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 programming competition site AtCode provides algorithmic problems. Each problem is allocated a score based on its difficulty. Currently, for each integer i between 1 and D (inclusive), there are p_i problems with a score of 100i points. These p_1 + β¦ + p_D problems are all of the problems available on AtCode.
A user of AtCode has a value called total score. The total score of a user is the sum of the following two elements:
* Base score: the sum of the scores of all problems solved by the user.
* Perfect bonuses: when a user solves all problems with a score of 100i points, he/she earns the perfect bonus of c_i points, aside from the base score (1 β€ i β€ D).
Takahashi, who is the new user of AtCode, has not solved any problem. His objective is to have a total score of G or more points. At least how many problems does he need to solve for this objective?
Constraints
* 1 β€ D β€ 10
* 1 β€ p_i β€ 100
* 100 β€ c_i β€ 10^6
* 100 β€ G
* All values in input are integers.
* c_i and G are all multiples of 100.
* It is possible to have a total score of G or more points.
Input
Input is given from Standard Input in the following format:
D G
p_1 c_1
:
p_D c_D
Output
Print the minimum number of problems that needs to be solved in order to have a total score of G or more points. Note that this objective is always achievable (see Constraints).
Examples
Input
2 700
3 500
5 800
Output
3
Input
2 2000
3 500
5 800
Output
7
Input
2 400
3 500
5 800
Output
2
Input
5 25000
20 1000
40 1000
50 1000
30 1000
1 1000
Output
66
Submitted Solution:
```
dg = input().split(β β);
d = int(dg[0]);
g = int(dg[1]);
p = [0]*d;
c = [0]*d;
for i in range(d) :
s = input().split(β β);
p[i] = int(s[0]);
c[i] = int(s[1]);
ans = 0;
for i in range(sum(p)) :
sump = 0;
for j in range(len(p)) :
all = 0;
for m in range(p[j]) :
if(i & 2**(sump+m)>>(sump+m)) :
ans += (j+1)*100;
all += 1;
if(all == p[j]) :
ans += c[j];
sump += p[i];
print(ans);
``` | instruction | 0 | 2,314 | 11 | 4,628 |
No | output | 1 | 2,314 | 11 | 4,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A programming competition site AtCode provides algorithmic problems. Each problem is allocated a score based on its difficulty. Currently, for each integer i between 1 and D (inclusive), there are p_i problems with a score of 100i points. These p_1 + β¦ + p_D problems are all of the problems available on AtCode.
A user of AtCode has a value called total score. The total score of a user is the sum of the following two elements:
* Base score: the sum of the scores of all problems solved by the user.
* Perfect bonuses: when a user solves all problems with a score of 100i points, he/she earns the perfect bonus of c_i points, aside from the base score (1 β€ i β€ D).
Takahashi, who is the new user of AtCode, has not solved any problem. His objective is to have a total score of G or more points. At least how many problems does he need to solve for this objective?
Constraints
* 1 β€ D β€ 10
* 1 β€ p_i β€ 100
* 100 β€ c_i β€ 10^6
* 100 β€ G
* All values in input are integers.
* c_i and G are all multiples of 100.
* It is possible to have a total score of G or more points.
Input
Input is given from Standard Input in the following format:
D G
p_1 c_1
:
p_D c_D
Output
Print the minimum number of problems that needs to be solved in order to have a total score of G or more points. Note that this objective is always achievable (see Constraints).
Examples
Input
2 700
3 500
5 800
Output
3
Input
2 2000
3 500
5 800
Output
7
Input
2 400
3 500
5 800
Output
2
Input
5 25000
20 1000
40 1000
50 1000
30 1000
1 1000
Output
66
Submitted Solution:
```
D, G = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(D)]
def func(i, t):
if i == 0 or i > D:
return 10 ** 9
# Solve all problems, or part of them
k = min(t // (100 * i), X[i][0])
s = 100 * i * k
# If all problems are solved, add bonus
if k == X[i][0]:
s += X[i][1]
# If score < objective, go next step
if s < t:
k += func(i - 1, t - s)
# Select minimum number of solved problems
# k: solve i-th line
# func(i-1,t): pass i-th line
return min(k, func(i - 1, t))
# Solve backward
print(func(D, G))
``` | instruction | 0 | 2,315 | 11 | 4,630 |
No | output | 1 | 2,315 | 11 | 4,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A programming competition site AtCode provides algorithmic problems. Each problem is allocated a score based on its difficulty. Currently, for each integer i between 1 and D (inclusive), there are p_i problems with a score of 100i points. These p_1 + β¦ + p_D problems are all of the problems available on AtCode.
A user of AtCode has a value called total score. The total score of a user is the sum of the following two elements:
* Base score: the sum of the scores of all problems solved by the user.
* Perfect bonuses: when a user solves all problems with a score of 100i points, he/she earns the perfect bonus of c_i points, aside from the base score (1 β€ i β€ D).
Takahashi, who is the new user of AtCode, has not solved any problem. His objective is to have a total score of G or more points. At least how many problems does he need to solve for this objective?
Constraints
* 1 β€ D β€ 10
* 1 β€ p_i β€ 100
* 100 β€ c_i β€ 10^6
* 100 β€ G
* All values in input are integers.
* c_i and G are all multiples of 100.
* It is possible to have a total score of G or more points.
Input
Input is given from Standard Input in the following format:
D G
p_1 c_1
:
p_D c_D
Output
Print the minimum number of problems that needs to be solved in order to have a total score of G or more points. Note that this objective is always achievable (see Constraints).
Examples
Input
2 700
3 500
5 800
Output
3
Input
2 2000
3 500
5 800
Output
7
Input
2 400
3 500
5 800
Output
2
Input
5 25000
20 1000
40 1000
50 1000
30 1000
1 1000
Output
66
Submitted Solution:
```
import itertools
D,G = list(map(int,input().split()))
d = []
ans = (10e10)
for i in range(D):
a,b = list(map(int,input().split()))
d.append([100*(i+1) for j in range(a-1)])
d[i].append(100*(i+1)+b)
for ar in itertools.permutations(d):
num = cnt = 0
for i in ar:
if num+sum(i) < G:
num += sum(i)
cnt += len(i)
else:
for j in i:
if num+j < G:
num += j
cnt += 1
else:
ans = min(ans,cnt+1)
break
break
print(ans)
``` | instruction | 0 | 2,316 | 11 | 4,632 |
No | output | 1 | 2,316 | 11 | 4,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A programming competition site AtCode provides algorithmic problems. Each problem is allocated a score based on its difficulty. Currently, for each integer i between 1 and D (inclusive), there are p_i problems with a score of 100i points. These p_1 + β¦ + p_D problems are all of the problems available on AtCode.
A user of AtCode has a value called total score. The total score of a user is the sum of the following two elements:
* Base score: the sum of the scores of all problems solved by the user.
* Perfect bonuses: when a user solves all problems with a score of 100i points, he/she earns the perfect bonus of c_i points, aside from the base score (1 β€ i β€ D).
Takahashi, who is the new user of AtCode, has not solved any problem. His objective is to have a total score of G or more points. At least how many problems does he need to solve for this objective?
Constraints
* 1 β€ D β€ 10
* 1 β€ p_i β€ 100
* 100 β€ c_i β€ 10^6
* 100 β€ G
* All values in input are integers.
* c_i and G are all multiples of 100.
* It is possible to have a total score of G or more points.
Input
Input is given from Standard Input in the following format:
D G
p_1 c_1
:
p_D c_D
Output
Print the minimum number of problems that needs to be solved in order to have a total score of G or more points. Note that this objective is always achievable (see Constraints).
Examples
Input
2 700
3 500
5 800
Output
3
Input
2 2000
3 500
5 800
Output
7
Input
2 400
3 500
5 800
Output
2
Input
5 25000
20 1000
40 1000
50 1000
30 1000
1 1000
Output
66
Submitted Solution:
```
import itertools
def main():
d, g = list(map(int, input().split()))
problems = [list(map(int, input().split())) for _ in range(d)]
ptns = itertools.product([0, 1], repeat = d)
#print(list(ptns))
ans = sum([x[0] for x in problems])
if sum([(i + 1) * 100 * problems[i][0] for i in range(d)]) == g:
print(sum([x[1] for x in problems]))
return
for pt in ptns:
#print(pt)
rest = g - sum([((i + 1) * 100 * problems[i][0] + problems[i][1]) * pt[i] for i in range(d)])
tmp = sum([problems[i][0] * pt[i] for i in range(d)])
if rest > 0:
if 0 in pt:
rest_max_idx = d - pt[::-1].index(0) - 1
for i in range(1, problems[rest_max_idx][0]):
rest -= (rest_max_idx + 1) * 100
tmp += 1
if rest <= 0:
break
if rest <= 0:
ans = min(ans, tmp)
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 2,317 | 11 | 4,634 |
No | output | 1 | 2,317 | 11 | 4,635 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Joisino is working as a receptionist at a theater.
The theater has 100000 seats, numbered from 1 to 100000.
According to her memo, N groups of audiences have come so far, and the i-th group occupies the consecutive seats from Seat l_i to Seat r_i (inclusive).
How many people are sitting at the theater now?
Constraints
* 1β€Nβ€1000
* 1β€l_iβ€r_iβ€100000
* No seat is occupied by more than one person.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
l_1 r_1
:
l_N r_N
Output
Print the number of people sitting at the theater.
Examples
Input
1
24 30
Output
7
Input
2
6 8
3 3
Output
4
Submitted Solution:
```
n=int(input())
ans=0
for i in range(n):
ans+=~(eval(input().replace(' ','-')))+2
print(ans)
``` | instruction | 0 | 2,328 | 11 | 4,656 |
Yes | output | 1 | 2,328 | 11 | 4,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Joisino is working as a receptionist at a theater.
The theater has 100000 seats, numbered from 1 to 100000.
According to her memo, N groups of audiences have come so far, and the i-th group occupies the consecutive seats from Seat l_i to Seat r_i (inclusive).
How many people are sitting at the theater now?
Constraints
* 1β€Nβ€1000
* 1β€l_iβ€r_iβ€100000
* No seat is occupied by more than one person.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
l_1 r_1
:
l_N r_N
Output
Print the number of people sitting at the theater.
Examples
Input
1
24 30
Output
7
Input
2
6 8
3 3
Output
4
Submitted Solution:
```
n = int(input())
s = 0
for _ in range(n):
a, b = map(int, input().split())
s += (b - a + 1)
print(s)
``` | instruction | 0 | 2,329 | 11 | 4,658 |
Yes | output | 1 | 2,329 | 11 | 4,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n β€ 1000) on the first line, reception number pi (1 β€ pi β€ n) of the i-th subject on the following n lines, height hi in centimeters (1 β€ hi β€ 200), Given a kilogram of body weight wi (1 β€ wi β€ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2
Submitted Solution:
```
# Aizu Problem 00159: The Best Body
#
import sys, math, os, bisect
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
while True:
n = int(input())
if n == 0:
break
best = 999999999999999999
near = float('Inf')
for _ in range(n):
no, h, w = [int(__) for __ in input().split()]
h /= 100
bmi = w / h**2
diff = abs(bmi - 22)
if abs(diff - near) < 1e-8:
near = abs(bmi - 22)
best = min(best, no)
elif diff < near:
near = diff
best = no
print(best)
``` | instruction | 0 | 2,382 | 11 | 4,764 |
Yes | output | 1 | 2,382 | 11 | 4,765 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
5 3
4
2
5
Output
5
2
4
1
3
Submitted Solution:
```
N,M = map(int,input().split())
used = [1] + [0] * N
src = [int(input()) for i in range(M)]
for v in reversed(src):
if used[v]: continue
print(v)
used[v] = 1
for v,u in enumerate(used):
if not u: print(v)
``` | instruction | 0 | 2,413 | 11 | 4,826 |
Yes | output | 1 | 2,413 | 11 | 4,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
5 3
4
2
5
Output
5
2
4
1
3
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
while True:
n,m = LI()
a = [I() for _ in range(m)][::-1]
f = [None] * (n+1)
for c in a:
if f[c] is None:
f[c] = 1
rr.append(c)
for c in range(1,n+1):
if f[c] is None:
rr.append(c)
break
return '\n'.join(map(str, rr))
print(main())
``` | instruction | 0 | 2,414 | 11 | 4,828 |
Yes | output | 1 | 2,414 | 11 | 4,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
5 3
4
2
5
Output
5
2
4
1
3
Submitted Solution:
```
from collections import deque
n, m = map(int, input().split())
e = [int(input()) for _ in range(m)]
d = deque(i for i in range(1, n+1))
for v in e[::-1]:
try:
d.remove(v)
print(v)
except ValueError:
pass
while d:
print(d.popleft())
``` | instruction | 0 | 2,415 | 11 | 4,830 |
No | output | 1 | 2,415 | 11 | 4,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
7
>>
Output
7
Submitted Solution:
```
input()
s=input()
print(len(s)-min(s.find('>'),s.rfind('<')-1))
``` | instruction | 0 | 2,432 | 11 | 4,864 |
No | output | 1 | 2,432 | 11 | 4,865 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are $ n $ acitivities with start times $ \\ {s_i \\} $ and finish times $ \\ {t_i \\} $. Assuming that a person can only work on a single activity at a time, find the maximum number of activities that can be performed by a single person.
Constraints
* $ 1 \ le n \ le 10 ^ 5 $
* $ 1 \ le s_i \ lt t_i \ le 10 ^ 9 (1 \ le i \ le n) $
Input
$ n $
$ s_1 $ $ t_1 $
$ s_2 $ $ t_2 $
::
$ s_n $ $ t_n $
The first line consists of the integer $ n $. In the following $ n $ lines, the start time $ s_i $ and the finish time $ t_i $ of the activity $ i $ are given.
output
Print the maximum number of activities in a line.
Examples
Input
5
1 2
3 9
3 5
5 9
6 8
Output
3
Input
3
1 5
3 4
2 5
Output
1
Input
3
1 2
2 3
3 4
Output
2
Submitted Solution:
```
n = int(input())
A = [[int(i) for i in input().split()] for _ in range(n)]
A.sort(key = lambda x:x[1])
t = 0
ans = 0
for i in A:
if t < i[0]:
ans += 1
t = i[1]
print(ans)
``` | instruction | 0 | 2,444 | 11 | 4,888 |
Yes | output | 1 | 2,444 | 11 | 4,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are $ n $ acitivities with start times $ \\ {s_i \\} $ and finish times $ \\ {t_i \\} $. Assuming that a person can only work on a single activity at a time, find the maximum number of activities that can be performed by a single person.
Constraints
* $ 1 \ le n \ le 10 ^ 5 $
* $ 1 \ le s_i \ lt t_i \ le 10 ^ 9 (1 \ le i \ le n) $
Input
$ n $
$ s_1 $ $ t_1 $
$ s_2 $ $ t_2 $
::
$ s_n $ $ t_n $
The first line consists of the integer $ n $. In the following $ n $ lines, the start time $ s_i $ and the finish time $ t_i $ of the activity $ i $ are given.
output
Print the maximum number of activities in a line.
Examples
Input
5
1 2
3 9
3 5
5 9
6 8
Output
3
Input
3
1 5
3 4
2 5
Output
1
Input
3
1 2
2 3
3 4
Output
2
Submitted Solution:
```
class Activity:
def __init__(self,s,e):
self.s=s
self.e=e
n=int(input())
acts=[]
for i in range(n):
si,ei=map(int,input().split())
acts.append(Activity(si,ei))
acts.sort(key=lambda x:x.s)
stack=[]
stack.append(acts[0])
for i in range(1,n):
last = stack[-1]
acti = acts[i]
if acti.s > last.e:
stack.append(acti)
elif acti.e < last.e:
stack.pop()
stack.append(acti)
print(len(stack))
``` | instruction | 0 | 2,445 | 11 | 4,890 |
Yes | output | 1 | 2,445 | 11 | 4,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are $ n $ acitivities with start times $ \\ {s_i \\} $ and finish times $ \\ {t_i \\} $. Assuming that a person can only work on a single activity at a time, find the maximum number of activities that can be performed by a single person.
Constraints
* $ 1 \ le n \ le 10 ^ 5 $
* $ 1 \ le s_i \ lt t_i \ le 10 ^ 9 (1 \ le i \ le n) $
Input
$ n $
$ s_1 $ $ t_1 $
$ s_2 $ $ t_2 $
::
$ s_n $ $ t_n $
The first line consists of the integer $ n $. In the following $ n $ lines, the start time $ s_i $ and the finish time $ t_i $ of the activity $ i $ are given.
output
Print the maximum number of activities in a line.
Examples
Input
5
1 2
3 9
3 5
5 9
6 8
Output
3
Input
3
1 5
3 4
2 5
Output
1
Input
3
1 2
2 3
3 4
Output
2
Submitted Solution:
```
n = int(input())
lst = [list(map(int, input().split())) for _ in range(n)]
lst.sort(key=lambda x:x[1])
now = -1
ans = 0
for s, t in lst:
if now < s:
ans += 1
now = t
print(ans)
``` | instruction | 0 | 2,446 | 11 | 4,892 |
Yes | output | 1 | 2,446 | 11 | 4,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are $ n $ acitivities with start times $ \\ {s_i \\} $ and finish times $ \\ {t_i \\} $. Assuming that a person can only work on a single activity at a time, find the maximum number of activities that can be performed by a single person.
Constraints
* $ 1 \ le n \ le 10 ^ 5 $
* $ 1 \ le s_i \ lt t_i \ le 10 ^ 9 (1 \ le i \ le n) $
Input
$ n $
$ s_1 $ $ t_1 $
$ s_2 $ $ t_2 $
::
$ s_n $ $ t_n $
The first line consists of the integer $ n $. In the following $ n $ lines, the start time $ s_i $ and the finish time $ t_i $ of the activity $ i $ are given.
output
Print the maximum number of activities in a line.
Examples
Input
5
1 2
3 9
3 5
5 9
6 8
Output
3
Input
3
1 5
3 4
2 5
Output
1
Input
3
1 2
2 3
3 4
Output
2
Submitted Solution:
```
readline = open(0).readline
from heapq import heappush, heappop
N = int(readline())
que = []
P = [list(map(int, readline().split())) for i in range(N)]
P.sort()
ans = 0
for s, t in P:
while que and que[0][0] < s:
ans = max(ans, heappop(que)[1])
heappush(que, (t, ans+1))
while que:
ans = max(ans, heappop(que)[1])
open(1, 'w').write("%d\n" % ans)
``` | instruction | 0 | 2,447 | 11 | 4,894 |
Yes | output | 1 | 2,447 | 11 | 4,895 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are $ n $ acitivities with start times $ \\ {s_i \\} $ and finish times $ \\ {t_i \\} $. Assuming that a person can only work on a single activity at a time, find the maximum number of activities that can be performed by a single person.
Constraints
* $ 1 \ le n \ le 10 ^ 5 $
* $ 1 \ le s_i \ lt t_i \ le 10 ^ 9 (1 \ le i \ le n) $
Input
$ n $
$ s_1 $ $ t_1 $
$ s_2 $ $ t_2 $
::
$ s_n $ $ t_n $
The first line consists of the integer $ n $. In the following $ n $ lines, the start time $ s_i $ and the finish time $ t_i $ of the activity $ i $ are given.
output
Print the maximum number of activities in a line.
Examples
Input
5
1 2
3 9
3 5
5 9
6 8
Output
3
Input
3
1 5
3 4
2 5
Output
1
Input
3
1 2
2 3
3 4
Output
2
Submitted Solution:
```
n = int(input())
data = []
for _ in range(n):
x,y = map(int,input().split(" "))
data.append([x,y])
data.sort()
maxa = sorted(data, key=lambda x:x[1])[-1][1]
index = 0
count = 0
while True:
taisyo = []
for ele in data:
if ele[0] == index:
taisyo.append(ele)
if taisyo == []:
index += 1
else:
lmao = sorted(taisyo, key=lambda x:x[1])
index = lmao[0][1] + 1
count += 1
if index > maxa:
break
print(count)
``` | instruction | 0 | 2,448 | 11 | 4,896 |
No | output | 1 | 2,448 | 11 | 4,897 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are $ n $ acitivities with start times $ \\ {s_i \\} $ and finish times $ \\ {t_i \\} $. Assuming that a person can only work on a single activity at a time, find the maximum number of activities that can be performed by a single person.
Constraints
* $ 1 \ le n \ le 10 ^ 5 $
* $ 1 \ le s_i \ lt t_i \ le 10 ^ 9 (1 \ le i \ le n) $
Input
$ n $
$ s_1 $ $ t_1 $
$ s_2 $ $ t_2 $
::
$ s_n $ $ t_n $
The first line consists of the integer $ n $. In the following $ n $ lines, the start time $ s_i $ and the finish time $ t_i $ of the activity $ i $ are given.
output
Print the maximum number of activities in a line.
Examples
Input
5
1 2
3 9
3 5
5 9
6 8
Output
3
Input
3
1 5
3 4
2 5
Output
1
Input
3
1 2
2 3
3 4
Output
2
Submitted Solution:
```
class Activity:
def __init__(self,s,e):
self.s=s
self.e=e
self.k=str(s)+'-'+str(e)
n=int(input())
acts=[]
for i in range(n):
si,ei=map(int,input().split())
acts.append(Activity(si,ei))
acts.sort(key=lambda x:x.k)
stack=[]
stack.append(acts[0])
for i in range(1,n):
last = stack[-1]
acti = acts[i]
if acti.s > last.e:
stack.append(acti)
elif acti.e < last.e:
stack.pop()
stack.append(acti)
print(len(stack))
``` | instruction | 0 | 2,449 | 11 | 4,898 |
No | output | 1 | 2,449 | 11 | 4,899 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are $ n $ acitivities with start times $ \\ {s_i \\} $ and finish times $ \\ {t_i \\} $. Assuming that a person can only work on a single activity at a time, find the maximum number of activities that can be performed by a single person.
Constraints
* $ 1 \ le n \ le 10 ^ 5 $
* $ 1 \ le s_i \ lt t_i \ le 10 ^ 9 (1 \ le i \ le n) $
Input
$ n $
$ s_1 $ $ t_1 $
$ s_2 $ $ t_2 $
::
$ s_n $ $ t_n $
The first line consists of the integer $ n $. In the following $ n $ lines, the start time $ s_i $ and the finish time $ t_i $ of the activity $ i $ are given.
output
Print the maximum number of activities in a line.
Examples
Input
5
1 2
3 9
3 5
5 9
6 8
Output
3
Input
3
1 5
3 4
2 5
Output
1
Input
3
1 2
2 3
3 4
Output
2
Submitted Solution:
```
class Activity:
def __init__(self,s,e):
self.s=s
self.e=e
self.k=str(s)+'-'+str(e)
n=int(input())
acts=[]
for i in range(n):
si,ei=map(int,input().split())
acts.append(Activity(si,ei))
acts.sort(key=lambda x:x.k)
stack=[]
stack.append(acts[0])
for i in range(1,n):
last = stack[0]
acti = acts[i]
if acti.s > last.e:
stack.append(acti)
elif acti.e < last.e:
stack.pop()
stack.append(acti)
print(len(stack))
``` | instruction | 0 | 2,450 | 11 | 4,900 |
No | output | 1 | 2,450 | 11 | 4,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
s = input()
def valid(s):
if not (s[0] == '0' and len(s) > 1) and int(s) <= 1000000:
return True
return False
res = []
for x in range(1, len(s)):
for y in range(x, len(s)):
b = [x, y]
num1 = s[:x]
num2 = s[x:y]
num3 = s[y:]
if len(set(b)) != 2:
continue
if valid(num1) and valid(num2) and valid(num3):
res.append(int(num1) + int(num2) + int(num3))
if not len(res):
print(-1)
else:
print(max(res))
``` | instruction | 0 | 2,710 | 11 | 5,420 |
Yes | output | 1 | 2,710 | 11 | 5,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
n=input()
l=len(n)
mini=-1
for i in range(1,l-1):
for j in range(1,l-1):
k=l-i-j
if(k>0):
# print(i,i+j)
t1="".join(n[:i])
t2="".join(n[i:i+j])
t3="".join(n[i+j:])
if((t1[0]=="0" and i>1) or (t2[0]=="0" and j>1) or (t3[0]=="0" and k>1)):
continue
# print(t1,t2,t3)
t1=int(t1)
t2=int(t2)
t3=int(t3)
s=t1+t2+t3
if(s>mini and t1<=10**6 and t2<=10**6 and t3<=10**6 ):
mini=s
print(mini)
``` | instruction | 0 | 2,711 | 11 | 5,422 |
Yes | output | 1 | 2,711 | 11 | 5,423 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
def g(a):
return (len(a) == 1 or a[0] != '0') and int(a) <= 1000000
def f(a, b, c):
return int(a) + int(b) + int(c) if g(a) and g(b) and g(c) else -1
s, v = input(), -1
for i in range(1, len(s) - 1):
for j in range(i + 1, len(s)):
v = max(v, f(s[:i], s[i:j], s[j:]))
print(v)
``` | instruction | 0 | 2,712 | 11 | 5,424 |
Yes | output | 1 | 2,712 | 11 | 5,425 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
s = input()
n = len(s)
def num(x):
if len(x) > 1 and x[0] == '0':
return 1000000000
x = int(x)
if x > 1000000:
return 1000000000
return x
ans = -1
for i in range(1, n-1):
for j in range(i+1, n):
l = s[:i]
m = s[i:j]
r = s[j:]
cur = num(l) + num(m) + num(r)
if cur < 100000000:
ans = max(ans, cur)
print(ans)
``` | instruction | 0 | 2,713 | 11 | 5,426 |
Yes | output | 1 | 2,713 | 11 | 5,427 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
# https://codeforces.com/problemset/problem/175/A
inputArray = [int(d) for d in str(input())]
# inputArray = [9, 0, 0, 0]
x = []
y = []
z = []
max_sum = -1
def convert(list):
# Converting integer list to string list
s = [str(i) for i in list]
# Join list items using join()
res = int("".join(s))
return(res)
for idxFirst in range(len(inputArray) - 2):
for idxSecond in range(idxFirst+1, len(inputArray)-1):
x = []
y = []
z = []
for idxX in range(idxFirst+1):
x.append(inputArray[idxX])
if len(x) > 1 and x[0] == 0:
break
x = convert(x)
for idxY in range(idxFirst+1, idxSecond+1):
y.append(inputArray[idxY])
if len(y) > 1 and y[0] == 0:
break
y = convert(y)
for idxZ in range(idxSecond+1, len(inputArray)):
z.append(inputArray[idxZ])
if len(z) > 1 and z[0] == 0:
break
z = convert(z)
temp = x + y + z
if temp > max_sum and max_sum <= 1000000:
max_sum = temp
print(max_sum)
``` | instruction | 0 | 2,716 | 11 | 5,432 |
No | output | 1 | 2,716 | 11 | 5,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
s = input()
final = -1
n = len(s)
flag = 0
l = ['00', '01', '02', '03', '04', '05', '06', '07', '08', '09']
for i in range(1, n):
for j in range(i+1, n):
numbers = [s[:i], s[i:j], s[j:]]
# print(numbers)
# print(flag)
flag = 0;
# for element in numbers:
# if(str(int(element)) != element):
# flag = 1
# if(flag == 0):
# print(int(s[:i]) + int(s[i:j]) + int(s[j:]))
# print(final)
# print('f', s[:i], s[i:j], s[j:])
# print(str(s[j:][:1]))
if(str(s[:i][:2]) in l or str(s[i:j][:2]) in l or str(s[j:][:2]) in l):
# print(1)
flag = 1
else:
if(int(s[:i]) <= 1000000 and int(s[i:j]) <= 1000000 and int(s[j:]) <= 1000000):
# print(s[:i], s[i:j], s[j:])
final = max(final, (int(s[:i]) + int(s[i:j]) + int(s[j:])))
# flag = 0
# print(final)
# print('flag', flag)
if(flag == 1):
print(-1)
else:
print(final)
``` | instruction | 0 | 2,717 | 11 | 5,434 |
No | output | 1 | 2,717 | 11 | 5,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera has n counters numbered from 1 to n. Some of them are connected by wires, and each of the counters has a special button.
Initially, all the counters contain number 0. When you press a button on a certain counter, the value it has increases by one. Also, the values recorded in all the counters, directly connected to it by a wire, increase by one.
Valera and Ignat started having a dispute, the dispute is as follows. Ignat thought of a sequence of n integers a1, a2, ..., an. Valera should choose some set of distinct counters and press buttons on each of them exactly once (on other counters the buttons won't be pressed). If after that there is a counter with the number i, which has value ai, then Valera loses the dispute, otherwise he wins the dispute.
Help Valera to determine on which counters he needs to press a button to win the dispute.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 105), that denote the number of counters Valera has and the number of pairs of counters connected by wires.
Each of the following m lines contains two space-separated integers ui and vi (1 β€ ui, vi β€ n, ui β vi), that mean that counters with numbers ui and vi are connected by a wire. It is guaranteed that each pair of connected counters occurs exactly once in the input.
The last line contains n space-separated integers a1, a2, ..., an (0 β€ ai β€ 105), where ai is the value that Ignat choose for the i-th counter.
Output
If Valera can't win the dispute print in the first line -1.
Otherwise, print in the first line integer k (0 β€ k β€ n). In the second line print k distinct space-separated integers β the numbers of the counters, where Valera should push buttons to win the dispute, in arbitrary order.
If there exists multiple answers, you are allowed to print any of them.
Examples
Input
5 5
2 3
4 1
1 5
5 3
2 1
1 1 2 0 2
Output
2
1 2
Input
4 2
1 2
3 4
0 0 0 0
Output
3
1 3 4
Submitted Solution:
```
from queue import Queue
n,m = map(int,input().split())
e = [[]for i in range(n+1)]
b = [0]*n
for i in range(m):
u,v = map(int,input().split())
e[u-1].append(v-1)
e[v-1].append(u-1)
ans = 0
q = Queue()
a = input().split()
ai = [-1]*n
c=0
mask = [False]*n
for i in a:
inti = int(i)
ai[c] = inti
if inti == 0:
q.put(c)
b[c]=1
c+=1
T=[]
while not q.empty():
i = q._get()
ans+=1
T.append(i+1)
for j in e[i]:
b[j]+=1
if b[j]== ai[j]:
q.put(j)
print(ans)
print(T)
``` | instruction | 0 | 2,751 | 11 | 5,502 |
No | output | 1 | 2,751 | 11 | 5,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serega loves fun. However, everyone has fun in the unique manner. Serega has fun by solving query problems. One day Fedor came up with such a problem.
You are given an array a consisting of n positive integers and queries to it. The queries can be of two types:
1. Make a unit cyclic shift to the right on the segment from l to r (both borders inclusive). That is rearrange elements of the array in the following manner:a[l], a[l + 1], ..., a[r - 1], a[r] β a[r], a[l], a[l + 1], ..., a[r - 1].
2. Count how many numbers equal to k are on the segment from l to r (both borders inclusive).
Fedor hurried to see Serega enjoy the problem and Serega solved it really quickly. Let's see, can you solve it?
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements of the array. The second line contains n integers a[1], a[2], ..., a[n] (1 β€ a[i] β€ n).
The third line contains a single integer q (1 β€ q β€ 105) β the number of queries. The next q lines contain the queries.
As you need to respond to the queries online, the queries will be encoded. A query of the first type will be given in format: 1 l'i r'i. A query of the second type will be given in format: 2 l'i r'i k'i. All the number in input are integer. They satisfy the constraints: 1 β€ l'i, r'i, k'i β€ n.
To decode the queries from the data given in input, you need to perform the following transformations:
li = ((l'i + lastans - 1) mod n) + 1; ri = ((r'i + lastans - 1) mod n) + 1; ki = ((k'i + lastans - 1) mod n) + 1.
Where lastans is the last reply to the query of the 2-nd type (initially, lastans = 0). If after transformation li is greater than ri, you must swap these values.
Output
For each query of the 2-nd type print the answer on a single line.
Examples
Input
7
6 6 2 7 4 2 5
7
1 3 6
2 2 4 2
2 2 4 7
2 2 2 5
1 2 6
1 1 4
2 1 7 3
Output
2
1
0
0
Input
8
8 4 2 2 7 7 8 8
8
1 8 8
2 8 1 7
1 8 1
1 7 3
2 8 8 3
1 1 4
1 2 7
1 4 5
Output
2
0
Submitted Solution:
```
n =int(input())
arr = [int(x) for x in input().split()]
big = 10**5
freq = [0]*(big + 1)
for i in arr:
freq[i] += 1
dp = {}
for a in range(big+1):
if(a==0):
val = 0
elif(a==1):
val = freq[1]
else:
val = max(dp[a-1], dp[a-2]+a*freq[a])
dp[a] = val
print(dp[big])
``` | instruction | 0 | 2,843 | 11 | 5,686 |
No | output | 1 | 2,843 | 11 | 5,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor Β«TextpadΒ» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters Β«*Β» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Submitted Solution:
```
import sys
arr = []
max_len = 0
for s in sys.stdin:
s = s.strip()
arr.append(s)
max_len = max(max_len, len(s))
print('*'*(max_len + 2))
flag = True
for s in arr:
diff = max_len - len(s)
left = int(diff / 2)
right = diff - left
if left != right:
if flag:
left = int(diff / 2)
right = diff - left
else:
right = int(diff / 2)
left = diff - right
# print(left, right, flag)
flag = not flag
# print(diff, left, right)
print('*' + ' '*left + s + ' '*right + '*')
print('*'*(max_len + 2))
``` | instruction | 0 | 2,914 | 11 | 5,828 |
Yes | output | 1 | 2,914 | 11 | 5,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Joisino is planning to record N TV programs with recorders.
The TV can receive C channels numbered 1 through C.
The i-th program that she wants to record will be broadcast from time s_i to time t_i (including time s_i but not t_i) on Channel c_i.
Here, there will never be more than one program that are broadcast on the same channel at the same time.
When the recorder is recording a channel from time S to time T (including time S but not T), it cannot record other channels from time S-0.5 to time T (including time S-0.5 but not T).
Find the minimum number of recorders required to record the channels so that all the N programs are completely recorded.
Constraints
* 1β€Nβ€10^5
* 1β€Cβ€30
* 1β€s_i<t_iβ€10^5
* 1β€c_iβ€C
* If c_i=c_j and iβ j, either t_iβ€s_j or s_iβ₯t_j.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N C
s_1 t_1 c_1
:
s_N t_N c_N
Output
When the minimum required number of recorders is x, print the value of x.
Examples
Input
3 2
1 7 2
7 8 1
8 12 1
Output
2
Input
3 4
1 3 2
3 4 4
1 4 3
Output
3
Input
9 4
56 60 4
33 37 2
89 90 3
32 43 1
67 68 3
49 51 3
31 32 3
70 71 1
11 12 3
Output
2
Submitted Solution:
```
n, _ = map(int, input().split())
a = sorted(tuple(map(int, input().split())) for _ in range(n))
r = [(0,0)]
for s, t, c in a:
u, i = min((u+0.5*(c!=d), i) for i, (u, d) in enumerate(r))
if s < u:
r.append((t, c))
else:
r[i] = (t, c)
print(len(r))
``` | instruction | 0 | 3,181 | 11 | 6,362 |
Yes | output | 1 | 3,181 | 11 | 6,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Joisino is planning to record N TV programs with recorders.
The TV can receive C channels numbered 1 through C.
The i-th program that she wants to record will be broadcast from time s_i to time t_i (including time s_i but not t_i) on Channel c_i.
Here, there will never be more than one program that are broadcast on the same channel at the same time.
When the recorder is recording a channel from time S to time T (including time S but not T), it cannot record other channels from time S-0.5 to time T (including time S-0.5 but not T).
Find the minimum number of recorders required to record the channels so that all the N programs are completely recorded.
Constraints
* 1β€Nβ€10^5
* 1β€Cβ€30
* 1β€s_i<t_iβ€10^5
* 1β€c_iβ€C
* If c_i=c_j and iβ j, either t_iβ€s_j or s_iβ₯t_j.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N C
s_1 t_1 c_1
:
s_N t_N c_N
Output
When the minimum required number of recorders is x, print the value of x.
Examples
Input
3 2
1 7 2
7 8 1
8 12 1
Output
2
Input
3 4
1 3 2
3 4 4
1 4 3
Output
3
Input
9 4
56 60 4
33 37 2
89 90 3
32 43 1
67 68 3
49 51 3
31 32 3
70 71 1
11 12 3
Output
2
Submitted Solution:
```
n, c = map(int, input().split())
r = [[0 for i in range(c)] for j in range(100000)]
for dummy in range(n):
s, t, c = map(int, input().split())
for j in range(s - 1, t):
r[j][c - 1] = 1
ans = 0
for i in range(100000):
if sum(r[i]) > ans:
ans = sum(r[i])
print(ans)
``` | instruction | 0 | 3,182 | 11 | 6,364 |
Yes | output | 1 | 3,182 | 11 | 6,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Joisino is planning to record N TV programs with recorders.
The TV can receive C channels numbered 1 through C.
The i-th program that she wants to record will be broadcast from time s_i to time t_i (including time s_i but not t_i) on Channel c_i.
Here, there will never be more than one program that are broadcast on the same channel at the same time.
When the recorder is recording a channel from time S to time T (including time S but not T), it cannot record other channels from time S-0.5 to time T (including time S-0.5 but not T).
Find the minimum number of recorders required to record the channels so that all the N programs are completely recorded.
Constraints
* 1β€Nβ€10^5
* 1β€Cβ€30
* 1β€s_i<t_iβ€10^5
* 1β€c_iβ€C
* If c_i=c_j and iβ j, either t_iβ€s_j or s_iβ₯t_j.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N C
s_1 t_1 c_1
:
s_N t_N c_N
Output
When the minimum required number of recorders is x, print the value of x.
Examples
Input
3 2
1 7 2
7 8 1
8 12 1
Output
2
Input
3 4
1 3 2
3 4 4
1 4 3
Output
3
Input
9 4
56 60 4
33 37 2
89 90 3
32 43 1
67 68 3
49 51 3
31 32 3
70 71 1
11 12 3
Output
2
Submitted Solution:
```
MAX = 114514
N,C=map(int, input().split())
Z=[[] for _ in range(C+1)]
for _ in range(N):
s,t,c = map(int, input().split())
Z[c].append([s,t])
Y=[]
for z in [sorted(z) for z in Z if len(z) > 0]:
for i in range(len(z)-1):
if z[i][1] == z[i+1][0]:
z[i+1][0] = z[i][0]
else:
Y.append(z[i])
Y.append(z.pop())
X=[0 for _ in range(MAX)]
for s,t in Y:
X[s] += 1
X[t+1] -= 1
for i in range(1, MAX):
X[i] += X[i-1]
print(max(X))
``` | instruction | 0 | 3,183 | 11 | 6,366 |
Yes | output | 1 | 3,183 | 11 | 6,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Joisino is planning to record N TV programs with recorders.
The TV can receive C channels numbered 1 through C.
The i-th program that she wants to record will be broadcast from time s_i to time t_i (including time s_i but not t_i) on Channel c_i.
Here, there will never be more than one program that are broadcast on the same channel at the same time.
When the recorder is recording a channel from time S to time T (including time S but not T), it cannot record other channels from time S-0.5 to time T (including time S-0.5 but not T).
Find the minimum number of recorders required to record the channels so that all the N programs are completely recorded.
Constraints
* 1β€Nβ€10^5
* 1β€Cβ€30
* 1β€s_i<t_iβ€10^5
* 1β€c_iβ€C
* If c_i=c_j and iβ j, either t_iβ€s_j or s_iβ₯t_j.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N C
s_1 t_1 c_1
:
s_N t_N c_N
Output
When the minimum required number of recorders is x, print the value of x.
Examples
Input
3 2
1 7 2
7 8 1
8 12 1
Output
2
Input
3 4
1 3 2
3 4 4
1 4 3
Output
3
Input
9 4
56 60 4
33 37 2
89 90 3
32 43 1
67 68 3
49 51 3
31 32 3
70 71 1
11 12 3
Output
2
Submitted Solution:
```
from heapq import heappush, heappop
# ε
₯ε
N, C = map(int, input().split())
s, t, c = zip(*(map(int, input().split()) for _ in range(N)))
# εͺε
εΊ¦δ»γγγ₯γΌγη¨γγ¦γ·γγ₯γ¬γΌγ·γ§γ³
Q = []
p = [0 for _ in range(C + 1)]
ans = 0
for x, y, z in sorted(zip(s, t, c)):
while Q and (Q[0] < x or Q[0] == x == p[z]):
p[z] = 0
heappop(Q)
p[z] = y
heappush(Q, y)
ans = max(ans, len(Q))
# εΊε
print(ans)
``` | instruction | 0 | 3,184 | 11 | 6,368 |
Yes | output | 1 | 3,184 | 11 | 6,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Joisino is planning to record N TV programs with recorders.
The TV can receive C channels numbered 1 through C.
The i-th program that she wants to record will be broadcast from time s_i to time t_i (including time s_i but not t_i) on Channel c_i.
Here, there will never be more than one program that are broadcast on the same channel at the same time.
When the recorder is recording a channel from time S to time T (including time S but not T), it cannot record other channels from time S-0.5 to time T (including time S-0.5 but not T).
Find the minimum number of recorders required to record the channels so that all the N programs are completely recorded.
Constraints
* 1β€Nβ€10^5
* 1β€Cβ€30
* 1β€s_i<t_iβ€10^5
* 1β€c_iβ€C
* If c_i=c_j and iβ j, either t_iβ€s_j or s_iβ₯t_j.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N C
s_1 t_1 c_1
:
s_N t_N c_N
Output
When the minimum required number of recorders is x, print the value of x.
Examples
Input
3 2
1 7 2
7 8 1
8 12 1
Output
2
Input
3 4
1 3 2
3 4 4
1 4 3
Output
3
Input
9 4
56 60 4
33 37 2
89 90 3
32 43 1
67 68 3
49 51 3
31 32 3
70 71 1
11 12 3
Output
2
Submitted Solution:
```
n,c = map(int,input().split())
l = [[0]*(10**5+1) for _ in range(c+1)]
for _ in range(n):
s,t,c = map(int,input().split())
for i in range(s,t+1):
l[c-1][i] = 1
ans = [0]*10**5
for i in range(len(l)):
for j in range(len(l[i])):
ans[j] += l[i][j]
print(max(ans))
``` | instruction | 0 | 3,185 | 11 | 6,370 |
No | output | 1 | 3,185 | 11 | 6,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Joisino is planning to record N TV programs with recorders.
The TV can receive C channels numbered 1 through C.
The i-th program that she wants to record will be broadcast from time s_i to time t_i (including time s_i but not t_i) on Channel c_i.
Here, there will never be more than one program that are broadcast on the same channel at the same time.
When the recorder is recording a channel from time S to time T (including time S but not T), it cannot record other channels from time S-0.5 to time T (including time S-0.5 but not T).
Find the minimum number of recorders required to record the channels so that all the N programs are completely recorded.
Constraints
* 1β€Nβ€10^5
* 1β€Cβ€30
* 1β€s_i<t_iβ€10^5
* 1β€c_iβ€C
* If c_i=c_j and iβ j, either t_iβ€s_j or s_iβ₯t_j.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N C
s_1 t_1 c_1
:
s_N t_N c_N
Output
When the minimum required number of recorders is x, print the value of x.
Examples
Input
3 2
1 7 2
7 8 1
8 12 1
Output
2
Input
3 4
1 3 2
3 4 4
1 4 3
Output
3
Input
9 4
56 60 4
33 37 2
89 90 3
32 43 1
67 68 3
49 51 3
31 32 3
70 71 1
11 12 3
Output
2
Submitted Solution:
```
# using main() makes code faster from the point of view of "access to variables in global name-space"
# def main():
# for i, a in enumerate(iterable)
# q, mod = divmod(a, b)
# divmod(x, y) returns the tuple (x//y, x%y)
# manage median(s) using two heapq https://atcoder.jp/contests/abc127/tasks/abc127_f
import sys
sys.setrecursionlimit(10**7)
from itertools import accumulate, combinations, permutations # https://docs.python.org/ja/3/library/itertools.html
from math import factorial
def combinations_count(n, r):
# faster than the following code
# def combinations_count(n, r):
# return factorial(n) // (factorial(n - r) * factorial(r))
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def combination_with_repetition_count(n, r):
return combinations_count(n + r - 1, r)
from collections import deque, Counter # https://docs.python.org/ja/3/library/collections.html#collections.deque
from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest # https://docs.python.org/ja/3/library/heapq.html
from copy import deepcopy, copy # https://docs.python.org/ja/3/library/copy.html
from operator import itemgetter
# ex1: List.sort(key=itemgetter(1))
# ex2: sorted(tuples, key=itemgetter(1,2))
from functools import reduce
from fractions import gcd # Deprecated since version 3.5: Use math.gcd() instead.
def gcds(numbers):
return reduce(gcd, numbers)
def lcm(x, y):
return (x * y) // gcd(x, y)
def lcms(numbers):
return reduce(lcm, numbers, 1)
# first create factorial_list
# fac_list = mod_factorial_list(n)
INF = 10 ** 18
MOD = 10 ** 6 + 3
modpow = lambda a, n, p = MOD: pow(a, n, p) # Recursive function in python is slow!
def modinv(a, p = MOD):
# evaluate reciprocal using Fermat's little theorem:
# a**(p-1) is identical to 1 (mod p) when a and p is coprime
return modpow(a, p-2, p)
def modinv_list(n, p = MOD):
if n <= 1:
return [0,1][:n+1]
else:
inv_t = [0,1]
for i in range(2, n+1):
inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
return inv_t
def modfactorial_list(n, p = MOD):
if n == 0:
return [1]
else:
l = [0] * (n+1)
tmp = 1
for i in range(1, n+1):
tmp = tmp * i % p
l[i] = tmp
return l
def modcomb(n, k, fac_list = [], p = MOD):
# fac_list = modfactorial_list(100)
# print(modcomb(100, 5, modfactorial_list(100)))
from math import factorial
if n < 0 or k < 0 or n < k: return 0
if n == 0 or k == 0: return 1
if len(fac_list) <= n:
a = factorial(n) % p
b = factorial(k) % p
c = factorial(n-k) % p
else:
a = fac_list[n]
b = fac_list[k]
c = fac_list[n-k]
return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
def modadd(a, b, p = MOD):
return (a + b) % MOD
def modsub(a, b, p = MOD):
return (a - b) % p
def modmul(a, b, p = MOD):
return ((a % p) * (b % p)) % p
def moddiv(a, b, p = MOD):
return modmul(a, modpow(b, p-2, p))
# initialize variables and set inputs
#initialize variables
# to initialize list, use [0] * n
# to initialize two dimentional array, use [[0] * N for _ in range(N)]
# set inputs
# open(0).read() is a convenient method:
# ex) n, m, *x = map(int, open(0).read().split())
# min(x[::2]) - max(x[1::2])
# ex2) *x, = map(int, open(0).read().split())
# don't forget to add comma after *x if only one variable is used
# calculate and output
# output pattern
# ex1) print(*l) => when l = [2, 5, 6], printed 2 5 6
# set test data
# sys.stdin = open('sample.txt') # for test
# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]
# watch out: join tv programmes which are continuously broadcast in one channel
for s, t, c in STC:
c -= 1
if tbl[c][2*s] != 0:
tbl[c][2*s] += 1
tbl[c][2*t] -= 1
elif tbl[c][2*t-1] != 0:
tbl[c][2*t-1] -= 1
tbl[c][2*s-1] += 1
else:
tbl[c][2*s-1] = 1
tbl[c][2*t] = -1
# for s, t, c in STC:
# c -= 1
# if tbl[c][s] == -1:
# tbl[c][s] = 0
# tbl[c][t] = -1
# elif tbl[c][t-1] == 1:
# tbl[c][s-1] = 1
# tbl[c][t-1] = 0
# else:
# tbl[c][s-1] = 1
# tbl[c][t] = -1
tbl2 = [list(accumulate(a)) for a in tbl]
ans = max([sum(x) for x in zip(*tbl2)])
print(ans)
# tmp = [sum(x) for x in zip(*tbl2)]
# res = 0
# for i in range(200002):
# cc = 0
# for j in range(C):
# if tbl2[j][i]:
# cc += 1
# res = max(res, cc)
# print(res)
# if __name__ == '__main__':
# main()
``` | instruction | 0 | 3,186 | 11 | 6,372 |
No | output | 1 | 3,186 | 11 | 6,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Joisino is planning to record N TV programs with recorders.
The TV can receive C channels numbered 1 through C.
The i-th program that she wants to record will be broadcast from time s_i to time t_i (including time s_i but not t_i) on Channel c_i.
Here, there will never be more than one program that are broadcast on the same channel at the same time.
When the recorder is recording a channel from time S to time T (including time S but not T), it cannot record other channels from time S-0.5 to time T (including time S-0.5 but not T).
Find the minimum number of recorders required to record the channels so that all the N programs are completely recorded.
Constraints
* 1β€Nβ€10^5
* 1β€Cβ€30
* 1β€s_i<t_iβ€10^5
* 1β€c_iβ€C
* If c_i=c_j and iβ j, either t_iβ€s_j or s_iβ₯t_j.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N C
s_1 t_1 c_1
:
s_N t_N c_N
Output
When the minimum required number of recorders is x, print the value of x.
Examples
Input
3 2
1 7 2
7 8 1
8 12 1
Output
2
Input
3 4
1 3 2
3 4 4
1 4 3
Output
3
Input
9 4
56 60 4
33 37 2
89 90 3
32 43 1
67 68 3
49 51 3
31 32 3
70 71 1
11 12 3
Output
2
Submitted Solution:
```
import heapq
N,C=map(int, input().split())
inl = [tuple(map(int, input().split())) for i in range(N)]
inl.sort(reverse=True)
heap = []
res = 0
for i in range(1, 10001):
nex = set([])
rem = set([])
con = 0
while inl and inl[-1][0] == i:
s,t,c = inl.pop()
nex.add((s,c))
heapq.heappush(heap, (t,c))
while heap and heap[0][0] == i:
t1,c1 = heapq.heappop(heap)
rem.add((t1,c1))
con = len(heap) + len(rem)# - len(rem.intersection(nex))
res = max(res, con)
print(res)
``` | instruction | 0 | 3,187 | 11 | 6,374 |
No | output | 1 | 3,187 | 11 | 6,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Joisino is planning to record N TV programs with recorders.
The TV can receive C channels numbered 1 through C.
The i-th program that she wants to record will be broadcast from time s_i to time t_i (including time s_i but not t_i) on Channel c_i.
Here, there will never be more than one program that are broadcast on the same channel at the same time.
When the recorder is recording a channel from time S to time T (including time S but not T), it cannot record other channels from time S-0.5 to time T (including time S-0.5 but not T).
Find the minimum number of recorders required to record the channels so that all the N programs are completely recorded.
Constraints
* 1β€Nβ€10^5
* 1β€Cβ€30
* 1β€s_i<t_iβ€10^5
* 1β€c_iβ€C
* If c_i=c_j and iβ j, either t_iβ€s_j or s_iβ₯t_j.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N C
s_1 t_1 c_1
:
s_N t_N c_N
Output
When the minimum required number of recorders is x, print the value of x.
Examples
Input
3 2
1 7 2
7 8 1
8 12 1
Output
2
Input
3 4
1 3 2
3 4 4
1 4 3
Output
3
Input
9 4
56 60 4
33 37 2
89 90 3
32 43 1
67 68 3
49 51 3
31 32 3
70 71 1
11 12 3
Output
2
Submitted Solution:
```
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
def A():
return
#B
def B():
return
#C
def C():
n = I()
f = LIR(n)
po = [1]*11
for i in range(n):
k = 0
p = 1
for j in range(10):
k += p*f[i][j]
p *= 2
po[j+1] = p
f[i] = k
p = LIR(n)
ans = -float("inf")
for i in range(1,1024):
k = 0
for j in range(n):
c = i&f[j]
s = 0
for l in po:
if c&l:s += 1
k += p[j][s]
ans = max(ans,k)
print(ans)
#D
def D():
n,C = LI()
T = [[0 for i in range(100001)] for j in range(C)]
for i in range(n):
s,t,c = LI()
c -= 1
T[c][s] += 1
T[c][t+1] -= 1
for c in range(C):
for i in range(100000):
T[c][i+1] += T[c][i]
ans = 0
for i in range(100000):
k = 0
for c in range(C):
if T[c][i]:k += 1
ans = max(ans, k)
print(ans)
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
D()
``` | instruction | 0 | 3,188 | 11 | 6,376 |
No | output | 1 | 3,188 | 11 | 6,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant. | instruction | 0 | 3,445 | 11 | 6,890 |
Tags: data structures, dp, greedy
Correct Solution:
```
x,y,z=map(int,input().split())
d=[[],[],[]]
d[0]=list(map(int,input().split()))
d[1]=list(map(int,input().split()))
d[2]=list(map(int,input().split()))
dicto=[dict(),dict(),dict()]
dp=[[float("inf")]*(x+y+z+1) for i in range(3)]
for i in range(3):
for j in d[i]:
dicto[i][j]=1
dp[0][0]=0
mini=9999999999999
for i in range(1,x+y+z+1):
mini=999999999999
for j in range(3):
for k in range(j+1):
mini=min(mini,dp[k][i-1])
if i not in dicto[j]:
dp[j][i]=mini+1
else:
dp[j][i]=mini
for i in range(3):
mini=min(dp[0][x+y+z],dp[1][x+y+z],dp[2][x+y+z])
print(mini)
``` | output | 1 | 3,445 | 11 | 6,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant. | instruction | 0 | 3,446 | 11 | 6,892 |
Tags: data structures, dp, greedy
Correct Solution:
```
def main():
n1,n2,n3=readIntArr()
n=n1+n2+n3
a=readIntArr()
b=readIntArr()
c=readIntArr()
origPos=[-1 for _ in range(n+1)]
for x in a:
origPos[x]=1
for x in b:
origPos[x]=2
for x in c:
origPos[x]=3
dp=makeArr(inf,[n+1,4]) # dp[idx][number of participants]=min moves
dp[0][1]=0
dp[0][2]=0
dp[0][3]=0
for i in range(1,n+1):
for j in range(1,4):
# put i in previous participant
dp[i][j]=min(dp[i][j],dp[i][j-1])
# put i in current participant
if origPos[i]!=j:
extraMove=1
else:
extraMove=0
dp[i][j]=min(dp[i][j],dp[i-1][j]+extraMove)
ans=dp[n][3]
print(ans)
return
import sys
# input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
def makeArr(defaultVal,dimensionArr): # eg. makeArr(0,[n,m])
dv=defaultVal;da=dimensionArr
if len(da)==1:return [dv for _ in range(da[0])]
else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
def queryInteractive(x,y):
print('? {} {}'.format(x,y))
sys.stdout.flush()
return int(input())
def answerInteractive(ans):
print('! {}'.format(ans))
sys.stdout.flush()
inf=float('inf')
MOD=10**9+7
for _abc in range(1):
main()
``` | output | 1 | 3,446 | 11 | 6,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant. | instruction | 0 | 3,447 | 11 | 6,894 |
Tags: data structures, dp, greedy
Correct Solution:
```
#!/usr/bin/env python3
import sys
import bisect
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = 10**9
anum, bnum, cnum = [int(item) for item in input().split()]
k = anum + bnum + cnum
a = [int(item) for item in input().split()]
b = [int(item) for item in input().split()]
c = [int(item) for item in input().split()]
holder = [0] * k
for item in a:
holder[item-1] = 0
for item in b:
holder[item-1] = 1
for item in c:
holder[item-1] = 2
# seen ith, state(a hold, b hold, c hold)
dp = [[INF] * (k + 1) for _ in range(3)]
dp[0][0] = 0
dp[1][0] = 0
dp[2][0] = 0
for i in range(k):
if holder[i] == 0:
dp[0][i+1] = min(dp[0][i+1], dp[0][i])
dp[1][i+1] = min(dp[1][i+1], dp[1][i] + 1)
dp[2][i+1] = min(dp[2][i+1], dp[2][i] + 1)
dp[1][i+1] = min(dp[1][i+1], dp[0][i] + 1)
dp[2][i+1] = min(dp[2][i+1], dp[1][i] + 1)
dp[2][i+1] = min(dp[2][i+1], dp[0][i] + 1)
elif holder[i] == 1:
dp[0][i+1] = min(dp[0][i+1], dp[0][i] + 1)
dp[1][i+1] = min(dp[1][i+1], dp[1][i])
dp[2][i+1] = min(dp[2][i+1], dp[2][i] + 1)
dp[1][i+1] = min(dp[1][i+1], dp[0][i])
dp[2][i+1] = min(dp[2][i+1], dp[1][i] + 1)
dp[2][i+1] = min(dp[2][i+1], dp[0][i] + 1)
elif holder[i] == 2:
dp[0][i+1] = min(dp[0][i+1], dp[0][i] + 1)
dp[1][i+1] = min(dp[1][i+1], dp[1][i] + 1)
dp[2][i+1] = min(dp[2][i+1], dp[2][i])
dp[1][i+1] = min(dp[1][i+1], dp[0][i] + 1)
dp[2][i+1] = min(dp[2][i+1], dp[1][i])
dp[2][i+1] = min(dp[2][i+1], dp[0][i])
ans = INF
for line in dp:
ans = min(ans, line[-1])
print(ans)
``` | output | 1 | 3,447 | 11 | 6,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant. | instruction | 0 | 3,448 | 11 | 6,896 |
Tags: data structures, dp, greedy
Correct Solution:
```
import sys
k1, k2, k3 = [int(i) for i in sys.stdin.readline().split()]
k = [[], [], [], []]
for j in range(1, 4):
k[j] = [int(i) for i in sys.stdin.readline().split()]
n = k1 + k2 + k3
k_4 = []
for f in [2, 3]:
k_4.extend((jlk, f) for jlk in k[f])
k_4.sort(reverse=True)
ndd = [0] * (k2 + k3 + 1)
for j in range(1, k2 + k3 + 1):
if k_4[j-1][1] == 3:
ndd[j] = ndd[j-1]
else:
ndd[j] = ndd[j-1] + 1
fj = []
for j in range(k2+k3+1):
fj.append(k3 - j + 2 * ndd[j])
# min of fj up to value i
mnfj_i = []
mn = fj[0]
for i in range(k2+k3+1):
mn = min(mn, fj[i])
mnfj_i.append(mn)
k3s = set(k[3])
cnt_lea3 = [0] * (n+1)
for i in range(1, n+1):
if i in k3s:
cnt_lea3[i] = cnt_lea3[i-1] + 1
else:
cnt_lea3[i] = cnt_lea3[i-1]
k2s = set(k[2])
cnt_lea2 = [0] * (n+1)
for i in range(1, n+1):
if i in k2s:
cnt_lea2[i] = cnt_lea2[i-1] + 1
else:
cnt_lea2[i] = cnt_lea2[i-1]
k1s = set(k[1])
cnt_lea1 = [0] * (n+1)
for i in range(1, n+1):
if i in k1s:
cnt_lea1[i] = cnt_lea1[i-1] + 1
else:
cnt_lea1[i] = cnt_lea1[i-1]
# print(cnt_lea1)
# print('fj', fj)
# print('mnfj_i', mnfj_i)
# print('ndd', ndd)
ans = 5 * (k1 + k2 + k3)
for alpha in range(n+1):
ub = k2 + k3 - cnt_lea3[alpha] - cnt_lea2[alpha]
# print(alpha, ub)
ans = min(ans, mnfj_i[ub] - cnt_lea3[alpha] + k1 + alpha - 2 * cnt_lea1[alpha])
# print(alpha, ans, ':', k1 + alpha - 2 * cnt_lea1[alpha], mnfj_i[ub] - cnt_lea3[alpha] )
print(ans)
``` | output | 1 | 3,448 | 11 | 6,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant. | instruction | 0 | 3,449 | 11 | 6,898 |
Tags: data structures, dp, greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
k1,k2,k3=map(int,input().split())
A1=list(map(int,input().split()))
A2=list(map(int,input().split()))
A3=list(map(int,input().split()))
A=sorted(A1)+sorted(A2)+sorted(A3)
import bisect
N=k1+k2+k3
DP=[float("inf")]*N
for a in A:
pos=bisect.bisect_left(DP,a)
DP[pos]=a
ANS=0
for i in range(N):
if DP[i]!=float("inf"): ANS=i
print(N-(ANS+1))
``` | output | 1 | 3,449 | 11 | 6,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant. | instruction | 0 | 3,450 | 11 | 6,900 |
Tags: data structures, dp, greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
K1, K2, K3 = map(int, input().split())
N = K1+K2+K3
A1 = list(map(int, input().split()))
A2 = list(map(int, input().split()))
A3 = list(map(int, input().split()))
A = [0] * N
for i, A_ in enumerate([A1, A2, A3], 1):
for a in A_:
A[a-1] = i
a_12to3 = K1+K2
ans = a_12to3
a_2to1 = 0
cnt_1 = 0
cnt_2 = 0
idx_12 = 0
for a in A:
if a==3:
a_12to3 += 1
else:
a_12to3 -= 1
if a==1:
cnt_1 += 1
if cnt_1 >= cnt_2:
a_2to1 += cnt_2
cnt_1 = cnt_2 = 0
else:
cnt_2 += 1
an = a_12to3 + a_2to1 + cnt_1
ans = min(ans, an)
print(ans)
``` | output | 1 | 3,450 | 11 | 6,901 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant. | instruction | 0 | 3,451 | 11 | 6,902 |
Tags: data structures, dp, greedy
Correct Solution:
```
from sys import stdin,stdout
inf=1000000000000007
def solve():
a1,b1,c1=[int(i) for i in stdin.readline().split()]
k=a1+b1+c1;
a=[0 for i in range(k+1)]
for i in stdin.readline().split():
a[int(i)]=0
for i in stdin.readline().split():
a[int(i)]=1
for i in stdin.readline().split():
a[int(i)]=2
dp=[[inf for i in range(k+1)] for j in range(3)]
dp[0][0],dp[1][0],dp[2][0]=0,0,0
for i in range(1,k+1):
for j in range(3):
if(a[i]==j):
for l in range(0,j+1):
dp[j][i]=min(dp[j][i],dp[l][i-1])
else:
for l in range(0,j+1):
dp[j][i]=min(dp[j][i],dp[l][i-1]+1)
print(min(dp[0][k],dp[1][k],dp[2][k]))
solve()
``` | output | 1 | 3,451 | 11 | 6,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant. | instruction | 0 | 3,452 | 11 | 6,904 |
Tags: data structures, dp, greedy
Correct Solution:
```
# inf = open('input.txt', 'r')
# reader = (map(int, line.split()) for line in inf)
# k1, k2, k3 = next(reader)
# a = list(next(reader))
# b = list(next(reader))
# c = list(next(reader))
k1, k2, k3 = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
def ceil(a, L, R, pivot):
while L + 1 < R:
m = (L + R) // 2
if (a[m] > pivot):
R = m
else:
L = m
return R
def LIS(a, n):
tails = [0 for _ in range(n + 1)]
empty = 0
tails[0] = a[0]
empty = 1
for i in range(1, n):
if (a[i] < tails[0]):
tails[0] = a[i]
elif (a[i] >= tails[empty - 1]):
tails[empty] = a[i]
empty += 1
else:
tails[ceil(tails, -1, empty - 1, a[i])] = a[i]
return empty
n = k1 + k2 + k3
abc = [None] * n
for el in a:
abc[el - 1] = 1
for el in b:
abc[el - 1] = 2
for el in c:
abc[el - 1] = 3
# print(abc)
print(n - LIS(abc, n))
# inf.close()
``` | output | 1 | 3,452 | 11 | 6,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant.
Submitted Solution:
```
k1,k2,k3=map(int,input().split())
s=[set([int(o) for o in input().split()]) for i in range(3)]
n=k1+k2+k3
dp=[[float('inf')]*3 for i in range(n+1)]
dp[0][0]=0
for i in range(1,n+1):
for j in range(3):
for k in range(j,3):
dp[i][k]=min(dp[i][k],dp[i-1][j]+(i not in s[k]))
#for j in range(3):
# for i in range(n+1):
# print(dp[i][j],end=" ")
# print()
print(min(dp[n]))
``` | instruction | 0 | 3,453 | 11 | 6,906 |
Yes | output | 1 | 3,453 | 11 | 6,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
from collections import defaultdict
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")
k1,k2,k3=map(int,input().split())
c=[dict(),dict(),dict()]
a=[[],[],[]]
a[0]=list(map(int,input().split()))
a[1]=list(map(int,input().split()))
a[2]=list(map(int,input().split()))
for i in range(3):
for j in a[i]:
c[i][j]=1
dp=[[float("inf") for j in range(3)] for i in range(k1+k2+k3+1)]
dp[0]=[0,0,0]
#we want to see for each number from 1 to k1+k2+k3 that to which person we shold give this.
#dp[i][j] represents the state that what will be minimum number of operations if we have to assign numbers till i and ith number is given
#to kth person.
for i in range(1,k1+k2+k3+1):
for j in range(3):
for k in range(j,3):
dp[i][k]=min(dp[i][k],dp[i-1][j]+(1 if i not in c[k] else 0))
print(min(dp[k1+k2+k3]))
``` | instruction | 0 | 3,454 | 11 | 6,908 |
Yes | output | 1 | 3,454 | 11 | 6,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant.
Submitted Solution:
```
import sys
import math
import collections
import heapq
import decimal
input=sys.stdin.readline
k1,k2,k3=(int(i) for i in input().split())
n=k1+k2+k3
l=[0 for i in range(n)]
for i in range(3):
l1=[int(j) for j in input().split()]
for j in l1:
l[j-1]=i
ans=0
m=0
for i in range(n):
if(l[i]<=1):
ans+=1
le=[0,0,0]
ri=[0,0,0]
for i in range(n):
ri[l[i]]+=1
for i in range(n):
le[l[i]]+=1
ri[l[i]]-=1
m=max(m,le[0]-le[1])
k=ri[0]+ri[1]+le[2]+le[0]-m
ans=min(ans,k)
print(ans)
``` | instruction | 0 | 3,455 | 11 | 6,910 |
Yes | output | 1 | 3,455 | 11 | 6,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant.
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**51, func=lambda a, b: a & b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
a,b,c=map(int,input().split())
s=set(map(int,input().split()))
s1=set(map(int,input().split()))
s2=set(map(int,input().split()))
dp=[[0 for i in range(3)]for j in range(a+b+c+1)]
for i in range(1,a+b+c+1):
dp[i][0]=dp[i-1][0]
dp[i][1]=min(dp[i-1][1],dp[i-1][0])
dp[i][2] = min(dp[i - 1][1], dp[i - 1][0],dp[i-1][2])
if i in s:
dp[i][1]+=1
dp[i][2]+=1
elif i in s1:
dp[i][0] += 1
dp[i][2] += 1
else:
dp[i][1] += 1
dp[i][0] += 1
print(min (dp[-1]))
#print(dp)
``` | instruction | 0 | 3,456 | 11 | 6,912 |
Yes | output | 1 | 3,456 | 11 | 6,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant.
Submitted Solution:
```
x,y,z=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
n=x+y+z
tag=[0 for i in range(n+1)]
fill=[[0]*(n+2) for i in range(3)]
refill=[[0]*(n+2) for i in range(3)]
d=[a,b,c]
k=[x,y,z]
for i in range(3):
for j in range(k[i]):
tag[d[i][j]]=i
for i in range(1,n+1):
for j in range(3):
if(tag[i]==j):
fill[j][i]=fill[j][i-1]
else:
fill[j][i]=fill[j][i-1]+1
for i in range(n,0,-1):
for j in range(3):
if(tag[i]==j):
refill[j][i]=refill[j][i+1]
else:
refill[j][i]=refill[j][i+1]+1
i,j=0,0
mini=99999999999
while(i<n+1):
if(fill[1][i]!=fill[1][i+1]):
mini=min(mini,min(fill[0][j],fill[1][j])+min(refill[1][i+1],refill[2][i+1]))
j=i+1
i+=1
if(mini==99999999999):
print(0)
else:
print(mini,x+y,y+z,z+x)
``` | instruction | 0 | 3,457 | 11 | 6,914 |
No | output | 1 | 3,457 | 11 | 6,915 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant.
Submitted Solution:
```
x,y,z=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
n=x+y+z
tag=[0 for i in range(n+1)]
fill=[[0]*(n+2) for i in range(3)]
refill=[[0]*(n+2) for i in range(3)]
d=[a,b,c]
k=[x,y,z]
for i in range(3):
for j in range(k[i]):
tag[d[i][j]]=i
for i in range(1,n+1):
for j in range(3):
if(tag[i]==j):
fill[j][i]=fill[j][i-1]
else:
fill[j][i]=fill[j][i-1]+1
for i in range(n,0,-1):
for j in range(3):
if(tag[i]==j):
refill[j][i]=refill[j][i+1]
else:
refill[j][i]=refill[j][i+1]+1
i,j=0,0
mini=99999999999
while(i<n+1):
if(fill[1][i]!=fill[1][i+1]):
mini=min(mini,min(fill[0][j],fill[1][j])+min(refill[1][i+1],refill[2][i+1]))
j=i+1
i+=1
if(mini==99999999999):
print(0)
else:
print(mini)
``` | instruction | 0 | 3,458 | 11 | 6,916 |
No | output | 1 | 3,458 | 11 | 6,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A team of three programmers is going to play a contest. The contest consists of n problems, numbered from 1 to n. Each problem is printed on a separate sheet of paper. The participants have decided to divide the problem statements into three parts: the first programmer took some prefix of the statements (some number of first paper sheets), the third contestant took some suffix of the statements (some number of last paper sheets), and the second contestant took all remaining problems. But something went wrong β the statements were printed in the wrong order, so the contestants have received the problems in some random order.
The first contestant has received problems a_{1, 1}, a_{1, 2}, ..., a_{1, k_1}. The second one has received problems a_{2, 1}, a_{2, 2}, ..., a_{2, k_2}. The third one has received all remaining problems (a_{3, 1}, a_{3, 2}, ..., a_{3, k_3}).
The contestants don't want to play the contest before they redistribute the statements. They want to redistribute them so that the first contestant receives some prefix of the problemset, the third contestant receives some suffix of the problemset, and the second contestant receives all the remaining problems.
During one move, some contestant may give one of their problems to other contestant. What is the minimum number of moves required to redistribute the problems?
It is possible that after redistribution some participant (or even two of them) will not have any problems.
Input
The first line contains three integers k_1, k_2 and k_3 (1 β€ k_1, k_2, k_3 β€ 2 β
10^5, k_1 + k_2 + k_3 β€ 2 β
10^5) β the number of problems initially taken by the first, the second and the third participant, respectively.
The second line contains k_1 integers a_{1, 1}, a_{1, 2}, ..., a_{1, k_1} β the problems initially taken by the first participant.
The third line contains k_2 integers a_{2, 1}, a_{2, 2}, ..., a_{2, k_2} β the problems initially taken by the second participant.
The fourth line contains k_3 integers a_{3, 1}, a_{3, 2}, ..., a_{3, k_3} β the problems initially taken by the third participant.
It is guaranteed that no problem has been taken by two (or three) participants, and each integer a_{i, j} meets the condition 1 β€ a_{i, j} β€ n, where n = k_1 + k_2 + k_3.
Output
Print one integer β the minimum number of moves required to redistribute the problems so that the first participant gets the prefix of the problemset, the third participant gets the suffix of the problemset, and the second participant gets all of the remaining problems.
Examples
Input
2 1 2
3 1
4
2 5
Output
1
Input
3 2 1
3 2 1
5 4
6
Output
0
Input
2 1 3
5 6
4
1 2 3
Output
3
Input
1 5 1
6
5 1 2 4 7
3
Output
2
Note
In the first example the third contestant should give the problem 2 to the first contestant, so the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 1 remaining problem.
In the second example the distribution of problems is already valid: the first contestant has 3 first problems, the third contestant has 1 last problem, and the second contestant has 2 remaining problems.
The best course of action in the third example is to give all problems to the third contestant.
The best course of action in the fourth example is to give all problems to the second contestant.
Submitted Solution:
```
import sys
input = sys.stdin.readline
k1,k2,k3=map(int,input().split())
A1=list(map(int,input().split()))
A2=list(map(int,input().split()))
A3=list(map(int,input().split()))
A1.sort()
A2.sort()
A3.sort()
S=k1+k2+k3
A1LIST=[0]*(S+1)
for a1 in A1:
A1LIST[a1]+=1
from itertools import accumulate
S1LIST=list(accumulate(A1LIST))
A1USE=[-1]*(S+1)
for i in range(S+1):
A1USE[i]=(i-S1LIST[i])+(S1LIST[-1]-S1LIST[i])
MIN=min(A1USE)
for i in range(S+1):
if A1USE[i]==MIN:
USE1=i
ANS=A1USE[USE1]
B2=[]
B3=[]
for a2 in A2:
if a2>USE1:
B2.append(a2)
for a3 in A3:
if a3>USE1:
B3.append(a3)
compression_dict={a: ind+1 for ind, a in enumerate(sorted(set(B2+B3)))}
B2=[compression_dict[a] for a in B2]
B3=[compression_dict[a] for a in B3]
S=len(B2)+len(B3)
B2LIST=[0]*(S+1)
for b2 in B2:
B2LIST[b2]+=1
S2LIST=list(accumulate(B2LIST))
B2USE=[-1]*(S+1)
for i in range(S+1):
B2USE[i]=(i-S2LIST[i])+(S2LIST[-1]-S2LIST[i])
MIN=min(B2USE)
for i in range(S+1):
if B2USE[i]==MIN:
USE2=i
ANS2=B2USE[USE2]
print(ANS+ANS2)
``` | instruction | 0 | 3,459 | 11 | 6,918 |
No | output | 1 | 3,459 | 11 | 6,919 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.