message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Medicine faculty of Berland State University has just finished their admission campaign. As usual, about 80\% of applicants are girls and majority of them are going to live in the university dormitory for the next 4 (hopefully) years.
The dormitory consists of n rooms and a single mouse! Girls decided to set mouse traps in some rooms to get rid of the horrible monster. Setting a trap in room number i costs c_i burles. Rooms are numbered from 1 to n.
Mouse doesn't sit in place all the time, it constantly runs. If it is in room i in second t then it will run to room a_i in second t + 1 without visiting any other rooms inbetween (i = a_i means that mouse won't leave room i). It's second 0 in the start. If the mouse is in some room with a mouse trap in it, then the mouse get caught into this trap.
That would have been so easy if the girls actually knew where the mouse at. Unfortunately, that's not the case, mouse can be in any room from 1 to n at second 0.
What it the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from?
Input
The first line contains as single integers n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of rooms in the dormitory.
The second line contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^4) — c_i is the cost of setting the trap in room number i.
The third line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — a_i is the room the mouse will run to the next second after being in room i.
Output
Print a single integer — the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from.
Examples
Input
5
1 2 3 2 10
1 3 4 3 3
Output
3
Input
4
1 10 2 10
2 4 2 2
Output
10
Input
7
1 1 1 1 1 1 1
2 2 2 3 6 7 6
Output
2
Note
In the first example it is enough to set mouse trap in rooms 1 and 4. If mouse starts in room 1 then it gets caught immideately. If mouse starts in any other room then it eventually comes to room 4.
In the second example it is enough to set mouse trap in room 2. If mouse starts in room 2 then it gets caught immideately. If mouse starts in any other room then it runs to room 2 in second 1.
Here are the paths of the mouse from different starts from the third example:
* 1 → 2 → 2 → ...;
* 2 → 2 → ...;
* 3 → 2 → 2 → ...;
* 4 → 3 → 2 → 2 → ...;
* 5 → 6 → 7 → 6 → ...;
* 6 → 7 → 6 → ...;
* 7 → 6 → 7 → ...;
So it's enough to set traps in rooms 2 and 6.
Submitted Solution:
```
n = int(input())
c = list(map(int, input().strip().split()))
a = list(map(int, input().strip().split()))
resd = {}
res = 0
for i in range(n):
d = {}
cur = i + 1
if cur in d:
continue
d[cur] = 1
group = []
while cur not in group:
group.append(cur)
cur = a[cur-1]
d[cur] = 1
mmin = float('inf')
flag = False
for item in group:
if item == cur:
flag = True
if flag:
mmin = min(mmin, c[item-1])
if mmin in resd:
continue
#print(mmin, group, cur)
resd[mmin] = 1
res += mmin
print(res)
``` | instruction | 0 | 88,369 | 8 | 176,738 |
No | output | 1 | 88,369 | 8 | 176,739 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Medicine faculty of Berland State University has just finished their admission campaign. As usual, about 80\% of applicants are girls and majority of them are going to live in the university dormitory for the next 4 (hopefully) years.
The dormitory consists of n rooms and a single mouse! Girls decided to set mouse traps in some rooms to get rid of the horrible monster. Setting a trap in room number i costs c_i burles. Rooms are numbered from 1 to n.
Mouse doesn't sit in place all the time, it constantly runs. If it is in room i in second t then it will run to room a_i in second t + 1 without visiting any other rooms inbetween (i = a_i means that mouse won't leave room i). It's second 0 in the start. If the mouse is in some room with a mouse trap in it, then the mouse get caught into this trap.
That would have been so easy if the girls actually knew where the mouse at. Unfortunately, that's not the case, mouse can be in any room from 1 to n at second 0.
What it the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from?
Input
The first line contains as single integers n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of rooms in the dormitory.
The second line contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^4) — c_i is the cost of setting the trap in room number i.
The third line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — a_i is the room the mouse will run to the next second after being in room i.
Output
Print a single integer — the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from.
Examples
Input
5
1 2 3 2 10
1 3 4 3 3
Output
3
Input
4
1 10 2 10
2 4 2 2
Output
10
Input
7
1 1 1 1 1 1 1
2 2 2 3 6 7 6
Output
2
Note
In the first example it is enough to set mouse trap in rooms 1 and 4. If mouse starts in room 1 then it gets caught immideately. If mouse starts in any other room then it eventually comes to room 4.
In the second example it is enough to set mouse trap in room 2. If mouse starts in room 2 then it gets caught immideately. If mouse starts in any other room then it runs to room 2 in second 1.
Here are the paths of the mouse from different starts from the third example:
* 1 → 2 → 2 → ...;
* 2 → 2 → ...;
* 3 → 2 → 2 → ...;
* 4 → 3 → 2 → 2 → ...;
* 5 → 6 → 7 → 6 → ...;
* 6 → 7 → 6 → ...;
* 7 → 6 → 7 → ...;
So it's enough to set traps in rooms 2 and 6.
Submitted Solution:
```
def tarjanst(i):
global tast,n,c,adjli,llv;
tast.append(i);c[i]=1;
for j in adjli[i]:
if c[j]==0:
tarjanst(j)
if c[j]==1:
temp=j
while tast[-1]!=j:
llv[tast[-1]]=min(llv[tast[-1]],llv[temp])
temp=tast.pop(-1)
llv[tast[-1]]=min(llv[tast[-1]],llv[temp])
tast.pop(-1)
c[i]=2
def tarjans():
global c,n,tast;
for i in range(n):
if c[i]==0:
tarjanst(i)
guaran=[];fans=0;
n=int(input())
llv=[i for i in range(n)];tast=[];c=[0 for i in range(n)]
cost=list(map(int,input().strip().split(' ')))
d=list(map(int,input().strip().split(' ')))
#if n==200000 and cost[0]==4052 and cost[1]==1718 and cost[2]==9082:
# print(1)
try:
adjli=[]
for i in range(n):
adjli.append([])
for i in range(len(d)):
if i==d[i]-1:
fans+=cost[i]
adjli[i].append(d[i]-1)
tarjans()
#print(llv)
d={}
for i in range(len(llv)):
if llv[i] in d:
d[llv[i]].append(i)
else:
d[llv[i]]=[i]
for i in d:
if len(d[i])>1:
mi=cost[d[i][0]]
for j in d[i]:
if cost[j]<mi:
mi=cost[j]
guaran.append(mi)
print(sum(guaran)+fans)
except BaseException as error:
print(error)
``` | instruction | 0 | 88,370 | 8 | 176,740 |
No | output | 1 | 88,370 | 8 | 176,741 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Medicine faculty of Berland State University has just finished their admission campaign. As usual, about 80\% of applicants are girls and majority of them are going to live in the university dormitory for the next 4 (hopefully) years.
The dormitory consists of n rooms and a single mouse! Girls decided to set mouse traps in some rooms to get rid of the horrible monster. Setting a trap in room number i costs c_i burles. Rooms are numbered from 1 to n.
Mouse doesn't sit in place all the time, it constantly runs. If it is in room i in second t then it will run to room a_i in second t + 1 without visiting any other rooms inbetween (i = a_i means that mouse won't leave room i). It's second 0 in the start. If the mouse is in some room with a mouse trap in it, then the mouse get caught into this trap.
That would have been so easy if the girls actually knew where the mouse at. Unfortunately, that's not the case, mouse can be in any room from 1 to n at second 0.
What it the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from?
Input
The first line contains as single integers n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of rooms in the dormitory.
The second line contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^4) — c_i is the cost of setting the trap in room number i.
The third line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — a_i is the room the mouse will run to the next second after being in room i.
Output
Print a single integer — the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from.
Examples
Input
5
1 2 3 2 10
1 3 4 3 3
Output
3
Input
4
1 10 2 10
2 4 2 2
Output
10
Input
7
1 1 1 1 1 1 1
2 2 2 3 6 7 6
Output
2
Note
In the first example it is enough to set mouse trap in rooms 1 and 4. If mouse starts in room 1 then it gets caught immideately. If mouse starts in any other room then it eventually comes to room 4.
In the second example it is enough to set mouse trap in room 2. If mouse starts in room 2 then it gets caught immideately. If mouse starts in any other room then it runs to room 2 in second 1.
Here are the paths of the mouse from different starts from the third example:
* 1 → 2 → 2 → ...;
* 2 → 2 → ...;
* 3 → 2 → 2 → ...;
* 4 → 3 → 2 → 2 → ...;
* 5 → 6 → 7 → 6 → ...;
* 6 → 7 → 6 → ...;
* 7 → 6 → 7 → ...;
So it's enough to set traps in rooms 2 and 6.
Submitted Solution:
```
from collections import deque
n = int(input())
def index(x):
return int(x)-1
c = list(map(int, input().split()))
a = list(map(index, input().split()))
graph = {}
for i in range(n):
graph[i] = []
for i in range(n):
graph[i].append(a[i])
# graph[a[i]].append(i)
added = [False] * n
visited = [False] * n
cycles = []
q = deque()
ret = 0
for i in range(n):
if visited[i]:
continue
visited[i] = True
minVal = float('inf')
q.append(i)
# newAdd = added[:]
while q:
r = q.popleft()
v = a[r]
if visited[v]:
cycles.append(set())
forw = v
cycles[-1].add(forw)
dock = forw
while a[forw] != dock and forw != a[forw]:
forw = a[forw]
cycles[-1].add(forw)
else:
q.append(v)
visited[v] = True
# print(cycles)
for cy in cycles:
minVal = float('inf')
for num in cy:
if c[num] < minVal:
minVal = c[num]
minNum = num
if cy:
ret += minVal
print(ret)
``` | instruction | 0 | 88,371 | 8 | 176,742 |
No | output | 1 | 88,371 | 8 | 176,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks. | instruction | 0 | 88,852 | 8 | 177,704 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
n,m = map(int, input().split())
answer=0
while True:
if n >=3 and m>=2:
if n/m>3/2:
n-=3
m-=1
else:
n-=2
m-=2
answer+=6
else:
if m == 1:
answer += max(3, 2* n)
break
elif m == 0:
answer+= 2*n
break
else:
answer += 3*m
break
print(answer)
``` | output | 1 | 88,852 | 8 | 177,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks. | instruction | 0 | 88,853 | 8 | 177,706 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
n, m = map(int, input().split())
start = 0
end = 10**10
while (end - start > 1):
mid = (end + start) // 2
two = mid // 2 - mid // 6
three = mid // 3 - mid // 6
six = mid // 6
nn = n
mm = m
nn -= two
mm -= three
nn = max(nn, 0)
mm = max(mm, 0)
if (six >= nn + mm):
end = mid
else:
start = mid
print(end)
``` | output | 1 | 88,853 | 8 | 177,707 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks. | instruction | 0 | 88,854 | 8 | 177,708 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
n, m = input().split()
n = int(n)
m = int(m)
res_n = n * 2
res_m = m * 3
tmp_height = 6
while(tmp_height <= min(res_n, res_m)):
tmpresn = res_n + 2
tmpresm = res_m + 3
# print(tmpresn)
# print(tmpresm)
if max(tmpresn, res_m) > max(res_n, tmpresm):
res_m = tmpresm
else:
res_n = tmpresn
tmp_height += 6
print(max(res_m, res_n))
``` | output | 1 | 88,854 | 8 | 177,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks. | instruction | 0 | 88,855 | 8 | 177,710 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
n,m=map(int,input().split())
curr=max(n*2,m*3)
while n+m>(curr//2+curr//3-curr//6):
curr+=1
print(curr)
``` | output | 1 | 88,855 | 8 | 177,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks. | instruction | 0 | 88,856 | 8 | 177,712 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
nm = input().split(" ")
n = int(nm[0])
m = int(nm[1])
#not allowed to be the same height, not not same number of blocks
if n == 0:
print(3*m)
elif m == 0:
print(2*n)
else:
new = max(3*m, 2*n)
i = 0
while i<new+1:
if i%6 == 0 and i != 0:
if i//3 <= m and i//2 <= n and 2*(n+1)-new < 3*(m+1)-new:
n += 1
elif i//3 <= m and i//2 <= n and 2*(n+1)-new >= 3*(m+1)-new:
m += 1
new = max(3*m, 2*n)
i+=1
print(max(3*m,2*n))
``` | output | 1 | 88,856 | 8 | 177,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks. | instruction | 0 | 88,857 | 8 | 177,714 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
if __name__=='__main__':
d,t = map(int,input().split(' '))
result = 0
i2 = d*2
i3 = t*3
cm = int(max(i2,i3)/6) #common
while cm>0:
if i2+2<i3+3:
i2+=2
elif i2+2> i3+3:
i3+=3
else:
i2+=2
cm+=1
cm-=1
print (max(i2,i3))
'''
if index2+common*2<=index3:
result = index3
else:
result = index2+common*2
if index2>=index3+common*3:
result = index2
'''
'''
while common>0:
print (d,t,common,oldCommon)
if (d+1)*2<=(t+1)*3:
d+=1
else:
t+=1
index2 = d*2
index3 = t*3
print (index2,index3)
common = int(min(index2,index3)/6)
x = common
common-=oldCommon
oldCommon=x
print(max(index2,index3))
'''
'''
C. Block Towers
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks.
'''
``` | output | 1 | 88,857 | 8 | 177,715 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks. | instruction | 0 | 88,858 | 8 | 177,716 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
def check(n, m, ans):
div2 = ans // 2
div3 = ans // 3
div6 = ans // 6
k = 0
if div2 < n or div3 < m:
return False
if div2 - div6 < n:
k = n - (div2 - div6)
return div3 - k >= m
n, m = list(map(int, input().split()))
l = -1
r = max(n * 6, m * 6) + 1
while l < r - 1:
mid = (l + r) // 2
if check(n, m, mid):
r = mid
else:
l = mid
print(r)
``` | output | 1 | 88,858 | 8 | 177,717 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks. | instruction | 0 | 88,859 | 8 | 177,718 |
Tags: brute force, greedy, math, number theory
Correct Solution:
```
n, m = map(int, input().split())
num = max(n * 2, m * 3)
while True:
if num % 2 == 0 or num % 3 == 0:
x = num // 2
y = num // 3
z = num // 6
if x >= n and y >= m and x + y - z >= m + n:
print(num)
exit()
num += 1
``` | output | 1 | 88,859 | 8 | 177,719 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks.
Submitted Solution:
```
def right(m, n, a):
b = True
n2 = a // 2 - a // 6
n3 = a // 3 - a // 6
n6 = a // 6
if n2+n6<n or n3+n6<m or n2+n3+n6<n+m:
b = False
return b
n, m = map(int, input().split())
ans = n+m
while not right(m, n, ans):
ans += 1
print(ans)
``` | instruction | 0 | 88,860 | 8 | 177,720 |
Yes | output | 1 | 88,860 | 8 | 177,721 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks.
Submitted Solution:
```
n,m = map(int,input().split())
ans = max(n*2, m*3)
while ans//2 + ans//3 - ans//6 < n+m:
ans += 1
print(ans)
``` | instruction | 0 | 88,861 | 8 | 177,722 |
Yes | output | 1 | 88,861 | 8 | 177,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks.
Submitted Solution:
```
n, m = map(int,input().split())
a, b, i = 2 * n, 3 * m, 6
while i <= min(a, b):
if b < a: b += 3
else: a += 2
i += 6
print(max(a, b))
``` | instruction | 0 | 88,862 | 8 | 177,724 |
Yes | output | 1 | 88,862 | 8 | 177,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks.
Submitted Solution:
```
#!/usr/bin/env python3
read_ints = lambda : map(int, input().split())
def solve(m, n):
h2 , h3 = 2*m , 3*n
left = min(h2,h3) // 6
while left > 0:
# print('h2=%d h3=%d n=%d' % (h2, h3, left))
if h2+2 < h3+3:
h2 += 2
if (h2 % 3 != 0) or (h2 > h3):
left -= 1
else:
h3 += 3
if (h3 % 2 != 0) or (h3 > h2):
left -= 1
return max(h2,h3)
if __name__ == '__main__':
m, n = read_ints()
print(solve(m, n))
``` | instruction | 0 | 88,863 | 8 | 177,726 |
Yes | output | 1 | 88,863 | 8 | 177,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks.
Submitted Solution:
```
n, m = map(int, input().split())
mx = m * 3
nx = mx // 6 * 2 + n * 2
ny = n * 2
my = ny // 6 * 3 + m * 3
print(min(max(nx, mx), max(ny, my)))
``` | instruction | 0 | 88,864 | 8 | 177,728 |
No | output | 1 | 88,864 | 8 | 177,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks.
Submitted Solution:
```
a, b = input().split()
a = int(a)
b = int(b)
cont = 0
def alt_min(n, m):
global a_mtn, a_mtm, cont
a_mtn = n*2
#print(a_mtn)
a_mtm = m*3
#print(a_mtm)
if a_mtn %3 == 0 and (n+1)*2 < (m+1)*3 and cont == 0:
#print('entrou')
cont += 1
alt_min(n+1, m)
elif a_mtm % 2 == 0 and cont == 0:
#print('ent_3')
cont += 1
alt_min(n, m+1)
else:
#print('chamou_dnv')
#print(a_mtn)
#print(a_mtm)
return(max(a_mtn, a_mtm))
alt_min(a, b)
print(max(a_mtm, a_mtn))
# 1481132396353
``` | instruction | 0 | 88,865 | 8 | 177,730 |
No | output | 1 | 88,865 | 8 | 177,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks.
Submitted Solution:
```
nm = input().split(" ")
n = int(nm[0])
m = int(nm[1])
#not allowed to be the same height, not not same number of blocks
if n == 0:
print(3*m)
elif m == 0:
print(2*n)
else:
new = max(3*m, 2*n)
for i in range(new+1):
if i%6 == 0 and i != 0:
if i//3 <= m and i//2 <= n and 2*(n+1)-new < 3*(m+1)-new:
n += 1
elif i//3 <= m and i//2 <= n and 2*(n+1)-new >= 3*(m+1)-new:
m += 1
print(max(3*m,2*n))
``` | instruction | 0 | 88,866 | 8 | 177,732 |
No | output | 1 | 88,866 | 8 | 177,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks.
Submitted Solution:
```
import math
n, m=map(int, input().rstrip().split())
nums_3=[]
for i in range(m):
nums_3.append(3*(i+1))
#print(nums_3)
total=0
if len(nums_3)==0:
print(n*2)
else:
for i in range(10**9):
c=2*(i+1)
if c not in nums_3:
total+=1
if total==n:
print(max(max(nums_3), c))
break
``` | instruction | 0 | 88,867 | 8 | 177,734 |
No | output | 1 | 88,867 | 8 | 177,735 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1. | instruction | 0 | 88,937 | 8 | 177,874 |
Tags: greedy
Correct Solution:
```
n = int(input())
a = input().split()
repeats = []
for i in range(n):
repeats.append(a.count(a[i]))
print(max(repeats))
``` | output | 1 | 88,937 | 8 | 177,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1. | instruction | 0 | 88,938 | 8 | 177,876 |
Tags: greedy
Correct Solution:
```
N = int(input())
boxes = list(map(int,input().split()))
high = 0
for item in boxes:
high = max(high, boxes.count(item))
print(high)
``` | output | 1 | 88,938 | 8 | 177,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1. | instruction | 0 | 88,939 | 8 | 177,878 |
Tags: greedy
Correct Solution:
```
#Ya Hassan Mojtaba
n=int(input())
my=[n for n in input().split()]
ans=1
for i in my:
ans=max(my.count(i),ans)
print(ans)
``` | output | 1 | 88,939 | 8 | 177,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1. | instruction | 0 | 88,940 | 8 | 177,880 |
Tags: greedy
Correct Solution:
```
n = int(input())
s = input()
k = list(map(int, s.split()))
name =[]
count = []
for each in k:
if (each in name) == True:
count[name.index(each)] += 1
else:
name.append(each)
count.append(1)
print(max(count))
``` | output | 1 | 88,940 | 8 | 177,881 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1. | instruction | 0 | 88,941 | 8 | 177,882 |
Tags: greedy
Correct Solution:
```
n= int(input())
lis=list(map(int,input().split()))
lis.sort()
c=1
mx=1
for i in range(n-1):
if lis[i]==lis[i+1]:
c+=1
else:
c=1
if mx<c:
mx=c
print(mx)
``` | output | 1 | 88,941 | 8 | 177,883 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1. | instruction | 0 | 88,942 | 8 | 177,884 |
Tags: greedy
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Tue Dec 12 19:12:40 2017
@author: ms
"""
def merge(left, right):
a = []
left.append(float("Inf"))
right.append(float("Inf"))
i = 0
j = 0
iters = len(left) + len(right)
for k in range(iters-2):
if left[i] <= right[j]:
a.append(left[i])
i += 1
else:
a.append(right[j])
j += 1
return a
def merge_sort(a):
mid = int(len(a) / 2)
if (mid > 0):
left = a[:mid]
right = a[mid:]
left = merge_sort(left)
right = merge_sort(right)
return merge(left,right)
return a
def main():
n = int(input())
lens = [int(x) for x in input().split()]
#lens = merge_sort(lens)
box = 0
while(len(lens)):
s = list(set(lens))
for i in range(len(s)):
lens.remove(s[i])
box += 1
print(box)
main()
``` | output | 1 | 88,942 | 8 | 177,885 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1. | instruction | 0 | 88,943 | 8 | 177,886 |
Tags: greedy
Correct Solution:
```
from collections import defaultdict
n=int(input())
a=sorted(list(map(int,input().split())))
d=defaultdict(int)
for i in a:
d[i]+=1
print(max(d.values()))
``` | output | 1 | 88,943 | 8 | 177,887 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1. | instruction | 0 | 88,944 | 8 | 177,888 |
Tags: greedy
Correct Solution:
```
input()
a={}
for i in input().split():
i=int(i)
if i in a:
a[i]+=1
else:
a[i]=1
a=sorted(a.items(),key=lambda i:i[0],reverse=True)
b=[i[1] for i in a]
print(max(b))
``` | output | 1 | 88,944 | 8 | 177,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1.
Submitted Solution:
```
n=int(input())
a={}
mx=0
for i in map(int,input().split()):
if i not in a:
a[i]=1
if mx<a[i]:
mx=a[i]
else:
a[i]+=1
if mx<a[i]:
mx=a[i]
print(mx)
``` | instruction | 0 | 88,945 | 8 | 177,890 |
Yes | output | 1 | 88,945 | 8 | 177,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1.
Submitted Solution:
```
n = int(input())
skatle = list(map(int, input().strip().split()))
st = dict()
for e in skatle:
if e not in st:
st[e] = 0
st[e] += 1
S = [(s,kol) for s,kol in st.items()]
print(max(k for (s,k) in S))
``` | instruction | 0 | 88,946 | 8 | 177,892 |
Yes | output | 1 | 88,946 | 8 | 177,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1.
Submitted Solution:
```
from collections import Counter
nos_of_boxex = int(input())
boxes = [int(x) for x in input().split()]
print(max(Counter(boxes).values()))
``` | instruction | 0 | 88,947 | 8 | 177,894 |
Yes | output | 1 | 88,947 | 8 | 177,895 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1.
Submitted Solution:
```
n = int(input())
a = [int(i) for i in input().split()]
m = 0
b = {}
for i in a:
try:
b[i] += 1
except KeyError:
b[i] = 1
if b[i] > m: m = b[i]
print(m)
``` | instruction | 0 | 88,948 | 8 | 177,896 |
Yes | output | 1 | 88,948 | 8 | 177,897 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1.
Submitted Solution:
```
n=int(input())
a=[*map(int, input().split())]
#a=[int(i) for i in input().split()]
a.sort()
g=0
for i in range(n-1):
if a[i+1]>a[i]:
g+=1
print(n-g)
``` | instruction | 0 | 88,949 | 8 | 177,898 |
No | output | 1 | 88,949 | 8 | 177,899 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
a.sort()
res = 1
while len(a) > 1:
if a[0] == a[1]:
res += 1
a.pop(0)
print(res)
``` | instruction | 0 | 88,950 | 8 | 177,900 |
No | output | 1 | 88,950 | 8 | 177,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1.
Submitted Solution:
```
def solve(array):
temp = list()
track = dict()
for i in array:
if i in track:
track[i]+=1
else:
track[i] = 1
for key,values in sorted(track.items()):
temp.append(values)
ans = 0
extra = 0
for i in range(len(temp)-1):
ans += min(temp[i]+extra,temp[i+1])
if(temp[i]>temp[i+1]):
extra+=(temp[i]-temp[i+1])
return len(array)-ans
if __name__ == "__main__":
t = int(input())
arr = list(map(int,input().split(" ")))
print(solve(arr))
``` | instruction | 0 | 88,951 | 8 | 177,902 |
No | output | 1 | 88,951 | 8 | 177,903 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1.
Submitted Solution:
```
import collections
n = int(input())
nums = list(map(int,input().split()))
d = collections.defaultdict(int)
for i in nums:
d[i] += 1
k = sorted(d.keys())
if len(k)==1:
print(1)
exit()
t = d[k[0]]
s = 0
for i in range(1,len(k)):
in_boxes = min(d[k[i]],t)
t = t + d[k[i]] - in_boxes
s += in_boxes
print(n-s)
``` | instruction | 0 | 88,952 | 8 | 177,904 |
No | output | 1 | 88,952 | 8 | 177,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong — the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure — and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...
For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.
However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus — Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.
This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with n nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to n. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).
In Hexadecimal's game all the trees are different, but the height of each is not lower than h. In this problem «height» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
Input
The input data contains two space-separated positive integer numbers n and h (n ≤ 35, h ≤ n).
Output
Output one number — the answer to the problem. It is guaranteed that it does not exceed 9·1018.
Examples
Input
3 2
Output
5
Input
3 3
Output
4
Submitted Solution:
```
n, h = map(int, input().split())
less = [[1] * (n + 2)] + [[0] * (n + 2) for i in range(n)] # dp[n][h]
ge = [[0] * (n + 2) for i in range(n + 1)] # dp[n][h]
less[0][0] = 0
less[0][-1] = 0
ge[0][0] = 1
ge[0][-1] = 1
for i in range(1, n + 1):
for j in range(0, n + 1):
for k in range(1, i + 1):
if j > 0:
less[i][j] += less[k - 1][j - 1] * less[i - k][j - 1]
ge[i][j] += ge[k - 1][j - 1] * less[i - k][j - 1] + \
less[k - 1][j - 1] * ge[i - k][j - 1] + \
ge[k - 1][j - 1] * ge[i - k][j - 1]
ge[i][-1] = ge[i][0]
print(ge[n][h])
``` | instruction | 0 | 88,983 | 8 | 177,966 |
Yes | output | 1 | 88,983 | 8 | 177,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong — the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure — and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...
For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.
However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus — Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.
This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with n nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to n. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).
In Hexadecimal's game all the trees are different, but the height of each is not lower than h. In this problem «height» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
Input
The input data contains two space-separated positive integer numbers n and h (n ≤ 35, h ≤ n).
Output
Output one number — the answer to the problem. It is guaranteed that it does not exceed 9·1018.
Examples
Input
3 2
Output
5
Input
3 3
Output
4
Submitted Solution:
```
# coding: utf-8
# In[9]:
# In[42]:
line = input().split()
n = int(line[0])
h = int(line[1])
from math import log
array_nodes_minheigt = [[0 for x in range(36)] for y in range(36)]
array_nodes_minheigt[0][0] = 1
for nodes in range(1,36):
for minheight in range(0,nodes+1):
for topnode in range(1, nodes + 1):
left = topnode-1
right = nodes - topnode
array_nodes_minheigt[nodes][minheight] += array_nodes_minheigt[left][0] * array_nodes_minheigt[right][0] - (array_nodes_minheigt[left][0]-array_nodes_minheigt[left][max(minheight-1,0)])* (array_nodes_minheigt[right][0]-array_nodes_minheigt[right][max(minheight-1,0)])
print(int(array_nodes_minheigt[n][h]))
``` | instruction | 0 | 88,984 | 8 | 177,968 |
Yes | output | 1 | 88,984 | 8 | 177,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong — the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure — and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...
For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.
However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus — Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.
This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with n nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to n. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).
In Hexadecimal's game all the trees are different, but the height of each is not lower than h. In this problem «height» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
Input
The input data contains two space-separated positive integer numbers n and h (n ≤ 35, h ≤ n).
Output
Output one number — the answer to the problem. It is guaranteed that it does not exceed 9·1018.
Examples
Input
3 2
Output
5
Input
3 3
Output
4
Submitted Solution:
```
# coding: utf-8
# In[9]:
# In[42]:
line = input().split()
n = int(line[0])
h = int(line[1])
from math import log
array_nodes_minheigt = [[0 for x in range(36)] for y in range(36)]
array_nodes_minheigt[0][0] = 1
for nodes in range(1,36):
for minheight in range(0,nodes+1):
for topnode in range(1, nodes + 1):
left = topnode-1
right = nodes - topnode
array_nodes_minheigt[nodes][minheight] += array_nodes_minheigt[left][0] * array_nodes_minheigt[right][0] - (array_nodes_minheigt[left][0]-array_nodes_minheigt[left][max(minheight-1,0)])* (array_nodes_minheigt[right][0]-array_nodes_minheigt[right][max(minheight-1,0)])
print(int(array_nodes_minheigt[n][h]))
# Made By Mostafa_Khaled
``` | instruction | 0 | 88,985 | 8 | 177,970 |
Yes | output | 1 | 88,985 | 8 | 177,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong — the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure — and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...
For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.
However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus — Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.
This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with n nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to n. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).
In Hexadecimal's game all the trees are different, but the height of each is not lower than h. In this problem «height» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
Input
The input data contains two space-separated positive integer numbers n and h (n ≤ 35, h ≤ n).
Output
Output one number — the answer to the problem. It is guaranteed that it does not exceed 9·1018.
Examples
Input
3 2
Output
5
Input
3 3
Output
4
Submitted Solution:
```
def main():
(n, h) = input().split()
n = int(n)
h = int(h)
#(n, h) = (3, 3)
memo = [([None] * (h + 1)) for i in range(n + 1)]
catalans = [catalan(i) for i in range(n + 1)]
print(calculate(n, h, memo, catalans))
def calculate(n, h, memo, catalans):
if memo[n][h] != None:
return memo[n][h]
elif n < h:
memo[n][h] = 0
return 0
elif n <= 1:
memo[n][h] = 1
return 1
else:
if h == 0:
newH = 0
else:
newH = h - 1
total = 0
for left in range(n):
right = n - left - 1
calcLeft = calculate(left, newH, memo, catalans)
calcRight = calculate(right, newH, memo, catalans)
total += (calcLeft * catalans[right]) + \
(calcRight * catalans[left]) - (calcLeft * calcRight)
memo[n][h] = total
return total
def catalan(n):
product = 1
for top in range(n + 1, 2 * n + 1):
product *= top
for bot in range(2, n + 1):
product //= bot
product //= (n + 1)
return product
#print(catalan(4))
main()
``` | instruction | 0 | 88,986 | 8 | 177,972 |
Yes | output | 1 | 88,986 | 8 | 177,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong — the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure — and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...
For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.
However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus — Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.
This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with n nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to n. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).
In Hexadecimal's game all the trees are different, but the height of each is not lower than h. In this problem «height» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
Input
The input data contains two space-separated positive integer numbers n and h (n ≤ 35, h ≤ n).
Output
Output one number — the answer to the problem. It is guaranteed that it does not exceed 9·1018.
Examples
Input
3 2
Output
5
Input
3 3
Output
4
Submitted Solution:
```
import sys
from array import array # noqa: F401
from math import factorial
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n, h = map(int, input().split())
catalan = [factorial(2 * i) // factorial(i + 1) // factorial(i) for i in range(26)]
dp = [[-1] * 100 for _ in range(100)]
dp[0][0] = 1
def solve(x, h):
if dp[x][h] != -1:
return dp[x][h]
res = 0
for l, r in zip(range(x), range(x - 1, -1, -1)):
if l >= h - 1:
res += solve(l, h - 1) * catalan[r]
if r >= h - 1:
res += catalan[l] * solve(r, h - 1)
if l >= h - 1 and r >= -1:
res -= solve(l, h - 1) * solve(r, h - 1)
dp[x][h] = res
return res
print(solve(n, h))
``` | instruction | 0 | 88,987 | 8 | 177,974 |
No | output | 1 | 88,987 | 8 | 177,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong — the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure — and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...
For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.
However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus — Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.
This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with n nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to n. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).
In Hexadecimal's game all the trees are different, but the height of each is not lower than h. In this problem «height» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
Input
The input data contains two space-separated positive integer numbers n and h (n ≤ 35, h ≤ n).
Output
Output one number — the answer to the problem. It is guaranteed that it does not exceed 9·1018.
Examples
Input
3 2
Output
5
Input
3 3
Output
4
Submitted Solution:
```
dic={}
def dfs(a,res):
if a<=1:
return 1
elif a*100+res in dic:
return dic[a*100+res]
else:
cnt=0
for i in range(a):
if i<res-1 and a-i-1<res-1:
continue
else:
cnt=cnt+dfs(i,res-1)*dfs(a-i-1,res-1)
dic[a*100+res]=cnt
return cnt
inp=input().split()
print(dfs(int(inp[0]),int(inp[1])))
``` | instruction | 0 | 88,988 | 8 | 177,976 |
No | output | 1 | 88,988 | 8 | 177,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong — the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure — and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...
For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.
However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus — Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.
This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with n nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to n. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).
In Hexadecimal's game all the trees are different, but the height of each is not lower than h. In this problem «height» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
Input
The input data contains two space-separated positive integer numbers n and h (n ≤ 35, h ≤ n).
Output
Output one number — the answer to the problem. It is guaranteed that it does not exceed 9·1018.
Examples
Input
3 2
Output
5
Input
3 3
Output
4
Submitted Solution:
```
n, h = map(int, input().split())
node_counts = [0]
dp = [[0 for j in range(n+1)] for i in range(n+1)]
# Maximum amount of nodes for each height
for i in range(n):
node_counts.append(node_counts[-1] + (2**i))
for i in range(1, n+1):
for j in range(1, n+1):
if (j < i or j > node_counts[i]): continue
elif (j == node_counts[i]):
dp[i][j] = 1
continue
for l in range(0, j):
left = dp[i-1][l]
right = dp[i-1][j-l-1]
if (left == 0 and right == 0): continue
if (left == 0): left = 1
if (right == 0): right = 1
dp[i][j] += left * right
s = 0
for i in range(h, n+1):
s += dp[i][n]
print(s)
``` | instruction | 0 | 88,989 | 8 | 177,978 |
No | output | 1 | 88,989 | 8 | 177,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong — the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure — and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...
For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.
However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus — Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.
This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with n nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to n. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).
In Hexadecimal's game all the trees are different, but the height of each is not lower than h. In this problem «height» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
Input
The input data contains two space-separated positive integer numbers n and h (n ≤ 35, h ≤ n).
Output
Output one number — the answer to the problem. It is guaranteed that it does not exceed 9·1018.
Examples
Input
3 2
Output
5
Input
3 3
Output
4
Submitted Solution:
```
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n, h = map(int, input().split())
dp = [[[0] * (n + 2) for _ in range(n + 2)] for _ in range(n * 2)]
dp[0][1][1] = 1
for i in range(n * 2 - 1):
for j in range(n + 1):
for k in range(j + 1):
if k > 0:
dp[i + 1][j][k - 1] += dp[i][j][k]
dp[i + 1][j + 1 if k == j else j][k + 1] += dp[i][j][k]
ans = 0
for i in range(max(0, h - 1), n + 1):
ans += dp[-1][i][0]
print(ans)
``` | instruction | 0 | 88,990 | 8 | 177,980 |
No | output | 1 | 88,990 | 8 | 177,981 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave.
The cave has N rooms and M passages. The rooms are numbered 1 to N, and the passages are numbered 1 to M. Passage i connects Room A_i and Room B_i bidirectionally. One can travel between any two rooms by traversing passages. Room 1 is a special room with an entrance from the outside.
It is dark in the cave, so we have decided to place a signpost in each room except Room 1. The signpost in each room will point to one of the rooms directly connected to that room with a passage.
Since it is dangerous in the cave, our objective is to satisfy the condition below for each room except Room 1.
* If you start in that room and repeatedly move to the room indicated by the signpost in the room you are in, you will reach Room 1 after traversing the minimum number of passages possible.
Determine whether there is a way to place signposts satisfying our objective, and print one such way if it exists.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq M \leq 2 \times 10^5
* 1 \leq A_i, B_i \leq N\ (1 \leq i \leq M)
* A_i \neq B_i\ (1 \leq i \leq M)
* One can travel between any two rooms by traversing passages.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
If there is no way to place signposts satisfying the objective, print `No`.
Otherwise, print N lines. The first line should contain `Yes`, and the i-th line (2 \leq i \leq N) should contain the integer representing the room indicated by the signpost in Room i.
Examples
Input
4 4
1 2
2 3
3 4
4 2
Output
Yes
1
2
2
Input
6 9
3 4
6 1
2 4
5 3
4 6
1 5
6 2
4 5
5 6
Output
Yes
6
5
5
1
1 | instruction | 0 | 89,007 | 8 | 178,014 |
"Correct Solution:
```
from collections import deque
n,m = map(int,input().split())
ab = [list(map(int, input().split())) for _ in range(m)]
path = [[] for _ in range(n+1)]
for a,b in ab:
path[a].append(b)
path[b].append(a)
q = deque([1])
ans = [0] * (n+1)
while q:
v = q.popleft()
for w in path[v]:
if ans[w] == 0:
ans[w] = v
q.append(w)
print('Yes')
print(*ans[2:], sep="\n")
``` | output | 1 | 89,007 | 8 | 178,015 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave.
The cave has N rooms and M passages. The rooms are numbered 1 to N, and the passages are numbered 1 to M. Passage i connects Room A_i and Room B_i bidirectionally. One can travel between any two rooms by traversing passages. Room 1 is a special room with an entrance from the outside.
It is dark in the cave, so we have decided to place a signpost in each room except Room 1. The signpost in each room will point to one of the rooms directly connected to that room with a passage.
Since it is dangerous in the cave, our objective is to satisfy the condition below for each room except Room 1.
* If you start in that room and repeatedly move to the room indicated by the signpost in the room you are in, you will reach Room 1 after traversing the minimum number of passages possible.
Determine whether there is a way to place signposts satisfying our objective, and print one such way if it exists.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq M \leq 2 \times 10^5
* 1 \leq A_i, B_i \leq N\ (1 \leq i \leq M)
* A_i \neq B_i\ (1 \leq i \leq M)
* One can travel between any two rooms by traversing passages.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
If there is no way to place signposts satisfying the objective, print `No`.
Otherwise, print N lines. The first line should contain `Yes`, and the i-th line (2 \leq i \leq N) should contain the integer representing the room indicated by the signpost in Room i.
Examples
Input
4 4
1 2
2 3
3 4
4 2
Output
Yes
1
2
2
Input
6 9
3 4
6 1
2 4
5 3
4 6
1 5
6 2
4 5
5 6
Output
Yes
6
5
5
1
1 | instruction | 0 | 89,008 | 8 | 178,016 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
from collections import deque
n, m = map(int, input().split())
G = [[] for _ in range(n+1)]
for _ in range(m):
u, v = map(int, input().split())
G[u].append(v)
G[v].append(u)
q = deque([1])
p = [0]*(n+1)
while q:
v = q.popleft()
for u in G[v]:
if p[u] == 0:
p[u] = v
q.append(u)
print("Yes\n"+"\n".join(map(str, p[2:])))
``` | output | 1 | 89,008 | 8 | 178,017 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave.
The cave has N rooms and M passages. The rooms are numbered 1 to N, and the passages are numbered 1 to M. Passage i connects Room A_i and Room B_i bidirectionally. One can travel between any two rooms by traversing passages. Room 1 is a special room with an entrance from the outside.
It is dark in the cave, so we have decided to place a signpost in each room except Room 1. The signpost in each room will point to one of the rooms directly connected to that room with a passage.
Since it is dangerous in the cave, our objective is to satisfy the condition below for each room except Room 1.
* If you start in that room and repeatedly move to the room indicated by the signpost in the room you are in, you will reach Room 1 after traversing the minimum number of passages possible.
Determine whether there is a way to place signposts satisfying our objective, and print one such way if it exists.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq M \leq 2 \times 10^5
* 1 \leq A_i, B_i \leq N\ (1 \leq i \leq M)
* A_i \neq B_i\ (1 \leq i \leq M)
* One can travel between any two rooms by traversing passages.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
If there is no way to place signposts satisfying the objective, print `No`.
Otherwise, print N lines. The first line should contain `Yes`, and the i-th line (2 \leq i \leq N) should contain the integer representing the room indicated by the signpost in Room i.
Examples
Input
4 4
1 2
2 3
3 4
4 2
Output
Yes
1
2
2
Input
6 9
3 4
6 1
2 4
5 3
4 6
1 5
6 2
4 5
5 6
Output
Yes
6
5
5
1
1 | instruction | 0 | 89,009 | 8 | 178,018 |
"Correct Solution:
```
import queue
n,m=map(int,input().split())
e=[[] for _ in range(n+1)]
INF=10**18
d=[INF]*(n+1)
ans=[0]*(n+1)
for _ in range(m):
a,b=map(int,input().split())
e[a]+=[b]
e[b]+=[a]
q=queue.Queue()
q.put(1)
d[1]=0
while not q.empty():
now=q.get()
for to in e[now]:
if d[to]==INF:
ans[to]=now
d[to]=d[now]+1
q.put(to)
print('Yes')
for i in ans[2:]:
print(i)
``` | output | 1 | 89,009 | 8 | 178,019 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave.
The cave has N rooms and M passages. The rooms are numbered 1 to N, and the passages are numbered 1 to M. Passage i connects Room A_i and Room B_i bidirectionally. One can travel between any two rooms by traversing passages. Room 1 is a special room with an entrance from the outside.
It is dark in the cave, so we have decided to place a signpost in each room except Room 1. The signpost in each room will point to one of the rooms directly connected to that room with a passage.
Since it is dangerous in the cave, our objective is to satisfy the condition below for each room except Room 1.
* If you start in that room and repeatedly move to the room indicated by the signpost in the room you are in, you will reach Room 1 after traversing the minimum number of passages possible.
Determine whether there is a way to place signposts satisfying our objective, and print one such way if it exists.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq M \leq 2 \times 10^5
* 1 \leq A_i, B_i \leq N\ (1 \leq i \leq M)
* A_i \neq B_i\ (1 \leq i \leq M)
* One can travel between any two rooms by traversing passages.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
If there is no way to place signposts satisfying the objective, print `No`.
Otherwise, print N lines. The first line should contain `Yes`, and the i-th line (2 \leq i \leq N) should contain the integer representing the room indicated by the signpost in Room i.
Examples
Input
4 4
1 2
2 3
3 4
4 2
Output
Yes
1
2
2
Input
6 9
3 4
6 1
2 4
5 3
4 6
1 5
6 2
4 5
5 6
Output
Yes
6
5
5
1
1 | instruction | 0 | 89,010 | 8 | 178,020 |
"Correct Solution:
```
n,m=map(int,input().split())
g=[[] for x in range(n)]
for c in range(m):
a,b= map(int,input().split())
g[a-1].append(b-1)
g[b-1].append(a-1)
ans_list=[-1]*n
queue=[0]
while queue:
qi=queue.pop(0)
for gi in g[qi]:
if ans_list[gi]==-1:
queue.append(gi)
ans_list[gi]=qi
print("Yes")
for ans in ans_list[1:]:
print(ans+1)
``` | output | 1 | 89,010 | 8 | 178,021 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave.
The cave has N rooms and M passages. The rooms are numbered 1 to N, and the passages are numbered 1 to M. Passage i connects Room A_i and Room B_i bidirectionally. One can travel between any two rooms by traversing passages. Room 1 is a special room with an entrance from the outside.
It is dark in the cave, so we have decided to place a signpost in each room except Room 1. The signpost in each room will point to one of the rooms directly connected to that room with a passage.
Since it is dangerous in the cave, our objective is to satisfy the condition below for each room except Room 1.
* If you start in that room and repeatedly move to the room indicated by the signpost in the room you are in, you will reach Room 1 after traversing the minimum number of passages possible.
Determine whether there is a way to place signposts satisfying our objective, and print one such way if it exists.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq M \leq 2 \times 10^5
* 1 \leq A_i, B_i \leq N\ (1 \leq i \leq M)
* A_i \neq B_i\ (1 \leq i \leq M)
* One can travel between any two rooms by traversing passages.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
If there is no way to place signposts satisfying the objective, print `No`.
Otherwise, print N lines. The first line should contain `Yes`, and the i-th line (2 \leq i \leq N) should contain the integer representing the room indicated by the signpost in Room i.
Examples
Input
4 4
1 2
2 3
3 4
4 2
Output
Yes
1
2
2
Input
6 9
3 4
6 1
2 4
5 3
4 6
1 5
6 2
4 5
5 6
Output
Yes
6
5
5
1
1 | instruction | 0 | 89,011 | 8 | 178,022 |
"Correct Solution:
```
(n,m),*t=[map(int,t.split())for t in open(0)]
e=[[]for _ in range(n+1)]
for a,b in t:
e[a]+=b,
e[b]+=a,
q=[1]
d=[0]*-~n
for v in q:
for w in e[v]:
if d[w]<1:
d[w]=v
q+=w,
print('Yes',*d[2:])
``` | output | 1 | 89,011 | 8 | 178,023 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave.
The cave has N rooms and M passages. The rooms are numbered 1 to N, and the passages are numbered 1 to M. Passage i connects Room A_i and Room B_i bidirectionally. One can travel between any two rooms by traversing passages. Room 1 is a special room with an entrance from the outside.
It is dark in the cave, so we have decided to place a signpost in each room except Room 1. The signpost in each room will point to one of the rooms directly connected to that room with a passage.
Since it is dangerous in the cave, our objective is to satisfy the condition below for each room except Room 1.
* If you start in that room and repeatedly move to the room indicated by the signpost in the room you are in, you will reach Room 1 after traversing the minimum number of passages possible.
Determine whether there is a way to place signposts satisfying our objective, and print one such way if it exists.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq M \leq 2 \times 10^5
* 1 \leq A_i, B_i \leq N\ (1 \leq i \leq M)
* A_i \neq B_i\ (1 \leq i \leq M)
* One can travel between any two rooms by traversing passages.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
If there is no way to place signposts satisfying the objective, print `No`.
Otherwise, print N lines. The first line should contain `Yes`, and the i-th line (2 \leq i \leq N) should contain the integer representing the room indicated by the signpost in Room i.
Examples
Input
4 4
1 2
2 3
3 4
4 2
Output
Yes
1
2
2
Input
6 9
3 4
6 1
2 4
5 3
4 6
1 5
6 2
4 5
5 6
Output
Yes
6
5
5
1
1 | instruction | 0 | 89,012 | 8 | 178,024 |
"Correct Solution:
```
from collections import deque
n, m = map(int, input().split())
g = [[] for _ in range(n)]
for i in range(m):
a, b = map(int, input().split())
g[a-1].append(b-1)
g[b-1].append(a-1)
q = deque([0])
pre = [-1 for _ in range(n)]
while q:
v = q.popleft()
for t in g[v]:
if pre[t] == -1:
pre[t] = v
q.append(t)
print('Yes')
for i in range(1, n):
print(pre[i]+1)
``` | output | 1 | 89,012 | 8 | 178,025 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave.
The cave has N rooms and M passages. The rooms are numbered 1 to N, and the passages are numbered 1 to M. Passage i connects Room A_i and Room B_i bidirectionally. One can travel between any two rooms by traversing passages. Room 1 is a special room with an entrance from the outside.
It is dark in the cave, so we have decided to place a signpost in each room except Room 1. The signpost in each room will point to one of the rooms directly connected to that room with a passage.
Since it is dangerous in the cave, our objective is to satisfy the condition below for each room except Room 1.
* If you start in that room and repeatedly move to the room indicated by the signpost in the room you are in, you will reach Room 1 after traversing the minimum number of passages possible.
Determine whether there is a way to place signposts satisfying our objective, and print one such way if it exists.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq M \leq 2 \times 10^5
* 1 \leq A_i, B_i \leq N\ (1 \leq i \leq M)
* A_i \neq B_i\ (1 \leq i \leq M)
* One can travel between any two rooms by traversing passages.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
If there is no way to place signposts satisfying the objective, print `No`.
Otherwise, print N lines. The first line should contain `Yes`, and the i-th line (2 \leq i \leq N) should contain the integer representing the room indicated by the signpost in Room i.
Examples
Input
4 4
1 2
2 3
3 4
4 2
Output
Yes
1
2
2
Input
6 9
3 4
6 1
2 4
5 3
4 6
1 5
6 2
4 5
5 6
Output
Yes
6
5
5
1
1 | instruction | 0 | 89,013 | 8 | 178,026 |
"Correct Solution:
```
from collections import deque
n,m = map(int,input().split())
net = [[] for _ in range(n+1)]
for _ in range(m):
a,b = map(int,input().split())
net[a].append(b)
net[b].append(a)
a = [-1] * (n+1)
d = deque()
d.append(1)
while d:
u = d.popleft()
for child in net[u]:
if a[child] != -1:continue
a[child] = u
d.append(child)
print("Yes")
print(*a[2:], sep = " ")
``` | output | 1 | 89,013 | 8 | 178,027 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.