message
stringlengths 2
39.6k
| message_type
stringclasses 2
values | message_id
int64 0
1
| conversation_id
int64 219
108k
| cluster
float64 11
11
| __index_level_0__
int64 438
217k
|
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A: Information Search
problem
The posting list is a list in which there is a correspondence between the search term and the appearing document ID. For example
* Hokkaido: 1, 2, 4, 9
* Sightseeing: 1, 3, 4, 7
And so on.
From the above posting list, if you search for and, the document with ID 1, 4 will be hit, and if you search for or, ID 1, 2, 3, 4, 7, 9 will be hit.
Here, and search means "listing elements contained in either list", or search means "listing elements contained in at least one of the lists".
Since the posting list is given, output the results of and search and or search respectively.
Input format
n m
a_1 a_2 $ \ ldots $ a_n
b_1 b_2 $ \ ldots $ b_m
All inputs consist of integers.
The first line gives the lengths n and m of the two posting lists to search, separated by spaces.
The second and third lines are given the IDs contained in their respective posting lists, separated by blanks.
Constraint
* 1 \ leq n, m \ leq 2 \ times 10 ^ 5
* a_i <a_j (i <j)
* b_i <b_j (i <j)
* 1 \ leq a_i, b_i \ leq 10 ^ 9
Output format
Let A be the number of hits in the and search, and B be the number of hits in the or search.
Print on the first line in the order A B, separated by blanks.
Output the IDs hit by and search on the following line A in ascending order.
Output the IDs hit by or search on the following B line in ascending order.
Input example 1
4 4
1 2 4 9
1 3 4 7
Output example 1
2 6
1
Four
1
2
3
Four
7
9
Input example 2
4 4
1 3 5 7
2 4 6 8
Output example 2
0 8
1
2
3
Four
Five
6
7
8
Input example 3
3 5
one two Three
1 2 3 4 5
Output example 3
3 5
1
2
3
1
2
3
Four
Five
Example
Input
4 4
1 2 4 9
1 3 4 7
Output
2 6
1
4
1
2
3
4
7
9
Submitted Solution:
```
n,m = map(int,input().split())
a = set(map(int,input().split()))
b = set(map(int,input().split()))
i = sorted(a&b)
u = sorted(a|b)
print(len(i),len(u))
for x in i:
print(x)
for x in u:
print(x)
```
|
instruction
| 0
| 93,511
| 11
| 187,022
|
Yes
|
output
| 1
| 93,511
| 11
| 187,023
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
|
instruction
| 0
| 93,660
| 11
| 187,320
|
Tags: math
Correct Solution:
```
from math import *
from sys import stdin,stdout
# input = stdin.readline
for __ in range(int(input())):
n,m=map(int,input().split())
if(min(n,m)<=1 or (n==2 and m==2)):
print("YES")
else:
print("NO")
```
|
output
| 1
| 93,660
| 11
| 187,321
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
|
instruction
| 0
| 93,661
| 11
| 187,322
|
Tags: math
Correct Solution:
```
for t in range(int(input())):
a,b = map(int,input().split())
if a==b==2:
print('Yes')
elif a == 1 or b == 1: print('Yes')
else: print('No')
```
|
output
| 1
| 93,661
| 11
| 187,323
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
|
instruction
| 0
| 93,662
| 11
| 187,324
|
Tags: math
Correct Solution:
```
z=input
from math import *
for _ in range(int(z())):
a,b=map(int,z().split())
if a==b<=2 or a==1 or b==1:
print('YES')
else:
print('NO')
```
|
output
| 1
| 93,662
| 11
| 187,325
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
|
instruction
| 0
| 93,663
| 11
| 187,326
|
Tags: math
Correct Solution:
```
t = int(input())
for x in range(t):
wejscie = str(input())
a, b = wejscie.split()
a = int(a)
b = int(b)
if a == 1 or b == 1:
print("YES")
else:
if a <= 2 and b <= 2:
print("YES")
else:
print("NO")
```
|
output
| 1
| 93,663
| 11
| 187,327
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
|
instruction
| 0
| 93,664
| 11
| 187,328
|
Tags: math
Correct Solution:
```
for _ in range(int(input())):
# n = int(input())
n, m = list(map(int, input().split()))
# arr = list(map(str, input().split()))
# arr = list(input())
# temp1 = temp2 = stars = stars1 = flag = 0
if n == 1 or m == 1 :
print('YES')
elif n + m <= 4:
print('YES')
else:
print('NO')
```
|
output
| 1
| 93,664
| 11
| 187,329
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
|
instruction
| 0
| 93,665
| 11
| 187,330
|
Tags: math
Correct Solution:
```
import sys
input = sys.stdin.readline
t = int(input())
nm = [list(map(int, input().split())) for _ in range(t)]
for n, m in nm:
if n == 1 or m == 1:
print('YES')
elif n == 2 and m == 2:
print('YES')
else:
print('NO')
```
|
output
| 1
| 93,665
| 11
| 187,331
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
|
instruction
| 0
| 93,666
| 11
| 187,332
|
Tags: math
Correct Solution:
```
test=int(input())
for i in range(test):
n,m=input().split()
if n=="1" or m=="1" or (n=="2" and m=="2"):
print("YES")
else:
print("NO")
```
|
output
| 1
| 93,666
| 11
| 187,333
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
|
instruction
| 0
| 93,667
| 11
| 187,334
|
Tags: math
Correct Solution:
```
Times=int(input())
j=0
while j<Times:
s=input().split()
m=int(s[0])
n=int(s[1])
if m>n:
m,n=n,m
if m*n<=m+n:
print("YES")
else:
print("NO")
j+=1
```
|
output
| 1
| 93,667
| 11
| 187,335
|
Provide tags and a correct Python 2 solution for this coding contest problem.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
|
instruction
| 0
| 93,668
| 11
| 187,336
|
Tags: math
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
for t in range(input()):
n,m=in_arr()
if min(n,m)==1 or (n==2 and m==2):
pr('YES\n')
else:
pr('NO\n')
```
|
output
| 1
| 93,668
| 11
| 187,337
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
Submitted Solution:
```
t = int(input())
for i in range(t):
n,m = map(int,input().split())
if n==1 or m==1 or n==m==2:
print("YES")
else:
print("NO")
```
|
instruction
| 0
| 93,669
| 11
| 187,338
|
Yes
|
output
| 1
| 93,669
| 11
| 187,339
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
Submitted Solution:
```
def answer(n,m):
if n==1 or m==1:
return "YES"
elif n<=2 and m<=2:
return "YES"
else:
return "NO"
t=int(input())
for i in range(t):
n,m=map(int,input().split())
print(answer(n,m))
```
|
instruction
| 0
| 93,670
| 11
| 187,340
|
Yes
|
output
| 1
| 93,670
| 11
| 187,341
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
Submitted Solution:
```
for _ in range(int(input())):
n,m=map(int,input().split())
if n==1 or m==1:
print("YES")
elif n*m==4:
print("YES")
else:
print("NO")
```
|
instruction
| 0
| 93,671
| 11
| 187,342
|
Yes
|
output
| 1
| 93,671
| 11
| 187,343
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
Submitted Solution:
```
t = int(input())
for i in range(t):
n,m = map(int,input().split())
if(m*n>=2*m*n-m-n):
print("YES")
else:
print("NO")
```
|
instruction
| 0
| 93,672
| 11
| 187,344
|
Yes
|
output
| 1
| 93,672
| 11
| 187,345
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
Submitted Solution:
```
for _ in range(int(input())):
n,m=map(int,input().split())
if n>2 and m==1 or m>2 and n==1:
print('YES')
elif n==2 and m==2:
print('YES')
else:
print('NO')
```
|
instruction
| 0
| 93,673
| 11
| 187,346
|
No
|
output
| 1
| 93,673
| 11
| 187,347
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
Submitted Solution:
```
# import sys
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
for _ in range(int(input())):
n,m = map(int,input().split())
if (min(n,m)<=2):
print('YES')
else:
print('NO')
```
|
instruction
| 0
| 93,674
| 11
| 187,348
|
No
|
output
| 1
| 93,674
| 11
| 187,349
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
Submitted Solution:
```
for _ in range(int(input())):
n,m = map(int,input().split())
if(n>2 and m>2):
print("NO")
else:
print("YES")
```
|
instruction
| 0
| 93,675
| 11
| 187,350
|
No
|
output
| 1
| 93,675
| 11
| 187,351
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
Submitted Solution:
```
t = int(input())
for _ in range(t):
n, m = (int(i) for i in input().split())
if(n == 1 or n == 2 or m == 1 or m == 2):
print("YES")
else:
print("NO")
```
|
instruction
| 0
| 93,676
| 11
| 187,352
|
No
|
output
| 1
| 93,676
| 11
| 187,353
|
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
for t in range(input()):
if min(in_arr())>2:
pr('NO\n')
else:
pr('YES\n')
```
|
instruction
| 0
| 93,677
| 11
| 187,354
|
No
|
output
| 1
| 93,677
| 11
| 187,355
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
|
instruction
| 0
| 93,699
| 11
| 187,398
|
Tags: brute force, dp, greedy, sortings, two pointers
Correct Solution:
```
# Enter your code here. Read input from STDIN. Print output to STDOUT# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import ceil, floor
from copy import *
from collections import deque, defaultdict
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
from operator import *
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O region
BUFSIZE = 8192
from sys import stderr
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
# ===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
###########################
# Sorted list
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
# ===============================================================================================
# some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def fsep(): return map(float, inp().split())
def nextline(): out("\n") # as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def pow(x, y, p):
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0):
return 0
while (y > 0):
if ((y & 1) == 1): # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
from functools import reduce
def factors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
def gcd(a, b):
if a == b: return a
while b > 0: a, b = b, a % b
return a
# discrete binary search
# minimise:
# def search():
# l = 0
# r = 10 ** 15
#
# for i in range(200):
# if isvalid(l):
# return l
# if l == r:
# return l
# m = (l + r) // 2
# if isvalid(m) and not isvalid(m - 1):
# return m
# if isvalid(m):
# r = m + 1
# else:
# l = m
# return m
# maximise:
# def search():
# l = 0
# r = 10 ** 15
#
# for i in range(200):
# # print(l,r)
# if isvalid(r):
# return r
# if l == r:
# return l
# m = (l + r) // 2
# if isvalid(m) and not isvalid(m + 1):
# return m
# if isvalid(m):
# l = m
# else:
# r = m - 1
# return m
##############Find sum of product of subsets of size k in a array
# ar=[0,1,2,3]
# k=3
# n=len(ar)-1
# dp=[0]*(n+1)
# dp[0]=1
# for pos in range(1,n+1):
# dp[pos]=0
# l=max(1,k+pos-n-1)
# for j in range(min(pos,k),l-1,-1):
# dp[j]=dp[j]+ar[pos]*dp[j-1]
# print(dp[k])
def prefix_sum(ar): # [1,2,3,4]->[1,3,6,10]
return list(accumulate(ar))
def suffix_sum(ar): # [1,2,3,4]->[10,9,7,4]
return list(accumulate(ar[::-1]))[::-1]
def N():
return int(inp())
dx = [0, 0, 1, -1]
dy = [1, -1, 0, 0]
def YES():
print("YES")
def NO():
print("NO")
def Yes():
print("Yes")
def No():
print("No")
# =========================================================================================
from collections import defaultdict
def numberOfSetBits(i):
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24
def lcm(a, b):
return abs((a // gcd(a, b)) * b)
#
# # to find factorial and ncr
# tot = 400005
# mod = 10 ** 9 + 7
# fac = [1, 1]
# finv = [1, 1]
# inv = [0, 1]
#
# for i in range(2, tot + 1):
# fac.append((fac[-1] * i) % mod)
# inv.append(mod - (inv[mod % i] * (mod // i) % mod))
# finv.append(finv[-1] * inv[-1] % mod)
#
#
# def comb(n, r):
# if n < r:
# return 0
# else:
# return fac[n] * (finv[r] * finv[n - r] % mod) % mod
def solve():
n,m,k=sep()
a=[lis() for _ in range(m)]
def solv(lst):
res = sum(lst[:k]);
s = res
for i in range(n - k): s += lst[i + k] - lst[i];res = max(res, s)
return res
a.sort(key=lambda x: sum(x) / 2);
apr = [0] * n
for el in a:
for i in range(el[0] - 1, el[1]): apr[i] += 1
res = solv(apr);
bpr = [0] * n
for r, l in a:
for i in range(r - 1, l): apr[i] -= 1;bpr[i] += 1
nres = solv(apr) + solv(bpr);
res = max(res, nres)
print(res)
solve()
#testcase(int(inp()))
# 5
# 3 6
# 5 10
# 4 3
# 2 1
# 1 3
```
|
output
| 1
| 93,699
| 11
| 187,399
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
|
instruction
| 0
| 93,700
| 11
| 187,400
|
Tags: brute force, dp, greedy, sortings, two pointers
Correct Solution:
```
# Enter your code here. Read input from STDIN. Print output to STDOUT# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import ceil, floor
from copy import *
from collections import deque, defaultdict
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
from operator import *
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O region
BUFSIZE = 8192
from sys import stderr
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
def solve():
n, m, k = map(int, input().split());a = [list(map(int, input().split())) for _ in range(m)]
def solv(lst):
res = sum(lst[:k]);s = res
for i in range(n-k):s += lst[i+k] - lst[i];res = max(res, s)
return res
a.sort(key=lambda x: sum(x)/2);apr = [0]*n
for el in a:
for i in range(el[0]-1, el[1]):apr[i] += 1
res = solv(apr);bpr = [0]*n
for r, l in a:
for i in range(r-1, l):apr[i] -= 1;bpr[i] += 1
nres = solv(apr) + solv(bpr);res = max(res, nres)
print(res)
solve()
#testcase(int(inp()))
# 5
# 3 6
# 5 10
# 4 3
# 2 1
# 1 3
```
|
output
| 1
| 93,700
| 11
| 187,401
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
|
instruction
| 0
| 93,701
| 11
| 187,402
|
Tags: brute force, dp, greedy, sortings, two pointers
Correct Solution:
```
"""
#If FastIO not needed, use this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
import time
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
self.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")
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
#start_time = time.time()
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def getMat(n):
return [getInts() for _ in range(n)]
MOD = 10**9+7
"""
Two subsets of length K which cover as many segments as possible
How many times does a problem appear?
Suppose one of the segments goes from [p,p+k-1]
How many problems for each participant are in that segment?
We want two overlapping segments such that the sum of the max for each person is maximised
Best possible answer from first i arrays?
Note that overlap is pointless
So the answer is to find a dividing line, and find the best array either side of that line
"""
def solve():
N, M, K = getInts()
A = []
for m in range(M):
A.append(tuple(getInts()))
A.sort(key = lambda x: sum(x))
def get_poss(arr):
curr = sum(arr[:K])
best = curr
for i in range(K,N):
curr += arr[i] - arr[i-K]
best = max(best,curr)
return best
A_pref = [0]*N
for L, R in A:
for i in range(L-1,R):
A_pref[i] += 1
ans = get_poss(A_pref)
B_pref = [0]*N
for L, R in A:
for i in range(L-1,R):
A_pref[i] -= 1
B_pref[i] += 1
ans = max(ans,get_poss(A_pref) + get_poss(B_pref))
return ans
#for _ in range(getInt()):
print(solve())
#solve()
#print(time.time()-start_time)
```
|
output
| 1
| 93,701
| 11
| 187,403
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
|
instruction
| 0
| 93,702
| 11
| 187,404
|
Tags: brute force, dp, greedy, sortings, two pointers
Correct Solution:
```
def solve(lst, n, k):
sum_current = sum(lst[0:k])
ans = sum_current
for i in range(n - k):
sum_current = sum_current - lst[i] + lst[i + k]
ans = max(ans, sum_current)
return ans
def two_editorials():
n, m, k = [int(x) for x in input().split(' ')]
arr = [0] * n
brr = [0] * n
inp = []
for _ in range(m):
inp += [[int(x) for x in input().split(' ')]]
inp.sort(key=lambda x: sum(x) / 2)
for a, b in inp:
for i in range(a - 1, b):
arr[i] += 1
ans = solve(arr, n, k)
for a, b in inp:
for i in range(a - 1, b):
arr[i] -= 1
brr[i] += 1
ans = max(ans, solve(arr, n, k) + solve(brr, n, k))
print(ans)
if __name__ == "__main__":
two_editorials()
```
|
output
| 1
| 93,702
| 11
| 187,405
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
|
instruction
| 0
| 93,703
| 11
| 187,406
|
Tags: brute force, dp, greedy, sortings, two pointers
Correct Solution:
```
n, m, k = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(m)]
def solv(lst):
res = sum(lst[:k])
s = res
for i in range(n-k):
s += lst[i+k] - lst[i]
res = max(res, s)
return res
a.sort(key=lambda x: sum(x)/2)
apr = [0]*n
for el in a:
for i in range(el[0]-1, el[1]):
apr[i] += 1
res = solv(apr)
bpr = [0]*n
for r, l in a:
for i in range(r-1, l):
apr[i] -= 1
bpr[i] += 1
nres = solv(apr) + solv(bpr)
res = max(res, nres)
print(res)
```
|
output
| 1
| 93,703
| 11
| 187,407
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
|
instruction
| 0
| 93,704
| 11
| 187,408
|
Tags: brute force, dp, greedy, sortings, two pointers
Correct Solution:
```
import sys
BUFSIZE = 8192
from sys import stderr
from io import BytesIO, IOBase
import os
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
def solve():
n, m, k = map(int, input().split());a = [list(map(int, input().split())) for _ in range(m)]
def solv(lst):
res = sum(lst[:k]);s = res
for i in range(n-k):s += lst[i+k] - lst[i];res = max(res, s)
return res
a.sort(key=lambda x: sum(x)/2);apr = [0]*n
for el in a:
for i in range(el[0]-1, el[1]):apr[i] += 1
res = solv(apr);bpr = [0]*n
for r, l in a:
for i in range(r-1, l):apr[i] -= 1;bpr[i] += 1
nres = solv(apr) + solv(bpr);res = max(res, nres)
print(res)
solve()
#testcase(int(inp()))
# 5
# 3 6
# 5 10
# 4 3
# 2 1
# 1 3
```
|
output
| 1
| 93,704
| 11
| 187,409
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
|
instruction
| 0
| 93,705
| 11
| 187,410
|
Tags: brute force, dp, greedy, sortings, two pointers
Correct Solution:
```
# Enter your code here. Read input from STDIN. Print output to STDOUT# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import ceil, floor
from copy import *
from collections import deque, defaultdict
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
from operator import *
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O region
BUFSIZE = 8192
from sys import stderr
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
# ===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
###########################
# Sorted list
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
# ===============================================================================================
# some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def fsep(): return map(float, inp().split())
def nextline(): out("\n") # as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def pow(x, y, p):
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0):
return 0
while (y > 0):
if ((y & 1) == 1): # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
from functools import reduce
def factors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
def gcd(a, b):
if a == b: return a
while b > 0: a, b = b, a % b
return a
# discrete binary search
# minimise:
# def search():
# l = 0
# r = 10 ** 15
#
# for i in range(200):
# if isvalid(l):
# return l
# if l == r:
# return l
# m = (l + r) // 2
# if isvalid(m) and not isvalid(m - 1):
# return m
# if isvalid(m):
# r = m + 1
# else:
# l = m
# return m
# maximise:
# def search():
# l = 0
# r = 10 ** 15
#
# for i in range(200):
# # print(l,r)
# if isvalid(r):
# return r
# if l == r:
# return l
# m = (l + r) // 2
# if isvalid(m) and not isvalid(m + 1):
# return m
# if isvalid(m):
# l = m
# else:
# r = m - 1
# return m
##############Find sum of product of subsets of size k in a array
# ar=[0,1,2,3]
# k=3
# n=len(ar)-1
# dp=[0]*(n+1)
# dp[0]=1
# for pos in range(1,n+1):
# dp[pos]=0
# l=max(1,k+pos-n-1)
# for j in range(min(pos,k),l-1,-1):
# dp[j]=dp[j]+ar[pos]*dp[j-1]
# print(dp[k])
def prefix_sum(ar): # [1,2,3,4]->[1,3,6,10]
return list(accumulate(ar))
def suffix_sum(ar): # [1,2,3,4]->[10,9,7,4]
return list(accumulate(ar[::-1]))[::-1]
def N():
return int(inp())
dx = [0, 0, 1, -1]
dy = [1, -1, 0, 0]
def YES():
print("YES")
def NO():
print("NO")
def Yes():
print("Yes")
def No():
print("No")
# =========================================================================================
from collections import defaultdict
def numberOfSetBits(i):
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24
def lcm(a, b):
return abs((a // gcd(a, b)) * b)
#
# # to find factorial and ncr
# tot = 400005
# mod = 10 ** 9 + 7
# fac = [1, 1]
# finv = [1, 1]
# inv = [0, 1]
#
# for i in range(2, tot + 1):
# fac.append((fac[-1] * i) % mod)
# inv.append(mod - (inv[mod % i] * (mod // i) % mod))
# finv.append(finv[-1] * inv[-1] % mod)
#
#
# def comb(n, r):
# if n < r:
# return 0
# else:
# return fac[n] * (finv[r] * finv[n - r] % mod) % mod
def solve():
n, m, k = map(int, input().split());a = [list(map(int, input().split())) for _ in range(m)]
def solv(lst):
res = sum(lst[:k]);s = res
for i in range(n-k):s += lst[i+k] - lst[i];res = max(res, s)
return res
a.sort(key=lambda x: sum(x)/2);apr = [0]*n
for el in a:
for i in range(el[0]-1, el[1]):apr[i] += 1
res = solv(apr);bpr = [0]*n
for r, l in a:
for i in range(r-1, l):apr[i] -= 1;bpr[i] += 1
nres = solv(apr) + solv(bpr);res = max(res, nres)
print(res)
solve()
#testcase(int(inp()))
# 5
# 3 6
# 5 10
# 4 3
# 2 1
# 1 3
```
|
output
| 1
| 93,705
| 11
| 187,411
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
|
instruction
| 0
| 93,706
| 11
| 187,412
|
Tags: brute force, dp, greedy, sortings, two pointers
Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
def prog():
n,m,k = map(int,input().split())
intervals = [list(map(int,input().split())) for i in range(m)]
for i in range(m):
intervals[i][0] -= 1
intervals[i][1] -= 1
mx = 0
for i in range(n-k+1):
curr = 0
change = 0
events = [0]*(2*n+1)
for interval in intervals:
length = interval[1] - interval[0] + 1
if i <= interval[0] <= interval[1] <= i+k-1:
curr += length
elif interval[0] <= i <= i+k-1 <= interval[1]:
curr += k
elif i <= interval[0] <= i+k-1 or i <= interval[1] <= i+k-1:
if i <= interval[0] <= i+k-1:
intersect = i+k-1 - interval[0] + 1
else:
intersect = interval[1] - i + 1
curr += intersect
events[interval[0] + intersect] += 1
events[interval[0] + k] -= 1
events[interval[1] + 1] -= 1
events[interval[1] + k + 1] += 1
else:
events[interval[0]] += 1
events[interval[0] + k] -= 1
events[interval[1] + 1] -= 1
events[interval[1] + k + 1] += 1
for j in range(n):
change += events[j]
curr += change
mx = max(mx,curr)
print(mx)
prog()
```
|
output
| 1
| 93,706
| 11
| 187,413
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
Submitted Solution:
```
import sys,os,io
input = sys.stdin.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n, m, k = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(m)]
A.sort(key = lambda x:x[0]+x[1])
table = [[0]*m for _ in range(n-k+1)]
for i in range(n-k+1): #i+1~i+k
for j in range(m):
lower = max(i+1, A[j][0])
upper = min(i+k, A[j][1])
table[i][j] = max(0,upper-lower+1)
from copy import deepcopy
cum1 = deepcopy(table)
cum2 = deepcopy(table)
ans = 0
for i in range(n-k+1):
for j in range(1,m):
cum1[i][j] += cum1[i][j-1]
for i in range(n-k+1):
for j in range(m-2,-1,-1):
cum2[i][j] += cum2[i][j+1]
# ans = max([cum1[i][-1] for i in range(n-k+1)])
ans = max([cum2[i][0] for i in range(n-k+1)])
for j in range(m-1):
left = max([cum1[i][j] for i in range(n-k+1)])
right = max([cum2[i][j+1] for i in range(n-k+1)])
ans = max(ans, left+right)
print(ans)
```
|
instruction
| 0
| 93,707
| 11
| 187,414
|
Yes
|
output
| 1
| 93,707
| 11
| 187,415
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
Submitted Solution:
```
n, m, k = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(m)]
A.sort(key = lambda x:x[0]+x[1])
table = [[0]*m for _ in range(n-k+1)]
for i in range(n-k+1): #i+1~i+k
for j in range(m):
lower = max(i+1, A[j][0])
upper = min(i+k, A[j][1])
table[i][j] = max(0,upper-lower+1)
from copy import deepcopy
cum1 = deepcopy(table)
cum2 = deepcopy(table)
ans = 0
for i in range(n-k+1):
for j in range(1,m):
cum1[i][j] += cum1[i][j-1]
for i in range(n-k+1):
for j in range(m-2,-1,-1):
cum2[i][j] += cum2[i][j+1]
ans = max([cum1[i][-1] for i in range(n-k+1)])
ans = max(ans,max([cum2[i][0] for i in range(n-k+1)]))
for j in range(m-1):
left = max([cum1[i][j] for i in range(n-k+1)])
right = max([cum2[i][j+1] for i in range(n-k+1)])
ans = max(ans, left+right)
print(ans)
```
|
instruction
| 0
| 93,708
| 11
| 187,416
|
Yes
|
output
| 1
| 93,708
| 11
| 187,417
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
Submitted Solution:
```
import sys,os,io
input = sys.stdin.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n, m, k = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(m)]
A.sort(key = lambda x:x[0]+x[1])
table = [[0]*m for _ in range(n-k+1)]
for i in range(n-k+1): #i+1~i+k
for j in range(m):
lower = max(i+1, A[j][0])
upper = min(i+k, A[j][1])
table[i][j] = max(0,upper-lower+1)
from copy import deepcopy
cum1 = deepcopy(table)
cum2 = deepcopy(table)
for i in range(n-k+1):
for j in range(1,m):
cum1[i][j] += cum1[i][j-1]
for i in range(n-k+1):
for j in range(m-2,-1,-1):
cum2[i][j] += cum2[i][j+1]
# mが1の場合を考慮
ans = max([cum1[i][-1] for i in range(n-k+1)])
for j in range(m-1):
left = max([cum1[i][j] for i in range(n-k+1)])
right = max([cum2[i][j+1] for i in range(n-k+1)])
ans = max(ans, left+right)
print(ans)
```
|
instruction
| 0
| 93,709
| 11
| 187,418
|
Yes
|
output
| 1
| 93,709
| 11
| 187,419
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
Submitted Solution:
```
import sys,os,io
input = sys.stdin.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n, m, k = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(m)]
A.sort(key = lambda x:x[0]+x[1])
table = [[0]*m for _ in range(n-k+1)]
for i in range(n-k+1): #i+1~i+k
for j in range(m):
lower = max(i+1, A[j][0])
upper = min(i+k, A[j][1])
table[i][j] = max(0,upper-lower+1)
from copy import deepcopy
cum1 = deepcopy(table)
cum2 = deepcopy(table)
ans = 0
for i in range(n-k+1):
for j in range(1,m):
cum1[i][j] += cum1[i][j-1]
for i in range(n-k+1):
for j in range(m-2,-1,-1):
cum2[i][j] += cum2[i][j+1]
ans = max([cum1[i][-1] for i in range(n-k+1)])
# ans = max(ans,max([cum2[i][0] for i in range(n-k+1)]))
for j in range(m-1):
left = max([cum1[i][j] for i in range(n-k+1)])
right = max([cum2[i][j+1] for i in range(n-k+1)])
ans = max(ans, left+right)
print(ans)
```
|
instruction
| 0
| 93,710
| 11
| 187,420
|
Yes
|
output
| 1
| 93,710
| 11
| 187,421
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
Submitted Solution:
```
n, m, k = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(m)]
A.sort(key = lambda x:x[0]+x[1])
table = [[0]*m for _ in range(n-k+1)]
for i in range(n-k+1): #i+1~i+k
for j in range(m):
lower = max(i+1, A[j][0])
upper = min(i+k, A[j][1])
table[i][j] = max(0,upper-lower+1)
from copy import deepcopy
cum1 = deepcopy(table)
cum2 = deepcopy(table)
ans = 0
for i in range(n-k+1):
for j in range(1,m):
cum1[i][j] += cum1[i][j-1]
for i in range(n-k+1):
for j in range(m-2,-1,-1):
cum2[i][j] += cum2[i][j+1]
for j in range(m-1):
left = max([cum1[i][j] for i in range(n-k+1)])
right = max([cum2[i][j+1] for i in range(n-k+1)])
ans = max(ans, left+right)
print(ans)
```
|
instruction
| 0
| 93,711
| 11
| 187,422
|
No
|
output
| 1
| 93,711
| 11
| 187,423
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
Submitted Solution:
```
from sys import stdin
def inverse(a,mod):
return pow(a,mod-2,mod)
n,m,k = map(int,stdin.readline().split())
ans = 0
lr = []
for i in range(m):
l,r = map(int,stdin.readline().split())
lr.append((l-1,r-1))
for D1 in range(0,n-k+1):
now = 0
nch = 0
ch = [0] * (n-k+1)
for l,r in lr:
L,R = l,r+1
if D1 >= R or L >= D1+k:
X = 0
elif D1 <= L <= D1+k <= R:
X = D1+k-L
elif L <= D1 <= R <= D1+k:
X = R-D1
else:
X = min(R-L,k)
now += X
tmp = [(l-k+X,1),(l,-1),(r+1-k,-1),(r+1-X,1)]
for i,j in tmp:
if i < 0:
now += j
elif i < n-k+1:
ch[i] += j
for i in range(n-k+1):
ans = max(ans,now)
now += nch
nch += ch[i]
print (ans)
```
|
instruction
| 0
| 93,712
| 11
| 187,424
|
No
|
output
| 1
| 93,712
| 11
| 187,425
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
Submitted Solution:
```
import sys,os,io
input = sys.stdin.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n, m, k = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(m)]
A.sort(key = lambda x:x[0]+x[1])
table = [[0]*m for _ in range(n-k+1)]
for i in range(n-k+1): #i+1~i+k
for j in range(m):
lower = max(i+1, A[j][0])
upper = min(i+k, A[j][1])
table[i][j] = max(0,upper-lower+1)
from copy import deepcopy
cum1 = deepcopy(table)
cum2 = deepcopy(table)
ans = 0
for i in range(n-k+1):
for j in range(1,m):
cum1[i][j] += cum1[i][j-1]
for i in range(n-k+1):
for j in range(m-2,-1,-1):
cum2[i][j] += cum2[i][j+1]
# ans = max([cum1[i][-1] for i in range(n-k+1)])
# ans = max([cum2[i][0] for i in range(n-k+1)])
for j in range(m-1):
left = max([cum1[i][j] for i in range(n-k+1)])
right = max([cum2[i][j+1] for i in range(n-k+1)])
ans = max(ans, left+right)
print(ans)
```
|
instruction
| 0
| 93,713
| 11
| 187,426
|
No
|
output
| 1
| 93,713
| 11
| 187,427
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland regional ICPC contest has just ended. There were m participants numbered from 1 to m, who competed on a problemset of n problems numbered from 1 to n.
Now the editorial is about to take place. There are two problem authors, each of them is going to tell the tutorial to exactly k consecutive tasks of the problemset. The authors choose the segment of k consecutive tasks for themselves independently of each other. The segments can coincide, intersect or not intersect at all.
The i-th participant is interested in listening to the tutorial of all consecutive tasks from l_i to r_i. Each participant always chooses to listen to only the problem author that tells the tutorials to the maximum number of tasks he is interested in. Let this maximum number be a_i. No participant can listen to both of the authors, even if their segments don't intersect.
The authors want to choose the segments of k consecutive tasks for themselves in such a way that the sum of a_i over all participants is maximized.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ n) — the number of problems, the number of participants and the length of the segment of tasks each of the problem authors plans to tell the tutorial to.
The i-th of the next m lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the segment of tasks the i-th participant is interested in listening to the tutorial to.
Output
Print a single integer — the maximum sum of a_i over all participants.
Examples
Input
10 5 3
1 3
2 4
6 9
6 9
1 8
Output
14
Input
10 3 3
2 4
4 6
3 5
Output
8
Input
4 4 1
3 3
1 1
2 2
4 4
Output
2
Input
5 4 5
1 2
2 3
3 4
4 5
Output
8
Note
In the first example the first author can tell the tutorial to problems from 1 to 3 and the second one — from 6 to 8. That way the sequence of a_i will be [3, 2, 3, 3, 3]. Notice that the last participant can't listen to both author, he only chooses the one that tells the maximum number of problems he's interested in.
In the second example the first one can tell problems 2 to 4, the second one — 4 to 6.
In the third example the first one can tell problems 1 to 1, the second one — 2 to 2. Or 4 to 4 and 3 to 3. Every pair of different problems will get the same sum of 2.
In the fourth example the first one can tell problems 1 to 5, the second one — 1 to 5 as well.
Submitted Solution:
```
n, m, k = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(m)]
A.sort(key = lambda x:x[0])
table = [[0]*m for _ in range(n-k+1)]
for i in range(n-k+1): #i+1~i+k
for j in range(m):
lower = max(i+1, A[j][0])
upper = min(i+k, A[j][1])
table[i][j] = max(0,upper-lower+1)
from copy import deepcopy
cum1 = deepcopy(table)
cum2 = deepcopy(table)
for i in range(n-k+1):
for j in range(1,m):
cum1[i][j] += cum1[i][j-1]
for i in range(n-k):
for j in range(m-2,-1,-1):
cum2[i][j] += cum2[i][j+1]
ans = 0
for j in range(m-1):
left = right = 0
for i in range(n-k+1):
left = max(left, cum1[i][j])
for i in range(n-k+1):
right = max(right, cum2[i][j+1])
ans = max(ans, left+right)
print(ans)
```
|
instruction
| 0
| 93,714
| 11
| 187,428
|
No
|
output
| 1
| 93,714
| 11
| 187,429
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem statement
Here are $ N $ sheets of paper. You want to scan all paper by using $ 3 $ scanners in parallel. Each piece of paper has a fixed scanning time, and the time it takes to scan the $ i $ th paper is $ T_i $. You can scan the paper in any order, but you cannot scan multiple papers at the same time with a $ 1 $ scanner.
Minimize the time it takes to finish scanning all paper and run out of scanners.
Constraint
$ 1 \ leq N \ leq 50 $
$ 1 \ leq T_i \ leq 50 $
All inputs are integers
sample
Sample input 1
Four
1
1
1
1
Sample output 1
2
<image>
Sample input 2
9
15
20
27
Four
Ten
7
34
30
36
Sample output 2
61
<image>
Sample input 3
6
20
18
46
16
9
48
Sample output 3
55
<image>
input
$ N $
$ T_1 $
$ T_2 $
$ T_3 $
$ \ vdots $
$ T_N $
output
Print the answer on the $ 1 $ line.
Example
Input
4
1
1
1
1
Output
2
Submitted Solution:
```
N = int(input())
ts = [int(input()) for i in range(N)]
ma = sum(ts) // 3 + 50
s = [[[0 for i in range(ma)] for j in range(ma)] for k in range(N + 1)]
for i in range(N):
for j in range(ma):
for k in range(j, ma):
p = [s[i][j][k] + ts[i]]
if(j >= ts[i]):
p.append(s[i][j - ts[i]][k])
if(k >= ts[i]):
p.append(s[i][j][k - ts[i]])
s[i + 1][j][k] = s[i + 1][k][j] = min(p)
i = 0
while True:
if(s[N][i][i] <= i):
break
i += 1
print(i)
```
|
instruction
| 0
| 95,237
| 11
| 190,474
|
No
|
output
| 1
| 95,237
| 11
| 190,475
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem statement
Here are $ N $ sheets of paper. You want to scan all paper by using $ 3 $ scanners in parallel. Each piece of paper has a fixed scanning time, and the time it takes to scan the $ i $ th paper is $ T_i $. You can scan the paper in any order, but you cannot scan multiple papers at the same time with a $ 1 $ scanner.
Minimize the time it takes to finish scanning all paper and run out of scanners.
Constraint
$ 1 \ leq N \ leq 50 $
$ 1 \ leq T_i \ leq 50 $
All inputs are integers
sample
Sample input 1
Four
1
1
1
1
Sample output 1
2
<image>
Sample input 2
9
15
20
27
Four
Ten
7
34
30
36
Sample output 2
61
<image>
Sample input 3
6
20
18
46
16
9
48
Sample output 3
55
<image>
input
$ N $
$ T_1 $
$ T_2 $
$ T_3 $
$ \ vdots $
$ T_N $
output
Print the answer on the $ 1 $ line.
Example
Input
4
1
1
1
1
Output
2
Submitted Solution:
```
import itertools
n=int(input())
dp=[[1<<30]*850 for _ in [0]*850]
dp[0][0]=0
t=[int(input()) for _ in[0]*n]
s=sum(t)
for i,j,k in itertools.product(range(n),range(s//3+1),range(s//2+1)):
dp[j][k]+=t[i]
if t[i]<=j and dp[j][k]>dp[j-t[i]][k]:dp[j][k]=dp[j-t[i]][k]
if t[i]<=k and dp[j][k]>dp[j][k-t[i]]:dp[j][k]=dp[j][k-t[i]]
a=1<<30
for i,j in itertools.product(range(s//3+1),range(s//2+1)):
a=min(a,max(i,j,s-i-j))
print(a)
```
|
instruction
| 0
| 95,238
| 11
| 190,476
|
No
|
output
| 1
| 95,238
| 11
| 190,477
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem statement
Here are $ N $ sheets of paper. You want to scan all paper by using $ 3 $ scanners in parallel. Each piece of paper has a fixed scanning time, and the time it takes to scan the $ i $ th paper is $ T_i $. You can scan the paper in any order, but you cannot scan multiple papers at the same time with a $ 1 $ scanner.
Minimize the time it takes to finish scanning all paper and run out of scanners.
Constraint
$ 1 \ leq N \ leq 50 $
$ 1 \ leq T_i \ leq 50 $
All inputs are integers
sample
Sample input 1
Four
1
1
1
1
Sample output 1
2
<image>
Sample input 2
9
15
20
27
Four
Ten
7
34
30
36
Sample output 2
61
<image>
Sample input 3
6
20
18
46
16
9
48
Sample output 3
55
<image>
input
$ N $
$ T_1 $
$ T_2 $
$ T_3 $
$ \ vdots $
$ T_N $
output
Print the answer on the $ 1 $ line.
Example
Input
4
1
1
1
1
Output
2
Submitted Solution:
```
# -*- coding: utf-8 -*-
N = int(input())
T = [int(input()) for i in range(N)]
T.sort(reverse = True)
machine = [0, 0, 0]
for t in T:
no = machine.index(min(machine))
machine[no] += t
print(max(machine))
```
|
instruction
| 0
| 95,239
| 11
| 190,478
|
No
|
output
| 1
| 95,239
| 11
| 190,479
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem statement
Here are $ N $ sheets of paper. You want to scan all paper by using $ 3 $ scanners in parallel. Each piece of paper has a fixed scanning time, and the time it takes to scan the $ i $ th paper is $ T_i $. You can scan the paper in any order, but you cannot scan multiple papers at the same time with a $ 1 $ scanner.
Minimize the time it takes to finish scanning all paper and run out of scanners.
Constraint
$ 1 \ leq N \ leq 50 $
$ 1 \ leq T_i \ leq 50 $
All inputs are integers
sample
Sample input 1
Four
1
1
1
1
Sample output 1
2
<image>
Sample input 2
9
15
20
27
Four
Ten
7
34
30
36
Sample output 2
61
<image>
Sample input 3
6
20
18
46
16
9
48
Sample output 3
55
<image>
input
$ N $
$ T_1 $
$ T_2 $
$ T_3 $
$ \ vdots $
$ T_N $
output
Print the answer on the $ 1 $ line.
Example
Input
4
1
1
1
1
Output
2
Submitted Solution:
```
N = int(input())
ts = [int(input()) for i in range(N)]
ts.sort()
ts.reverse()
ma = sum(ts) // 3 + 50
s = [[[0 for i in range(ma)] for j in range(ma)] for k in range(N + 1)]
for i in range(N):
for j in range(ma):
for k in range(ma):
p = [s[i][j][k] + ts[i]]
if(j >= ts[i]):
p.append(s[i][j - ts[i]][k])
if(k >= ts[i]):
p.append(s[i][j][k - ts[i]])
s[i + 1][j][k] = min(p)
i = 0
while True:
if(s[N][i][i] <= i):
break
i += 1
print(i)
```
|
instruction
| 0
| 95,240
| 11
| 190,480
|
No
|
output
| 1
| 95,240
| 11
| 190,481
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n positive integers. Find a non-empty subset of its elements such that their sum is even (i.e. divisible by 2) or determine that there is no such subset.
Both the given array and required subset may contain equal values.
Input
The first line contains a single integer t (1 ≤ t ≤ 100), number of test cases to solve. Descriptions of t test cases follow.
A description of each test case consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 100), length of array a.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100), elements of a. The given array a can contain equal values (duplicates).
Output
For each test case output -1 if there is no such subset of elements. Otherwise output positive integer k, number of elements in the required subset. Then output k distinct integers (1 ≤ p_i ≤ n), indexes of the chosen elements. If there are multiple solutions output any of them.
Example
Input
3
3
1 4 3
1
15
2
3 5
Output
1
2
-1
2
1 2
Note
There are three test cases in the example.
In the first test case, you can choose the subset consisting of only the second element. Its sum is 4 and it is even.
In the second test case, there is only one non-empty subset of elements consisting of the first element, however sum in it is odd, so there is no solution.
In the third test case, the subset consisting of all array's elements has even sum.
Submitted Solution:
```
t = int(input())
def solve(a):
n = len(a)
odds=[]
for j in range(n):
if a[j]%2==0:
print(1)
print(j+1)
return
else:
odds.append(j)
if len(odds)==2:
print(2)
print(odds[0]+1, odds[1]+1)
return
print(-1)
return
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
solve(a)
```
|
instruction
| 0
| 95,401
| 11
| 190,802
|
Yes
|
output
| 1
| 95,401
| 11
| 190,803
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program that consists of n instructions. Initially a single variable x is assigned to 0. Afterwards, the instructions are of two types:
* increase x by 1;
* decrease x by 1.
You are given m queries of the following format:
* query l r — how many distinct values is x assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
Then the description of t testcases follows.
The first line of each testcase contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of instructions in the program and the number of queries.
The second line of each testcase contains a program — a string of n characters: each character is either '+' or '-' — increment and decrement instruction, respectively.
Each of the next m lines contains two integers l and r (1 ≤ l ≤ r ≤ n) — the description of the query.
The sum of n over all testcases doesn't exceed 2 ⋅ 10^5. The sum of m over all testcases doesn't exceed 2 ⋅ 10^5.
Output
For each testcase print m integers — for each query l, r print the number of distinct values variable x is assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order.
Example
Input
2
8 4
-+--+--+
1 8
2 8
2 5
1 1
4 10
+-++
1 1
1 2
2 2
1 3
2 3
3 3
1 4
2 4
3 4
4 4
Output
1
2
4
4
3
3
4
2
3
2
1
2
2
2
Note
The instructions that remain for each query of the first testcase are:
1. empty program — x was only equal to 0;
2. "-" — x had values 0 and -1;
3. "---+" — x had values 0, -1, -2, -3, -2 — there are 4 distinct values among them;
4. "+--+--+" — the distinct values are 1, 0, -1, -2.
Submitted Solution:
```
import sys
t = int(sys.stdin.readline().strip())
for _ in range(t):
n, m = map(int, sys.stdin.readline().split())
s = sys.stdin.readline().strip()
psa = [0 for k in range(n+1)]
for j in range(1, n+1):
if s[j-1] == "+":
psa[j] = psa[j-1]+1
else:
psa[j] = psa[j-1]-1
sufMax = [0 for k in range(n+1)]
sufMin = [0 for k in range(n+1)]
preMax = [0 for k in range(n+1)]
preMin = [0 for k in range(n+1)]
sufMax[-1] = psa[-1]
sufMin[-1] = psa[-1]
preMax[1] = psa[1]
preMin[1] = psa[1]
for i in range(1, n+1):
preMax[i] = max(psa[i], preMax[i-1])
preMin[i] = min([psa[i], preMin[i-1]])
for i in range(n-1, 0, -1):
sufMax[i] = max(psa[i], sufMax[i+1])
sufMin[i] = min(psa[i], sufMin[i+1])
for j in range(m):
l, r = map(int, sys.stdin.readline().split())
bestMax = preMax[l-1]
bestMin = preMin[l-1]
if r == n:
print(bestMax - bestMin + 1)
else:
temp = psa[l-1]-psa[r]
bestMax = max(bestMax, sufMax[r+1]+temp)
bestMin = min(bestMin, sufMin[r+1]+temp)
print(bestMax-bestMin+1)
```
|
instruction
| 0
| 95,494
| 11
| 190,988
|
Yes
|
output
| 1
| 95,494
| 11
| 190,989
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program that consists of n instructions. Initially a single variable x is assigned to 0. Afterwards, the instructions are of two types:
* increase x by 1;
* decrease x by 1.
You are given m queries of the following format:
* query l r — how many distinct values is x assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
Then the description of t testcases follows.
The first line of each testcase contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of instructions in the program and the number of queries.
The second line of each testcase contains a program — a string of n characters: each character is either '+' or '-' — increment and decrement instruction, respectively.
Each of the next m lines contains two integers l and r (1 ≤ l ≤ r ≤ n) — the description of the query.
The sum of n over all testcases doesn't exceed 2 ⋅ 10^5. The sum of m over all testcases doesn't exceed 2 ⋅ 10^5.
Output
For each testcase print m integers — for each query l, r print the number of distinct values variable x is assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order.
Example
Input
2
8 4
-+--+--+
1 8
2 8
2 5
1 1
4 10
+-++
1 1
1 2
2 2
1 3
2 3
3 3
1 4
2 4
3 4
4 4
Output
1
2
4
4
3
3
4
2
3
2
1
2
2
2
Note
The instructions that remain for each query of the first testcase are:
1. empty program — x was only equal to 0;
2. "-" — x had values 0 and -1;
3. "---+" — x had values 0, -1, -2, -3, -2 — there are 4 distinct values among them;
4. "+--+--+" — the distinct values are 1, 0, -1, -2.
Submitted Solution:
```
'''
#python-io
'''
import sys
# need this
input = sys.stdin.readline
MAXN = 2 * 100_000 + 5
cnt, top, bot = [0]*MAXN, [[0]*MAXN for i in range(2)], [[0]*MAXN for i in range(2)]
def program(n, m, s):
for i in range(n):
if s[i] == '+': cnt[i+1] = cnt[i] + 1
else: cnt[i+1] = cnt[i] - 1
for i in range(1, n+1):
top[0][i] = bot[0][i] = top[1][i] = bot[1][i] = cnt[i]
for i in range(1, n+1):
top[0][i] = max(top[0][i], top[0][i-1])
bot[0][i] = min(bot[0][i], bot[0][i-1])
for i in range(n-1, -1, -1):
top[1][i] = max(top[1][i], top[1][i+1])
bot[1][i] = min(bot[1][i], bot[1][i+1])
for _ in range(m):
l, r = map(int, input().strip().split(' '))
diff = cnt[l-1] - cnt[r]
if r < n:
t = max(top[0][l-1], top[1][r+1] + diff)
b = min(bot[0][l-1], bot[1][r+1] + diff)
else:
t, b = top[0][l-1], bot[0][l-1]
# may not be necessary
sys.stdout.write(str(t-b+1) + '\n')
def main():
for t in range(int(input().strip())):
n, m = map(int, input().strip().split(' '))
s = input().strip()
program(n, m, s)
if __name__ == "__main__":
main()
```
|
instruction
| 0
| 95,495
| 11
| 190,990
|
Yes
|
output
| 1
| 95,495
| 11
| 190,991
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program that consists of n instructions. Initially a single variable x is assigned to 0. Afterwards, the instructions are of two types:
* increase x by 1;
* decrease x by 1.
You are given m queries of the following format:
* query l r — how many distinct values is x assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
Then the description of t testcases follows.
The first line of each testcase contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of instructions in the program and the number of queries.
The second line of each testcase contains a program — a string of n characters: each character is either '+' or '-' — increment and decrement instruction, respectively.
Each of the next m lines contains two integers l and r (1 ≤ l ≤ r ≤ n) — the description of the query.
The sum of n over all testcases doesn't exceed 2 ⋅ 10^5. The sum of m over all testcases doesn't exceed 2 ⋅ 10^5.
Output
For each testcase print m integers — for each query l, r print the number of distinct values variable x is assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order.
Example
Input
2
8 4
-+--+--+
1 8
2 8
2 5
1 1
4 10
+-++
1 1
1 2
2 2
1 3
2 3
3 3
1 4
2 4
3 4
4 4
Output
1
2
4
4
3
3
4
2
3
2
1
2
2
2
Note
The instructions that remain for each query of the first testcase are:
1. empty program — x was only equal to 0;
2. "-" — x had values 0 and -1;
3. "---+" — x had values 0, -1, -2, -3, -2 — there are 4 distinct values among them;
4. "+--+--+" — the distinct values are 1, 0, -1, -2.
Submitted Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from collections import defaultdict, deque, Counter
from math import sqrt, pi, ceil, log, inf, gcd, floor
from itertools import combinations, permutations
from bisect import *
from fractions import Fraction
from heapq import *
from random import randint
def main():
for _ in range(int(input())):
n, m = map(int,input().split())
a, x = [0], 0
for i in input().rstrip():
x += (i == "+") - (i == "-")
a.append(x)
maxl, minl = [a[0]], [a[0]]
for i in range(1, n + 1, 1):
maxl.append(max(maxl[-1], a[i]))
minl.append(min(minl[-1], a[i]))
maxr, minr = [a[n]], [a[n]]
for i in range(n - 1, -1, -1):
minr.append(min(minr[-1], a[i]))
maxr.append(max(maxr[-1], a[i]))
maxr.reverse()
minr.reverse()
b=[]
for i in range(m):
l, r = map(int, input().split())
if r == n:
b.append(maxl[l - 1] - minl[l - 1] + 1)
else:
z = a[r] - a[l - 1]
mi_l, ma_l, mi_r, ma_r = minl[l - 1], maxl[l - 1], minr[r + 1] - z, maxr[r + 1] - z
if min(ma_l, ma_r) < max(mi_l, mi_r):
b.append(ma_r - mi_r + ma_l - mi_l + 2)
else:
b.append(max(ma_l, ma_r) - min(mi_r, mi_l) + 1)
print(*b,sep="\n")
# 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")
if __name__ == "__main__":
main()
```
|
instruction
| 0
| 95,496
| 11
| 190,992
|
Yes
|
output
| 1
| 95,496
| 11
| 190,993
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program that consists of n instructions. Initially a single variable x is assigned to 0. Afterwards, the instructions are of two types:
* increase x by 1;
* decrease x by 1.
You are given m queries of the following format:
* query l r — how many distinct values is x assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
Then the description of t testcases follows.
The first line of each testcase contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of instructions in the program and the number of queries.
The second line of each testcase contains a program — a string of n characters: each character is either '+' or '-' — increment and decrement instruction, respectively.
Each of the next m lines contains two integers l and r (1 ≤ l ≤ r ≤ n) — the description of the query.
The sum of n over all testcases doesn't exceed 2 ⋅ 10^5. The sum of m over all testcases doesn't exceed 2 ⋅ 10^5.
Output
For each testcase print m integers — for each query l, r print the number of distinct values variable x is assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order.
Example
Input
2
8 4
-+--+--+
1 8
2 8
2 5
1 1
4 10
+-++
1 1
1 2
2 2
1 3
2 3
3 3
1 4
2 4
3 4
4 4
Output
1
2
4
4
3
3
4
2
3
2
1
2
2
2
Note
The instructions that remain for each query of the first testcase are:
1. empty program — x was only equal to 0;
2. "-" — x had values 0 and -1;
3. "---+" — x had values 0, -1, -2, -3, -2 — there are 4 distinct values among them;
4. "+--+--+" — the distinct values are 1, 0, -1, -2.
Submitted Solution:
```
#region Header
#!/usr/bin/env python3
# from typing import *
import sys
import io
import math
import collections
import decimal
import itertools
import bisect
import heapq
def input():
return sys.stdin.readline()[:-1]
# sys.setrecursionlimit(1000000)
#endregion
# _INPUT = """2
# 8 4
# -+--+--+
# 1 8
# 2 8
# 2 5
# 1 1
# 4 10
# +-++
# 1 1
# 1 2
# 2 2
# 1 3
# 2 3
# 3 3
# 1 4
# 2 4
# 3 4
# 4 4
# """
# sys.stdin = io.StringIO(_INPUT)
class BIT:
"""
Binary Indexed Tree (Fenwick Tree), 1-indexed
"""
def __init__(self, n):
"""
Parameters
----------
n : int
要素数。index は 0..n になる。
"""
self.size = n
self.data = [0] * (n+1)
# self.depth = n.bit_length()
def add(self, i, x):
while i <= self.size:
self.data[i] += x
i += i & -i
def get_sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def get_rsum(self, l, r):
"""
[l, r) の sum
"""
return self.get_sum(r) - self.get_sum(l-1)
class BIT_Max:
"""
Binary Indexed Tree (Fenwick Tree), 1-indexed
"""
def __init__(self, n):
"""
Parameters
----------
n : int
要素数。index は 0..n になる。
"""
self.size = n
self.data = [0] * (n+1)
# self.depth = n.bit_length()
def update(self, i, x):
while i <= self.size:
self.data[i] = max(x, self.data[i])
i += i & -i
def get_max(self, i):
# 1からiまで
s = 0
while i > 0:
s = max(s, self.data[i])
i -= i & -i
return s
class BIT_Min:
"""
Binary Indexed Tree (Fenwick Tree), 1-indexed
"""
def __init__(self, n):
"""
Parameters
----------
n : int
要素数。index は 0..n になる。
"""
self.size = n
self.data = [0] * (n+1)
# self.depth = n.bit_length()
def update(self, i, x):
while i <= self.size:
self.data[i] = min(x, self.data[i])
i += i & -i
def get_min(self, i):
# 1からiまで
s = 0
while i > 0:
s = min(s, self.data[i])
i -= i & -i
return s
def solve(N, M, S, Q):
bit_sum = BIT(N)
bit_max = BIT_Max(N)
bit_min = BIT_Min(N)
v = 0
for i in range(N):
if S[i] == '+':
v += 1
bit_sum.add(i+1, 1)
else:
v -= 1
bit_sum.add(i+1, -1)
bit_max.update(i+1, v)
bit_min.update(i+1, v)
last = v
bit_sum_r = BIT(N)
bit_max_r = BIT_Max(N)
bit_min_r = BIT_Min(N)
v = 0
for i in range(N):
if S[N-1-i] == '-':
v += 1
bit_sum_r.add(i+1, 1)
else:
v -= 1
bit_sum_r.add(i+1, -1)
bit_max_r.update(i+1, v)
bit_min_r.update(i+1, v)
for (l, r) in Q:
if r == N-1:
if l == 0:
print(1)
else:
max1 = bit_max.get_max(l)
min1 = bit_min.get_min(l)
print(max1 - min1 + 1)
else:
# [0, l) and [r, N+1)
max1 = bit_max.get_max(l)
min1 = bit_min.get_min(l)
a = bit_sum.get_sum(r+1) - bit_sum.get_sum(l)
max2 = bit_max_r.get_max(N-r-1) + last - a
min2 = bit_min_r.get_min(N-r-1) + last - a
print(max(max1, max2) - min(min1, min2) + 1)
def main():
T0 = int(input())
for _ in range(T0):
N, M = map(int, input().split())
S = input()
Q = []
for _ in range(M):
l, r = map(int, input().split())
Q.append((l-1, r-1))
solve(N, M, S, Q)
if __name__ == '__main__':
main()
```
|
instruction
| 0
| 95,497
| 11
| 190,994
|
Yes
|
output
| 1
| 95,497
| 11
| 190,995
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program that consists of n instructions. Initially a single variable x is assigned to 0. Afterwards, the instructions are of two types:
* increase x by 1;
* decrease x by 1.
You are given m queries of the following format:
* query l r — how many distinct values is x assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
Then the description of t testcases follows.
The first line of each testcase contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of instructions in the program and the number of queries.
The second line of each testcase contains a program — a string of n characters: each character is either '+' or '-' — increment and decrement instruction, respectively.
Each of the next m lines contains two integers l and r (1 ≤ l ≤ r ≤ n) — the description of the query.
The sum of n over all testcases doesn't exceed 2 ⋅ 10^5. The sum of m over all testcases doesn't exceed 2 ⋅ 10^5.
Output
For each testcase print m integers — for each query l, r print the number of distinct values variable x is assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order.
Example
Input
2
8 4
-+--+--+
1 8
2 8
2 5
1 1
4 10
+-++
1 1
1 2
2 2
1 3
2 3
3 3
1 4
2 4
3 4
4 4
Output
1
2
4
4
3
3
4
2
3
2
1
2
2
2
Note
The instructions that remain for each query of the first testcase are:
1. empty program — x was only equal to 0;
2. "-" — x had values 0 and -1;
3. "---+" — x had values 0, -1, -2, -3, -2 — there are 4 distinct values among them;
4. "+--+--+" — the distinct values are 1, 0, -1, -2.
Submitted Solution:
```
import sys
input=sys.stdin.readline
t = int(input())
while t:
ans = []
t -= 1
n, q = map(int, input().split())
s = input()
left = [[0, 0, 0]]
right = [[0, 0]]
now = plus = minus = 0
for i in s:
if i == "-":
now -= 1
if now < minus:
minus -= 1
elif i == "+":
now += 1
if now > plus:
plus += 1
left.append([plus, minus, now])
now = plus = minus = 0
a = b = 0
for i in s[::-1]:
if i == "-":
a -= 1
b -= 1
a = max(0, a)
elif i == "+":
a += 1
b += 1
b = min(b, 0)
right.append([a, b])
right = right[::-1]
print(left)
print(right)
for i in range(q):
l, r = map(int, input().split())
a, b, now = left[l - 1]
c, d = right[r]
print(a, b, now, c, d)
a = max(a, now + c)
b = min(b, now + d)
ans.append(a-b+1)
print(ans)
```
|
instruction
| 0
| 95,498
| 11
| 190,996
|
No
|
output
| 1
| 95,498
| 11
| 190,997
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program that consists of n instructions. Initially a single variable x is assigned to 0. Afterwards, the instructions are of two types:
* increase x by 1;
* decrease x by 1.
You are given m queries of the following format:
* query l r — how many distinct values is x assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
Then the description of t testcases follows.
The first line of each testcase contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of instructions in the program and the number of queries.
The second line of each testcase contains a program — a string of n characters: each character is either '+' or '-' — increment and decrement instruction, respectively.
Each of the next m lines contains two integers l and r (1 ≤ l ≤ r ≤ n) — the description of the query.
The sum of n over all testcases doesn't exceed 2 ⋅ 10^5. The sum of m over all testcases doesn't exceed 2 ⋅ 10^5.
Output
For each testcase print m integers — for each query l, r print the number of distinct values variable x is assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order.
Example
Input
2
8 4
-+--+--+
1 8
2 8
2 5
1 1
4 10
+-++
1 1
1 2
2 2
1 3
2 3
3 3
1 4
2 4
3 4
4 4
Output
1
2
4
4
3
3
4
2
3
2
1
2
2
2
Note
The instructions that remain for each query of the first testcase are:
1. empty program — x was only equal to 0;
2. "-" — x had values 0 and -1;
3. "---+" — x had values 0, -1, -2, -3, -2 — there are 4 distinct values among them;
4. "+--+--+" — the distinct values are 1, 0, -1, -2.
Submitted Solution:
```
import sys
#py import math
input = sys.stdin.readline
# x,y,z=map(int,input().split())
# a = list(map(int,input().split()))
# string = input().rstrip()
tests = int(input())
for test in range(tests):
n,m =map(int,input().split())
program = input().rstrip()
value = [0]
currentValue = 0
for step in program:
if step == "-":
currentValue += -1
else:
currentValue += 1
value.append(currentValue)
print(value)
for query in range(m):
l,r =map(int,input().split())
maxLeft = max(value[0:l])
minLeft = min(value[0:l])
if r == n:
print(maxLeft-minLeft+1)
else:
shift = value[l-1]-value[r]
maxValue = max(maxLeft , shift+max(value[r:]))
minValue = min(minLeft , shift+min(value[r:]))
print(maxValue-minValue+1)
```
|
instruction
| 0
| 95,499
| 11
| 190,998
|
No
|
output
| 1
| 95,499
| 11
| 190,999
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program that consists of n instructions. Initially a single variable x is assigned to 0. Afterwards, the instructions are of two types:
* increase x by 1;
* decrease x by 1.
You are given m queries of the following format:
* query l r — how many distinct values is x assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
Then the description of t testcases follows.
The first line of each testcase contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of instructions in the program and the number of queries.
The second line of each testcase contains a program — a string of n characters: each character is either '+' or '-' — increment and decrement instruction, respectively.
Each of the next m lines contains two integers l and r (1 ≤ l ≤ r ≤ n) — the description of the query.
The sum of n over all testcases doesn't exceed 2 ⋅ 10^5. The sum of m over all testcases doesn't exceed 2 ⋅ 10^5.
Output
For each testcase print m integers — for each query l, r print the number of distinct values variable x is assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order.
Example
Input
2
8 4
-+--+--+
1 8
2 8
2 5
1 1
4 10
+-++
1 1
1 2
2 2
1 3
2 3
3 3
1 4
2 4
3 4
4 4
Output
1
2
4
4
3
3
4
2
3
2
1
2
2
2
Note
The instructions that remain for each query of the first testcase are:
1. empty program — x was only equal to 0;
2. "-" — x had values 0 and -1;
3. "---+" — x had values 0, -1, -2, -3, -2 — there are 4 distinct values among them;
4. "+--+--+" — the distinct values are 1, 0, -1, -2.
Submitted Solution:
```
import math
import sys
input = sys.stdin.readline
T = int(input())
for t in range(T):
n,m=map(int,input().split())
script = input()
left=[(0,0,0)]
right=[[0,0]]
count=0
for i in range(len(script)):
if(script[i]=="+"):
count+=1
else:
count-=1
left.append((min(left[-1][0],count),count,max(left[-1][2],count)))
count=0
for i in range(len(script)-1,-1,-1):
k=[right[0][0],right[0][1]]
if(script[i]=="+"):
k[1]+=1
if(k[0]!=0):
k[0]+=1
else:
k[0]-=1
if(k[1]!=0):
k[1]-=1
right.insert(0,k)
for i in range(m):
a,b=map(int,input().split())
Min=min(left[a-1][0],left[a-1][1]+right[b][0])
Max=max(left[a-1][2],left[a-1][1]+right[b][1])
sys.stdout.write(str(Max-Min+1)+'\n')
```
|
instruction
| 0
| 95,500
| 11
| 191,000
|
No
|
output
| 1
| 95,500
| 11
| 191,001
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program that consists of n instructions. Initially a single variable x is assigned to 0. Afterwards, the instructions are of two types:
* increase x by 1;
* decrease x by 1.
You are given m queries of the following format:
* query l r — how many distinct values is x assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
Then the description of t testcases follows.
The first line of each testcase contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of instructions in the program and the number of queries.
The second line of each testcase contains a program — a string of n characters: each character is either '+' or '-' — increment and decrement instruction, respectively.
Each of the next m lines contains two integers l and r (1 ≤ l ≤ r ≤ n) — the description of the query.
The sum of n over all testcases doesn't exceed 2 ⋅ 10^5. The sum of m over all testcases doesn't exceed 2 ⋅ 10^5.
Output
For each testcase print m integers — for each query l, r print the number of distinct values variable x is assigned to if all the instructions between the l-th one and the r-th one inclusive are ignored and the rest are executed without changing the order.
Example
Input
2
8 4
-+--+--+
1 8
2 8
2 5
1 1
4 10
+-++
1 1
1 2
2 2
1 3
2 3
3 3
1 4
2 4
3 4
4 4
Output
1
2
4
4
3
3
4
2
3
2
1
2
2
2
Note
The instructions that remain for each query of the first testcase are:
1. empty program — x was only equal to 0;
2. "-" — x had values 0 and -1;
3. "---+" — x had values 0, -1, -2, -3, -2 — there are 4 distinct values among them;
4. "+--+--+" — the distinct values are 1, 0, -1, -2.
Submitted Solution:
```
def solve():
n, q = map(int, input().split())
instructions = input()
a = [0]*n
x = 0
for i in range(n):
if instructions[i] == '-':
x -= 1
else:
x += 1
a[i] = x
lmis = [0]*n
lmas = [0]*n
rmis = [0]*n
rmas = [0]*n
for i in range(n):
if i == 0:
lmis[i] = min(a[i], 0)
lmas[i] = max(a[i], 0)
continue
if a[i] < lmis[i-1]:
lmis[i] = a[i]
else:
lmis[i] = lmis[i-1]
if a[i] > lmas[i-1]:
lmas[i] = a[i]
else:
lmas[i] = lmas[i-1]
for i in reversed(range(n)):
if i == n-1:
rmis[i] = a[i]
rmas[i] = a[i]
continue
if a[i] < rmis[i+1]:
rmis[i] = a[i]
else:
rmis[i] = rmis[i+1]
if a[i] > rmas[i+1]:
rmas[i] = a[i]
else:
rmas[i] = rmas[i+1]
for _ in range(q):
l, r = map(int, input().split())
r -= 1
l -= 1
delta = a[r] - a[l]
if instructions[l] == '+':
delta += 1
else:
delta -= 1
lmi = 0
lma = 0
if(l > 0):
lmi = lmis[l-1]
lma = lmas[l-1]
rmi = rmis[r]
rma = rmas[r]
rmi -= delta
rma -= delta
mi = min(lmi, rmi)
ma = max(lma, rma)
print('ans', ma-mi+1)
t = int(input())
for _ in range(t):
solve()
```
|
instruction
| 0
| 95,501
| 11
| 191,002
|
No
|
output
| 1
| 95,501
| 11
| 191,003
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya tries to break in a safe. He knows that a code consists of n numbers, and every number is a 0 or a 1. Vasya has made m attempts to enter the code. After each attempt the system told him in how many position stand the right numbers. It is not said in which positions the wrong numbers stand. Vasya has been so unlucky that he hasn’t entered the code where would be more than 5 correct numbers. Now Vasya is completely bewildered: he thinks there’s a mistake in the system and it is self-contradictory. Help Vasya — calculate how many possible code variants are left that do not contradict the previous system responses.
Input
The first input line contains two integers n and m (6 ≤ n ≤ 35, 1 ≤ m ≤ 10) which represent the number of numbers in the code and the number of attempts made by Vasya. Then follow m lines, each containing space-separated si and ci which correspondingly indicate Vasya’s attempt (a line containing n numbers which are 0 or 1) and the system’s response (an integer from 0 to 5 inclusively).
Output
Print the single number which indicates how many possible code variants that do not contradict the m system responses are left.
Examples
Input
6 2
000000 2
010100 4
Output
6
Input
6 3
000000 2
010100 4
111100 0
Output
0
Input
6 3
000000 2
010100 4
111100 2
Output
1
|
instruction
| 0
| 95,653
| 11
| 191,306
|
Tags: brute force
Correct Solution:
```
import itertools
n,m=map(int,input().split())
def gen(s,d):
ans=[]
a=int(str(s),2)
A=int(a)
for i in itertools.combinations(list(range(n)), d):
c=A
for e in i:c=c ^ 1<<e
ans.append(c)
return ans
a,b=map(int,input().split())
cur=gen(a,b)
#print(cur)
for i in range(m-1):
a,b=map(int,input().split())
cur=[x for x in cur if(bin(x^int(str(a),2)).count("1")==b)]
#print(*cur)
print(len(cur))
```
|
output
| 1
| 95,653
| 11
| 191,307
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya tries to break in a safe. He knows that a code consists of n numbers, and every number is a 0 or a 1. Vasya has made m attempts to enter the code. After each attempt the system told him in how many position stand the right numbers. It is not said in which positions the wrong numbers stand. Vasya has been so unlucky that he hasn’t entered the code where would be more than 5 correct numbers. Now Vasya is completely bewildered: he thinks there’s a mistake in the system and it is self-contradictory. Help Vasya — calculate how many possible code variants are left that do not contradict the previous system responses.
Input
The first input line contains two integers n and m (6 ≤ n ≤ 35, 1 ≤ m ≤ 10) which represent the number of numbers in the code and the number of attempts made by Vasya. Then follow m lines, each containing space-separated si and ci which correspondingly indicate Vasya’s attempt (a line containing n numbers which are 0 or 1) and the system’s response (an integer from 0 to 5 inclusively).
Output
Print the single number which indicates how many possible code variants that do not contradict the m system responses are left.
Examples
Input
6 2
000000 2
010100 4
Output
6
Input
6 3
000000 2
010100 4
111100 0
Output
0
Input
6 3
000000 2
010100 4
111100 2
Output
1
|
instruction
| 0
| 95,654
| 11
| 191,308
|
Tags: brute force
Correct Solution:
```
import sys
from array import array # noqa: F401
from itertools import combinations
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n, m = map(int, input().split())
s = set()
x = set()
for i in range(m):
a, k = input().split()
k = int(k)
a = int(a, 2)
x.add(str(a))
cur_s = set()
for c in combinations(range(n), r=k):
mask = 0
for j in c:
mask |= (1 << j)
cur_s.add(str(a ^ mask))
if i == 0:
s = cur_s
else:
s.intersection_update(cur_s)
print(len(s - x))
```
|
output
| 1
| 95,654
| 11
| 191,309
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.