text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide a correct Python 3 solution for this coding contest problem.
The configuration of three circles packed inside a triangle such that each circle is tangent to the other two circles and to two of the edges of the triangle has been studied by many mathematicians for more than two centuries. Existence and uniqueness of such circles for an arbitrary triangle are easy to prove. Many methods of numerical calculation or geometric construction of such circles from an arbitrarily given triangle have been discovered. Today, such circles are called the Malfatti circles.
Figure 7 illustrates an example. The Malfatti circles of the triangle with the vertices (20, 80), (-40, -20) and (120, -20) are approximately
* the circle with the center (24.281677, 45.219486) and the radius 21.565935,
* the circle with the center (3.110950, 4.409005) and the radius 24.409005, and
* the circle with the center (54.556724, 7.107493) and the radius 27.107493.
Figure 8 illustrates another example. The Malfatti circles of the triangle with the vertices (20, -20), (120, -20) and (-40, 80) are approximately
* the circle with the center (25.629089, −10.057956) and the radius 9.942044,
* the circle with the center (53.225883, −0.849435) and the radius 19.150565, and
* the circle with the center (19.701191, 19.203466) and the radius 19.913790.
Your mission is to write a program to calculate the radii of the Malfatti circles of the given triangles.
<image>
Input
The input is a sequence of datasets. A dataset is a line containing six integers x1, y1 , x2 , y2, x3 and y3 in this order, separated by a space. The coordinates of the vertices of the given triangle are (x1 , y1 ), (x2 , y2 ) and (x3 , y3 ), respectively. You can assume that the vertices form a triangle counterclockwise. You can also assume that the following two conditions hold.
* All of the coordinate values are greater than −1000 and less than 1000.
* None of the Malfatti circles of the triangle has a radius less than 0.1.
The end of the input is indicated by a line containing six zeros separated by a space.
Output
For each input dataset, three decimal fractions r1 , r2 and r3 should be printed in a line in this order separated by a space. The radii of the Malfatti circles nearest to the vertices with the coordinates (x1 , y1 ), (x2 , y2 ) and (x3 , y3 ) should be r1 , r2 and r3 , respectively.
None of the output values may have an error greater than 0.0001. No extra character should appear in the output.
Example
Input
20 80 -40 -20 120 -20
20 -20 120 -20 -40 80
0 0 1 0 0 1
0 0 999 1 -999 1
897 -916 847 -972 890 -925
999 999 -999 -998 -998 -999
-999 -999 999 -999 0 731
-999 -999 999 -464 -464 999
979 -436 -955 -337 157 -439
0 0 0 0 0 0
Output
21.565935 24.409005 27.107493
9.942044 19.150565 19.913790
0.148847 0.207107 0.207107
0.125125 0.499750 0.499750
0.373458 0.383897 0.100456
0.706768 0.353509 0.353509
365.638023 365.638023 365.601038
378.524085 378.605339 378.605339
21.895803 22.052921 5.895714
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
x1, y1, x2, y2, x3, y3 = map(int, readline().split())
if x1 == y1 == x2 == y2 == x3 == y3 == 0:
return False
d12 = ((x1-x2)**2 + (y1-y2)**2)**.5
d23 = ((x2-x3)**2 + (y2-y3)**2)**.5
d31 = ((x3-x1)**2 + (y3-y1)**2)**.5
e1 = ((x1, y1), ((x2-x1)/d12, (y2-y1)/d12), ((x3-x1)/d31, (y3-y1)/d31))
e2 = ((x2, y2), ((x3-x2)/d23, (y3-y2)/d23), ((x1-x2)/d12, (y1-y2)/d12))
e3 = ((x3, y3), ((x1-x3)/d31, (y1-y3)/d31), ((x2-x3)/d23, (y2-y3)/d23))
def calc(e, x):
p0, p1, p2 = e
x0, y0 = p0; x1, y1 = p1; x2, y2 = p2
xc = (x1 + x2)/2; yc = (y1 + y2)/2; dc = (xc**2 + yc**2)**.5
cv = (x1*xc + y1*yc)/dc
sv = (x1*yc - y1*xc)/dc
d = x / cv
return (x0 + xc * d / dc, y0 + yc * d / dc), x * sv / cv
EPS = 1e-8
def check(p0, r0):
x0, y0 = p0
left = 0; right = min(d12, d23)
while right - left > EPS:
mid = (left + right) / 2
(x1, y1), r1 = calc(e2, mid)
if (x0-x1)**2 + (y0-y1)**2 < (r0+r1)**2:
right = mid
else:
left = mid
(x1, y1), r1 = calc(e2, left)
left = 0; right = min(d23, d31)
while right - left > EPS:
mid = (left + right) / 2
(x2, y2), r2 = calc(e3, mid)
if (x0-x2)**2 + (y0-y2)**2 < (r0+r2)**2:
right = mid
else:
left = mid
(x2, y2), r2 = calc(e3, left)
return (x1-x2)**2 + (y1-y2)**2 < (r1+r2)**2, r1, r2
left = 0; right = min(d12, d31)
while right - left > EPS:
mid = (left + right) / 2
p0, r0 = calc(e1, mid)
if check(p0, r0)[0]:
left = mid
else:
right = mid
p0, r0 = calc(e1, right)
e, r1, r2 = check(p0, r0)
write("%.16f %.16f %.16f\n" % (r0, r1, r2))
return True
while solve():
...
```
| 15,000 |
Provide a correct Python 3 solution for this coding contest problem.
The configuration of three circles packed inside a triangle such that each circle is tangent to the other two circles and to two of the edges of the triangle has been studied by many mathematicians for more than two centuries. Existence and uniqueness of such circles for an arbitrary triangle are easy to prove. Many methods of numerical calculation or geometric construction of such circles from an arbitrarily given triangle have been discovered. Today, such circles are called the Malfatti circles.
Figure 7 illustrates an example. The Malfatti circles of the triangle with the vertices (20, 80), (-40, -20) and (120, -20) are approximately
* the circle with the center (24.281677, 45.219486) and the radius 21.565935,
* the circle with the center (3.110950, 4.409005) and the radius 24.409005, and
* the circle with the center (54.556724, 7.107493) and the radius 27.107493.
Figure 8 illustrates another example. The Malfatti circles of the triangle with the vertices (20, -20), (120, -20) and (-40, 80) are approximately
* the circle with the center (25.629089, −10.057956) and the radius 9.942044,
* the circle with the center (53.225883, −0.849435) and the radius 19.150565, and
* the circle with the center (19.701191, 19.203466) and the radius 19.913790.
Your mission is to write a program to calculate the radii of the Malfatti circles of the given triangles.
<image>
Input
The input is a sequence of datasets. A dataset is a line containing six integers x1, y1 , x2 , y2, x3 and y3 in this order, separated by a space. The coordinates of the vertices of the given triangle are (x1 , y1 ), (x2 , y2 ) and (x3 , y3 ), respectively. You can assume that the vertices form a triangle counterclockwise. You can also assume that the following two conditions hold.
* All of the coordinate values are greater than −1000 and less than 1000.
* None of the Malfatti circles of the triangle has a radius less than 0.1.
The end of the input is indicated by a line containing six zeros separated by a space.
Output
For each input dataset, three decimal fractions r1 , r2 and r3 should be printed in a line in this order separated by a space. The radii of the Malfatti circles nearest to the vertices with the coordinates (x1 , y1 ), (x2 , y2 ) and (x3 , y3 ) should be r1 , r2 and r3 , respectively.
None of the output values may have an error greater than 0.0001. No extra character should appear in the output.
Example
Input
20 80 -40 -20 120 -20
20 -20 120 -20 -40 80
0 0 1 0 0 1
0 0 999 1 -999 1
897 -916 847 -972 890 -925
999 999 -999 -998 -998 -999
-999 -999 999 -999 0 731
-999 -999 999 -464 -464 999
979 -436 -955 -337 157 -439
0 0 0 0 0 0
Output
21.565935 24.409005 27.107493
9.942044 19.150565 19.913790
0.148847 0.207107 0.207107
0.125125 0.499750 0.499750
0.373458 0.383897 0.100456
0.706768 0.353509 0.353509
365.638023 365.638023 365.601038
378.524085 378.605339 378.605339
21.895803 22.052921 5.895714
"Correct Solution:
```
import math
def length(x1, y1, x2, y2):
return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
while True:
p = list(map(int, input().split()))
if not list(filter(lambda x: x, p)):
break
a, b, c = length(p[0], p[1], p[2], p[3]), length(p[0], p[1], p[4], p[5]), length(p[2], p[3], p[4], p[5])
S = 0.5 * a * b * (1 - ((a ** 2 + b ** 2 - c ** 2) / (a * b * 2)) ** 2) ** 0.5
R = (2 * S) / (a + b + c)
s = (a + b + c) / 2
d = (((- a + b + c) / 2) ** 2 + R ** 2) ** 0.5
e = (((a - b + c) / 2) ** 2 + R ** 2) ** 0.5
f = (((a + b - c) / 2) ** 2 + R ** 2) ** 0.5
print(R / (2 * (s - c)) * (s + f - R - e - d), end=" ")
print(R / (2 * (s - b)) * (s + e - R - d - f), end=" ")
print(R / (2 * (s - a)) * (s + d - R - e - f))
```
| 15,001 |
Provide a correct Python 3 solution for this coding contest problem.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
"Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import array
import math
def solve(m, p, xs):
total_prize = sum(xs) * (100 - p)
number_of_winners = xs[m - 1]
if not number_of_winners:
return 0
else:
return math.floor(total_prize / number_of_winners)
if __name__ == "__main__":
while True:
n, m, p = map(int, input().split())
if n == 0 and m == 0 and p == 0:
break
xs = array.array("H", (int(input()) for i in range(n)))
print(solve(m, p, xs))
```
| 15,002 |
Provide a correct Python 3 solution for this coding contest problem.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
"Correct Solution:
```
while True:
N, M, P = map(int, input().split())
if N == 0 and M == 0 and P == 0:
break
X = [0 for i in range(N)]
for i in range(N):
X[i] = int(input())
if X[M - 1] != 0:
print(sum(X) * (100 - P) // X[M - 1])
else:
print(0)
```
| 15,003 |
Provide a correct Python 3 solution for this coding contest problem.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
"Correct Solution:
```
l = input()
while l != '0 0 0':
l_split = l.split(' ')
athletes = int(l_split[0])
winner = int(l_split[1])
percent = int(l_split[2])
total_ticket = 0
win_ticket = 0
for i in range(athletes):
tickets = int(input())
total_ticket += tickets
if i + 1 == winner and tickets > 0:
win_ticket = tickets
if win_ticket > 0:
total_money = total_ticket*(100 - percent)
print(str(total_money//win_ticket))
else:
print('0')
l = input()
```
| 15,004 |
Provide a correct Python 3 solution for this coding contest problem.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
"Correct Solution:
```
while 1:
n,m,p=map(int,input().split())
if n==0:
break
data=[]
for i in range(n):
data.append(int(input()))
print(sum(data)*(100-p)//data[m-1] if data[m-1]!=0 else 0)
```
| 15,005 |
Provide a correct Python 3 solution for this coding contest problem.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
"Correct Solution:
```
import math
while True:
n,m,p = map(int,input().split())
if n == m == p == 0:
break
m -= 1
x = [int(input()) for i in range(n)]
if x[m] == 0:
print(0)
else:
print(math.floor((100-p)*sum(x)/x[m]))
```
| 15,006 |
Provide a correct Python 3 solution for this coding contest problem.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
"Correct Solution:
```
while True:
N,M,P=map(int,input().split())
if N==0 and M==0 and P==0:
break
card=[]
for i in range(N):
card.append(int(input()))
if card[M-1]==0:
print(0)
else:
sc=sum(card)
kati=sc*100-(sc*100*(P/100))
haitou=kati//(card[M-1])
print(int(haitou))
```
| 15,007 |
Provide a correct Python 3 solution for this coding contest problem.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
"Correct Solution:
```
while True :
N, M, P = map(int, input().split())
if N == 0 and M == 0 and P == 0 :
break
Sum = 0
for i in range(N) :
x = int(input())
Sum += x
if i == M - 1 :
winner = x
if winner == 0 :
print(0)
else :
print(int(Sum * 100 * (100 - P) / 100 / winner))
```
| 15,008 |
Provide a correct Python 3 solution for this coding contest problem.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
"Correct Solution:
```
#!/usr/bin/python
# -*- coding: utf-8 -*-
import math
while True:
amount, number, per = map(int, input().split())
if amount == 0 and number == 0 and per == 0:
break
vote = [int(input()) for _ in range(amount)]
if vote[number-1] == 0:
print("0")
else:
print(math.floor(100 * sum(vote) * (100 - per) / 100 / vote[number-1]))
```
| 15,009 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
Submitted Solution:
```
while 1:
n,m,p=map(int,input().split())
if n==0:break
x=[int(input()) for _ in range(n)]
print(sum(x)*(100-p)//x[m-1] if x[m-1] else 0)
```
Yes
| 15,010 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
Submitted Solution:
```
while 1:
N,M,P=map(int,input().split())
if not N and not M and not P:break
X=[int(input()) for _ in range(N)]
if not X[M-1]:r=0
else:r=int(sum(X)*100*(100-P)/100/X[M-1])
print(r)
```
Yes
| 15,011 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
Submitted Solution:
```
while True:
N,M,P = map(int,input().split())
if N == 0: break
src = [int(input()) for i in range(N)]
if src[M-1] == 0:
print(0)
else:
print((100-P) * sum(src) // src[M-1])
```
Yes
| 15,012 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
Submitted Solution:
```
while True:
n = input().split()
m = [int(i) for i in n]
if m[0] == 0:
break
l = [int(input()) for k in range(m[0])]
count = 0
sumMoney = 0
for count in range(m[0]):
sumMoney += l[count]
money = float(sumMoney * (100 - m[2]))
try:
pey = money / l[m[1] - 1]
print(int(pey))
except ZeroDivisionError :
print('0')
```
Yes
| 15,013 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
Submitted Solution:
```
def solve(N,M,P,Xs):
if Xs[M-1] == 0:
return 0
total = sum([x*100 for x in Xs])
total *= (100-P)/100
return total / Xs[M-1]
def main():
while True:
N,M,P = map(int,input().split())
if N == 0 and M == 0 and P == 0:
return
Xs = [int(input()) for _ in range(N)]
print(int(solve(N,M,P,Xs)))
if __name__ == '__main__':
main()
```
No
| 15,014 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
Submitted Solution:
```
while True:
n,m,p = map(int, input().split(" "))
if n+m+p == 0:
break
total = 0
winner = 0
for i in range(1, n+1):
x = int(input())
total += x
if i == m:
winner = x
print(int((1 - p / 100) * 100 * total / winner) if winner > 0 else 0)
```
No
| 15,015 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
Submitted Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
while True:
N,M,P = map(int,input().split(" "))
if N == 0 and M == 0 and P == 0:
break
count = 0
for i in range(N):
x = int(input())
count += x
if i + 1 == M:
hitman = x
if hitman == 0:
print(0)
else:
print(int((count*100)*((100-P)/100)/hitman))
```
No
| 15,016 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Princess'Gamble
Princess gambling
English text is not available in this practice contest.
One day, a brave princess in a poor country's tomboy broke the walls of her room, escaped from the castle, and entered the gambling hall where horse racing and other gambling were held. However, the princess who had never gambled was very defeated. The princess, who found this situation uninteresting, investigated how gambling was carried out. Then, in such gambling, it was found that the dividend was decided by a method called the parimutuel method.
The parimutuel method is a calculation method used to determine dividends in gambling for races. In this method, all the stakes are pooled, a certain percentage is deducted, and then the amount proportional to the stakes is distributed to the winners.
In the gambling that the princess is currently enthusiastic about, participants buy a 100 gold voting ticket to predict which player will win before the competition and receive a winning prize if the result of the competition matches the prediction. It's about getting the right. Gold is the currency unit of this country. Your job is to write a program that calculates the payout per voting ticket based on the competition information given as input.
If the dividend amount calculated by the above method is not an integer, round it down to an integer.
Input
The input consists of multiple datasets. The number of data sets is 100 or less. After the last dataset, a line of "0 0 0" is given to mark the end of the input.
Each data set has the following format.
> N M P
> X1
> ...
> XN
In the first line, N is the number of players to vote for, M is the number of the winning player, and P is an integer representing the deduction rate (percentage). Xi is the number of voting tickets voted for the i-th competitor. It may be assumed that 1 ≤ N ≤ 100, 1 ≤ M ≤ N, 0 ≤ P ≤ 100, 0 ≤ Xi ≤ 1000.
Output
For each dataset, output a line of integers indicating the payout amount per winning voting ticket. Output 0 if no one has won the bet. There must be no other characters on the output line.
Sample Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output for the Sample Input
150
0
112
Example
Input
3 2 50
1
2
3
4 4 75
1
2
3
0
3 1 10
8
1
1
0 0 0
Output
150
0
112
Submitted Solution:
```
def solve(N,M,P,Xs):
if N < M or Xs[M-1] == 0:
return 0
return (sum([x*100 for x in Xs]) * (1-P/100)) // Xs[M-1]
def main():
while True:
N,M,P = map(int,input().split())
if N == 0 and M == 0 and P == 0:
return
Xs = [int(input()) for _ in range(N)]
print(int(solve(N,M,P,Xs)))
if __name__ == '__main__':
main()
```
No
| 15,017 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
One evening. As usual, when you were watching TV in the living room, my sister in fifth grade offered me a consultation. When I listened to the story, I couldn't understand the math problem that was presented at school today, so I want you to teach me how to solve it.
The question that bothers my sister is, "How many ways are there in the shortest way from home (0, 0) to school (N, M) in a city with grid-like roads?" was. Of course, it's a simpler problem for you than twisting the baby's hand. Immediately, I wrote a figure like the one above and told me, "If you add up in order from the house (0, 0), you can solve it."
However, when I heard that, my sister was still thinking down. You wondered if your explanation was wrong, but apparently it wasn't.
Have you been worried for about 3 minutes? My sister raised her face and said to you:
"But if I were, I'm sure I would make a detour about K times on my way to school ... Hey brother, how many answers would you get?"
It's hard now. I have to answer this question to keep my brother dignified.
The formulation of this problem is as follows.
* Answer how many ways you can go from point (0, 0) to point (N, M) through a grid-like path.
* Basically, go one square to the right or up, but on the way, make a detour just K times.
* To "take a detour" means to go one square to the left or down.
* If you haven't made K detours, continue walking even after you reach point (N, M). It may return to the point (0, 0) on the way.
* The house is built in the corner of the city, so you can't enter a point where the X or Y coordinates are negative.
* However, it is possible to enter a point whose X coordinate is larger than N or whose Y coordinate is larger than M.
Input
NMK
On the first line of input, the integer N (1 ≤ N ≤ 100,000), the integer M (1 ≤ M ≤ 100,000), and the integer K (0 ≤ K ≤ 10,000) are written in this order, separated by blanks. The integer N represents the X coordinate of the school, the integer M represents the Y coordinate of the school, and the integer K represents the number of detours.
Output
How to make K detours from point (0, 0) to point (N, M). Divide the total number by 1,000,000,007 and output the remainder. Note that 1,000,000,007 are prime numbers.
Examples
Input
6 4 0
Output
210
Input
3 3 1
Output
448
Input
124 218 367
Output
817857665
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
MOD = 10**9 + 7
N, M, K = map(int, readline().split())
MOD = 10**9 + 7
L = N+M+2*K
fact = [1]*(L+1)
rfact = [1]*(L+1)
r = 1
for i in range(1, L+1):
fact[i] = r = r * i % MOD
rfact[L] = r = pow(fact[L], MOD-2, MOD)
for i in range(L, 0, -1):
rfact[i-1] = r = r * i % MOD
def C(n, k):
return fact[n] * rfact[n-k] * rfact[k] % MOD
def F(n, k):
return (fact[n+k] * (n-k+1) % MOD) * (rfact[k] * rfact[n+1] % MOD) % MOD
ans = 0
for a in range(K+1):
b = K-a
ans += C(N+2*a+M+2*b, N+2*a) * F(N+a, a) * F(M+b, b) % MOD
ans %= MOD
write("%d\n" % ans)
solve()
```
| 15,018 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
One evening. As usual, when you were watching TV in the living room, my sister in fifth grade offered me a consultation. When I listened to the story, I couldn't understand the math problem that was presented at school today, so I want you to teach me how to solve it.
The question that bothers my sister is, "How many ways are there in the shortest way from home (0, 0) to school (N, M) in a city with grid-like roads?" was. Of course, it's a simpler problem for you than twisting the baby's hand. Immediately, I wrote a figure like the one above and told me, "If you add up in order from the house (0, 0), you can solve it."
However, when I heard that, my sister was still thinking down. You wondered if your explanation was wrong, but apparently it wasn't.
Have you been worried for about 3 minutes? My sister raised her face and said to you:
"But if I were, I'm sure I would make a detour about K times on my way to school ... Hey brother, how many answers would you get?"
It's hard now. I have to answer this question to keep my brother dignified.
The formulation of this problem is as follows.
* Answer how many ways you can go from point (0, 0) to point (N, M) through a grid-like path.
* Basically, go one square to the right or up, but on the way, make a detour just K times.
* To "take a detour" means to go one square to the left or down.
* If you haven't made K detours, continue walking even after you reach point (N, M). It may return to the point (0, 0) on the way.
* The house is built in the corner of the city, so you can't enter a point where the X or Y coordinates are negative.
* However, it is possible to enter a point whose X coordinate is larger than N or whose Y coordinate is larger than M.
Input
NMK
On the first line of input, the integer N (1 ≤ N ≤ 100,000), the integer M (1 ≤ M ≤ 100,000), and the integer K (0 ≤ K ≤ 10,000) are written in this order, separated by blanks. The integer N represents the X coordinate of the school, the integer M represents the Y coordinate of the school, and the integer K represents the number of detours.
Output
How to make K detours from point (0, 0) to point (N, M). Divide the total number by 1,000,000,007 and output the remainder. Note that 1,000,000,007 are prime numbers.
Examples
Input
6 4 0
Output
210
Input
3 3 1
Output
448
Input
124 218 367
Output
817857665
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def inv(x):
return pow(x, mod - 2, mod)
cms = 10**6
cm = [0] * cms
def comb_init():
cm[0] = 1
for i in range(1, cms):
cm[i] = cm[i-1] * i % mod
def comb(a, b):
return (cm[a] * inv(cm[a-b]) % mod) * inv(cm[b]) % mod
def main():
rr = []
def f(n,m,k):
comb_init()
r = 0
for i in range(k+1):
j = k - i
mt = comb(n+m+k*2, n+i*2)
lk = rk = 1
if i > 0:
lk = (comb(n+i*2, i) - comb(n+i*2, i-1)) % mod
if j > 0:
rk = (comb(m+j*2, j) - comb(m+j*2, j-1)) % mod
r += mt * lk * rk % mod
r %= mod
return r
while 1:
n,m,k = LI()
if n == 0:
break
rr.append(f(n,m,k))
break
return '\n'.join(map(str, rr))
print(main())
```
| 15,019 |
Provide a correct Python 3 solution for this coding contest problem.
()
Problem Statement
There is a string S. Initially, S is an empty string.
Perform the following processing in order of n.
* Add x_i p_i (=" (" or") ") to the end of S.
After processing, determine if S is a well-balanced string.
"The string is balanced" is defined as follows.
* The empty string is well-balanced.
* For balanced strings a and b, a + b (+ represents a concatenation of strings) is balanced.
* For a balanced string a, "(" + a + ")" is balanced.
Constraints
* 1 ≤ n ≤ 1,000
* 1 ≤ x_i ≤ 10 ^ 6
* p_i is "(" or ")"
Input
Input follows the following format. All given numbers are integers.
n
p_1 x_1
.. ..
p_n x_n
Output
Output "YES" if balanced, otherwise output "NO" on one line.
Examples
Input
3
( 5
) 4
) 1
Output
YES
Input
5
( 2
) 2
( 3
) 1
) 2
Output
YES
Input
2
) 1
( 1
Output
NO
"Correct Solution:
```
n = int(input())
pos = 0
flag = True
for _ in range(n):
k, num = input().split()
num = int(num)
if k == "(":
pos += num
else:
pos -= num
if pos < 0:
flag = False
if not flag or pos != 0:
print("NO")
else:
print("YES")
```
| 15,020 |
Provide a correct Python 3 solution for this coding contest problem.
()
Problem Statement
There is a string S. Initially, S is an empty string.
Perform the following processing in order of n.
* Add x_i p_i (=" (" or") ") to the end of S.
After processing, determine if S is a well-balanced string.
"The string is balanced" is defined as follows.
* The empty string is well-balanced.
* For balanced strings a and b, a + b (+ represents a concatenation of strings) is balanced.
* For a balanced string a, "(" + a + ")" is balanced.
Constraints
* 1 ≤ n ≤ 1,000
* 1 ≤ x_i ≤ 10 ^ 6
* p_i is "(" or ")"
Input
Input follows the following format. All given numbers are integers.
n
p_1 x_1
.. ..
p_n x_n
Output
Output "YES" if balanced, otherwise output "NO" on one line.
Examples
Input
3
( 5
) 4
) 1
Output
YES
Input
5
( 2
) 2
( 3
) 1
) 2
Output
YES
Input
2
) 1
( 1
Output
NO
"Correct Solution:
```
a=0
for _ in range(int(input())):
b,c=input().split()
a+=int(c) if b=='(' else -int(c)
if a<0:break
print('NO' if a else 'YES')
```
| 15,021 |
Provide a correct Python 3 solution for this coding contest problem.
()
Problem Statement
There is a string S. Initially, S is an empty string.
Perform the following processing in order of n.
* Add x_i p_i (=" (" or") ") to the end of S.
After processing, determine if S is a well-balanced string.
"The string is balanced" is defined as follows.
* The empty string is well-balanced.
* For balanced strings a and b, a + b (+ represents a concatenation of strings) is balanced.
* For a balanced string a, "(" + a + ")" is balanced.
Constraints
* 1 ≤ n ≤ 1,000
* 1 ≤ x_i ≤ 10 ^ 6
* p_i is "(" or ")"
Input
Input follows the following format. All given numbers are integers.
n
p_1 x_1
.. ..
p_n x_n
Output
Output "YES" if balanced, otherwise output "NO" on one line.
Examples
Input
3
( 5
) 4
) 1
Output
YES
Input
5
( 2
) 2
( 3
) 1
) 2
Output
YES
Input
2
) 1
( 1
Output
NO
"Correct Solution:
```
n=int(input())
a,b=0,0
flag=0
for i in range(n):
p,x=map(str,input().split())
if p=="(":a+=int(x)
else:b+=int(x)
if a<b:
flag=1
break
if flag==1 or a!=b:print("NO")
else:print("YES")
```
| 15,022 |
Provide a correct Python 3 solution for this coding contest problem.
()
Problem Statement
There is a string S. Initially, S is an empty string.
Perform the following processing in order of n.
* Add x_i p_i (=" (" or") ") to the end of S.
After processing, determine if S is a well-balanced string.
"The string is balanced" is defined as follows.
* The empty string is well-balanced.
* For balanced strings a and b, a + b (+ represents a concatenation of strings) is balanced.
* For a balanced string a, "(" + a + ")" is balanced.
Constraints
* 1 ≤ n ≤ 1,000
* 1 ≤ x_i ≤ 10 ^ 6
* p_i is "(" or ")"
Input
Input follows the following format. All given numbers are integers.
n
p_1 x_1
.. ..
p_n x_n
Output
Output "YES" if balanced, otherwise output "NO" on one line.
Examples
Input
3
( 5
) 4
) 1
Output
YES
Input
5
( 2
) 2
( 3
) 1
) 2
Output
YES
Input
2
) 1
( 1
Output
NO
"Correct Solution:
```
n = int(input())
b = 0
ans = True
for _ in range(n):
p, x = input().split()
x = int(x)
if p == "(":
b += x
else:
b -= x
if b < 0:
ans = False
if ans:
if b == 0:
print("YES")
else:
print("NO")
else:
print("NO")
```
| 15,023 |
Provide a correct Python 3 solution for this coding contest problem.
()
Problem Statement
There is a string S. Initially, S is an empty string.
Perform the following processing in order of n.
* Add x_i p_i (=" (" or") ") to the end of S.
After processing, determine if S is a well-balanced string.
"The string is balanced" is defined as follows.
* The empty string is well-balanced.
* For balanced strings a and b, a + b (+ represents a concatenation of strings) is balanced.
* For a balanced string a, "(" + a + ")" is balanced.
Constraints
* 1 ≤ n ≤ 1,000
* 1 ≤ x_i ≤ 10 ^ 6
* p_i is "(" or ")"
Input
Input follows the following format. All given numbers are integers.
n
p_1 x_1
.. ..
p_n x_n
Output
Output "YES" if balanced, otherwise output "NO" on one line.
Examples
Input
3
( 5
) 4
) 1
Output
YES
Input
5
( 2
) 2
( 3
) 1
) 2
Output
YES
Input
2
) 1
( 1
Output
NO
"Correct Solution:
```
a=0
for _ in range(int(input())):
b,c=input().split()
a+= int(c) if b=='(' else -int(c)
if a<0:print('NO');break
else: print('NO' if a else 'YES')
```
| 15,024 |
Provide a correct Python 3 solution for this coding contest problem.
()
Problem Statement
There is a string S. Initially, S is an empty string.
Perform the following processing in order of n.
* Add x_i p_i (=" (" or") ") to the end of S.
After processing, determine if S is a well-balanced string.
"The string is balanced" is defined as follows.
* The empty string is well-balanced.
* For balanced strings a and b, a + b (+ represents a concatenation of strings) is balanced.
* For a balanced string a, "(" + a + ")" is balanced.
Constraints
* 1 ≤ n ≤ 1,000
* 1 ≤ x_i ≤ 10 ^ 6
* p_i is "(" or ")"
Input
Input follows the following format. All given numbers are integers.
n
p_1 x_1
.. ..
p_n x_n
Output
Output "YES" if balanced, otherwise output "NO" on one line.
Examples
Input
3
( 5
) 4
) 1
Output
YES
Input
5
( 2
) 2
( 3
) 1
) 2
Output
YES
Input
2
) 1
( 1
Output
NO
"Correct Solution:
```
n = int(input())
s = 0
f = 0
for i in range(n):
p,x = input().split()
x = int(x)
if p == "(":
s += x
else:
s -= x
if s < 0:
f = 1
if f or s != 0:
print("NO")
else:
print("YES")
```
| 15,025 |
Provide a correct Python 3 solution for this coding contest problem.
A: Taking a Seat-Taking a Seat-
story
Mr. A entered the classroom at the examination site to take an examination. However, Mr. A is a very nervous type. Therefore, depending on the situation, there may be seats that Mr. A does not want to sit in. Therefore, Mr. A decided to find out how many seats he could sit on based on certain conditions.
problem
Mr. A is a nervous type of person. First of all, Mr. A cannot sit in the first row from the front. Because when I sit near the proctor, I get nervous and can't solve the problem. Also, if there is a person on the right or left, Mr. A cannot sit down. This is because the sound of the pencil next to me makes it impossible to concentrate during the test. In addition, you can't sit near a noisy guy (near 8 diagonally up, down, left, and right). This is because my voice echoes in my head during the break and I can't rest. Also, it's natural, but I can't sit in the seat where the students are already sitting.
Is there a place where Mr. A can sit under these conditions? Assuming that M x N seats are lined up in the classroom, let's find the number.
Input format
The first row gives M (number of rows: number of vertical seats) and N (number of columns: number of horizontal seats). From the second line, M lines and a character string of length N are given line by line. The j character of the i-th character string represents the state of the seat in the i-th row and the j-th column. Each letter is either'-',' x'or'o', vacant seats'-', noisy students sitting during breaks'x', other students sitting' Let it be o'.
Constraint
* 0 <M ≤ 100
* 0 <N ≤ 100
Output format
Output the number of seats that Mr. A can sit in one line depending on the conditions. Don't forget the line break at the end.
Input example 1
5 5
--o--
--xo-
--x--
o --- x
--xoo
Output example 1
3
Input example 2
2 6
--oooo
x--o--
Output example 2
1
Input example 3
3 5
-----
-----
-----
Output example 3
Ten
Input example 4
4 6
o-oxoo
oo-ooo
oooxo-
o-ooox
Output example 4
0
Example
Input
5 5
--o--
--xo-
--x--
o---x
--xoo
Output
3
"Correct Solution:
```
m,n = map(int,input().split())
seat = [list(input()) for i in range(m)]
dummy = ["0" for i in range(n+2)]
for i in range(m):
seat[i].insert(0,"0")
seat[i].append("0")
seat.insert(0,dummy)
seat.append(dummy)
for i in range(1,m + 1):
for j in range(1,n + 1):
if seat[i][j] == "o":
if seat[i][j - 1] == "-":
seat[i][j - 1] = "0"
if seat[i][j + 1] == "-":
seat[i][j + 1] = "0"
elif seat[i][j] == "x":
for k in range(3):
for l in range(3):
if seat[i - 1 + k][j - 1 + l] == "-":
seat[i - 1 + k][j - 1 + l] = "0"
for i in range(n + 1):
if seat[1][i] == "-":
seat[1][i] = "0"
count = 0
for i in seat:
for j in i:
if j == "-":
count += 1
print (count)
```
| 15,026 |
Provide a correct Python 3 solution for this coding contest problem.
A: Taking a Seat-Taking a Seat-
story
Mr. A entered the classroom at the examination site to take an examination. However, Mr. A is a very nervous type. Therefore, depending on the situation, there may be seats that Mr. A does not want to sit in. Therefore, Mr. A decided to find out how many seats he could sit on based on certain conditions.
problem
Mr. A is a nervous type of person. First of all, Mr. A cannot sit in the first row from the front. Because when I sit near the proctor, I get nervous and can't solve the problem. Also, if there is a person on the right or left, Mr. A cannot sit down. This is because the sound of the pencil next to me makes it impossible to concentrate during the test. In addition, you can't sit near a noisy guy (near 8 diagonally up, down, left, and right). This is because my voice echoes in my head during the break and I can't rest. Also, it's natural, but I can't sit in the seat where the students are already sitting.
Is there a place where Mr. A can sit under these conditions? Assuming that M x N seats are lined up in the classroom, let's find the number.
Input format
The first row gives M (number of rows: number of vertical seats) and N (number of columns: number of horizontal seats). From the second line, M lines and a character string of length N are given line by line. The j character of the i-th character string represents the state of the seat in the i-th row and the j-th column. Each letter is either'-',' x'or'o', vacant seats'-', noisy students sitting during breaks'x', other students sitting' Let it be o'.
Constraint
* 0 <M ≤ 100
* 0 <N ≤ 100
Output format
Output the number of seats that Mr. A can sit in one line depending on the conditions. Don't forget the line break at the end.
Input example 1
5 5
--o--
--xo-
--x--
o --- x
--xoo
Output example 1
3
Input example 2
2 6
--oooo
x--o--
Output example 2
1
Input example 3
3 5
-----
-----
-----
Output example 3
Ten
Input example 4
4 6
o-oxoo
oo-ooo
oooxo-
o-ooox
Output example 4
0
Example
Input
5 5
--o--
--xo-
--x--
o---x
--xoo
Output
3
"Correct Solution:
```
m, n = map(int, input().split())
mp = [list("#" * (n + 2))] + [list("#" + input() + "#") for _ in range(m)] + [list("#" * (n + 2))]
vec = ((1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0), (-1, 1), (0, 1), (1, 1))
for y in range(1, m + 1):
for x in range(1, n + 1):
if mp[y][x] == "x":
for dx, dy in vec:
if mp[y + dy][x + dx] == "-":
mp[y + dy][x + dx] = "#"
if mp[y][x] == "o":
if mp[y][x - 1] == "-":mp[y][x - 1] = "#"
if mp[y][x + 1] == "-":mp[y][x + 1] = "#"
for x in range(1, n + 1):
if mp[1][x] == "-": mp[1][x] = "#"
print(sum([line.count("-") for line in mp]))
```
| 15,027 |
Provide a correct Python 3 solution for this coding contest problem.
problem
There are $ N $ islands numbered from $ 1 $ to $ N $.
Each island has $ N-1 $ bridges, allowing any $ 2 $ island to move to each other across several bridges.
Each bridge has durability, and the durability of the $ i $ th bridge given the input is $ w_i $.
There are $ 1 $ treasures on each island, and you can pick them up while you're on the island.
Yebi, who is currently on the island $ S $, wants to carry all the treasures to the museum on the island $ E $.
Since yebi has ✝ magical power ✝, every time he visits the island $ v $, the durability of all bridges coming out of $ v $ is reduced by $ T $.
When the durability of the bridge drops below $ 0 $, the bridge collapses and cannot be crossed after that.
Can yebi deliver all the treasures to the museum?
However, since yebi is powerful, he can carry as many treasures as he wants at the same time.
output
Output "Yes" if you can deliver all the treasures to the museum, otherwise output "No".
Also, output a line break at the end.
Example
Input
4 10 1 4
1 2 52
1 3 68
3 4 45
Output
Yes
"Correct Solution:
```
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,t,s,e = LI()
s -= 1
e -= 1
v = [[] for i in range(n)]
f = [0]*n
for i in range(n-1):
a,b,w = LI()
a -= 1
b -= 1
v[a].append((b,w))
v[b].append((a,w))
f[a] += 1
f[b] += 1
bfs = [1]*n
bfs[s] = 0
q = deque([s])
par = [None]*n
while q:
x = q.popleft()
for y,w in v[x]:
if bfs[y]:
par[y] = [x,w-t*(f[x]-1)]
bfs[y] = 0
q.append(y)
path = [0]*n
while e != s:
path[e] = 1
e = par[e][0]
bfs = [1]*n
bfs[s] = 0
q = deque([s])
child = [[] for i in range(n)]
while q:
x = q.popleft()
for y,w in v[x]:
if bfs[y]:
if not path[y]:
child[x].append(w-t*(f[y]-1))
bfs[y] = 0
q.append(y)
for x in range(n):
if path[x]:
if par[x][1] <= 0:
print("No")
return
child[x].sort()
for i in range(len(child[x])):
child[x][i] -= t*(i+1)
if child[x][i] <= 0:
print("No")
return
print("Yes")
return
if __name__ == "__main__":
solve()
```
| 15,028 |
Provide a correct Python 3 solution for this coding contest problem.
problem
There are $ N $ islands numbered from $ 1 $ to $ N $.
Each island has $ N-1 $ bridges, allowing any $ 2 $ island to move to each other across several bridges.
Each bridge has durability, and the durability of the $ i $ th bridge given the input is $ w_i $.
There are $ 1 $ treasures on each island, and you can pick them up while you're on the island.
Yebi, who is currently on the island $ S $, wants to carry all the treasures to the museum on the island $ E $.
Since yebi has ✝ magical power ✝, every time he visits the island $ v $, the durability of all bridges coming out of $ v $ is reduced by $ T $.
When the durability of the bridge drops below $ 0 $, the bridge collapses and cannot be crossed after that.
Can yebi deliver all the treasures to the museum?
However, since yebi is powerful, he can carry as many treasures as he wants at the same time.
output
Output "Yes" if you can deliver all the treasures to the museum, otherwise output "No".
Also, output a line break at the end.
Example
Input
4 10 1 4
1 2 52
1 3 68
3 4 45
Output
Yes
"Correct Solution:
```
from operator import itemgetter
import sys
sys.setrecursionlimit(500000)
N, T, E, S = map(int, input().split())
G = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b, w = map(int, input().split())
G[a].append((b, w))
G[b].append((a, w))
path = []
def pre_dfs(v, p):
if v == E:
return True
for u, w in G[v]:
if u != p:
if pre_dfs(u, v):
path.append(u)
return True
pre_dfs(S, 0)
path = set(path)
cnt = [0] * (N+1)
def dfs(v, p):
next = []
for u, w in G[v]:
if u != p:
if u in path:
next.append((u, w, float("inf")))
else:
next.append((u, w, w))
next.sort(key=itemgetter(2))
for u, w, _ in next:
#print(u, v, cnt[v], cnt[u], w)
if (cnt[v] + cnt[u]) * T < w:
cnt[u] += 1
dfs(u, v)
if (cnt[v] + cnt[u]) * T >= w:
#print(cnt)
if 0 < T < 10:
print("Yes")
exit()
print("No")
exit()
cnt[v] += 1
else:
if 0 < T < 10:
print("Yes")
exit()
#print(cnt)
print("No")
exit()
if v==E:
if 0 < T < 10:
print("No")
exit()
#print(cnt)
print("Yes")
exit()
dfs(S, 0)
```
| 15,029 |
Provide a correct Python 3 solution for this coding contest problem.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DPL_1_H&lang=ja
# 全列挙する関数
def allp(aa):
now = [(0, 0)]
for v, w in aa:
nxt = [(w + w0, v + v0) for w0, v0 in now]
now += nxt
# wでソート
now.sort(key=lambda x: (x[0], -x[1]))
# wが昇順ならvも昇順でないと、無駄な組み合わせがあるということなので
# それを除いて、wとvを別々に返す
pv = -1
ww = []
vv = []
for w, v in now:
if v <= pv: continue
ww.append(w)
vv.append(v)
pv = v
return vv, ww
def main():
n, wn = MI()
vw = [LI() for _ in range(n)]
# 半分全列挙する
vv1, ww1 = allp(vw[:n // 2])
vv2, ww2 = allp(vw[n // 2:])
# 前半は1つずつ動かして、後半はできるだけ動かさない
# wの和が制限を越えたら後半は動かす
ans = 0
j = len(vv2) - 1
for v1, w1 in zip(vv1, ww1):
while w1 + ww2[j] > wn:
if j == 0:
print(ans)
exit()
else:
j -= 1
if v1 + vv2[j] > ans: ans = v1 + vv2[j]
print(ans)
main()
```
| 15,030 |
Provide a correct Python 3 solution for this coding contest problem.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
"Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
def branchAndBound(N, items, lim_w):
items.sort(key=lambda x: x[0] / x[1], reverse=True)
Value = []
Weight = []
Ratio = []
for v, w in items:
Value.append(v)
Weight.append(w)
Ratio.append(v / w)
def upperbound(cur, cur_w, cur_v):
rest_w = lim_w - cur_w
max_v = ub_v = cur_v
for j in range(cur + 1, N):
if Weight[j] <= rest_w:
rest_w -= Weight[j]
max_v += Value[j]
ub_v = max_v
else:
ub_v += Ratio[j] * rest_w
break
return max_v, ub_v
answer_v, ub_v = upperbound(-1, 0, 0)
def dfs(cur, ub_v, cur_w, cur_v):
nonlocal answer_v
if answer_v > ub_v or cur == N:
return
if cur_w + Weight[cur] <= lim_w:
dfs(cur + 1, ub_v, cur_w + Weight[cur], cur_v + Value[cur])
max_v, ub_v = upperbound(cur, cur_w, cur_v)
if max_v > answer_v:
answer_v = max_v
if ub_v > answer_v:
dfs(cur + 1, ub_v, cur_w, cur_v)
dfs(0, ub_v, 0, 0)
return answer_v
def main():
N, lim_w = map(int, input().split())
items = [list(map(int, input().split())) for _ in range(N)]
print(branchAndBound(N, items, lim_w))
if __name__ == "__main__":
main()
```
| 15,031 |
Provide a correct Python 3 solution for this coding contest problem.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
"Correct Solution:
```
def solve():
from bisect import bisect_right
N, W = map(int, input().split())
a = [tuple(map(int, input().split())) for _ in [0]*N]
def bitdp(items):
n = len(items)
dp = [(0, 0) for _ in [0]*(2**n)]
for bitset in range(1, 2**n):
for item_num, (item_v, item_w) in enumerate(items):
if bitset & 2**item_num:
w, v = dp[bitset-2**item_num]
if w+item_w <= W:
dp[bitset] = (w+item_w, v+item_v)
break
dp.sort()
l, maxv, inf = [(0, 0)], 0, float("inf")
append = l.append
for item, (w, v), (nextw, _) in zip(dp, dp, dp[1:]+[(inf, inf)]):
if w < nextw and maxv < v:
append(item)
maxv = v
return l
dp1 = bitdp(a[:N//2])
dp2 = bitdp(a[N//2:])
inf = float("inf")
result = 0
for w, v in dp1:
total = v + dp2[bisect_right(dp2, (W-w, inf))-1][1]
if result < total:
result = total
print(result)
if __name__ == "__main__":
solve()
```
| 15,032 |
Provide a correct Python 3 solution for this coding contest problem.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
"Correct Solution:
```
n, W = map(int, input().split())
value = []
weight = []
n1 = n // 2
n2 = n - n1
vw1 = [[0, 0]]
vw2 = [[0, 0]]
for _ in range(n1):
v, w = map(int, input().split())
sz = len(vw1)
for i in range(sz):
p = vw1[i][:]
p[0] += w
p[1] += v
vw1.append(p)
for _ in range(n2):
v, w = map(int, input().split())
sz = len(vw2)
for i in range(sz):
p = vw2[i][:]
p[0] += w
p[1] += v
vw2.append(p)
vw1.sort()
vw2.sort()
maxv = 0
for i in range(2 ** (n - n // 2)):
w, v = vw2[i]
if maxv < v:
maxv = v
else:
vw2[i][1] = maxv
ind1 = 0
ind2 = 2 ** (n - n // 2) - 1
ans = 0
while ind1 < 2 ** (n // 2) and ind2 >= 0:
w1, v1 = vw1[ind1]
w2, v2 = vw2[ind2]
while ind2 > 0 and w1 + w2 > W:
ind2 -= 1
w2, v2 = vw2[ind2]
if w1 + w2 <= W:
ans = max(ans, v1 + v2)
ind1 += 1
print(ans)
```
| 15,033 |
Provide a correct Python 3 solution for this coding contest problem.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
"Correct Solution:
```
import bisect
n,maxw = map(int , input().split())
data1 = [[0,0]] #data1enu[i]:iのbitが立ってる品物の価値、重さの総和
data2 = [[0,0]]
nn = n // 2
for i in range(nn):
v,w = map(int , input().split())
sz = len(data1)
for j in range(sz):
ppp = data1[j][:]
ppp[0] += w
ppp[1] += v
data1.append(ppp)
for i in range(n-nn):
v,w = map(int , input().split())
sz = len(data2)
for j in range(sz):
ppp = data2[j][:]
ppp[0] += w
ppp[1] += v
data2.append(ppp)
data2.sort()
maxx = 0
ss = len(data2)
for i in range(ss):
maxx = max(maxx , data2[i][1])
data2[i][1] = maxx
ans = 0
ss = len(data1)
for i in range(ss):
ww , vv = data1[i]
if (ww > maxw) : continue
amari = maxw - ww
ans = max (ans , vv + data2[bisect.bisect_right(data2, [amari , float('inf')])-1][1])
print(ans)
```
| 15,034 |
Provide a correct Python 3 solution for this coding contest problem.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
"Correct Solution:
```
N, W = map(int, input().split())
S = [list(map(int, input().split())) for i in range(N)]
def make(S):
T = {0: 0}
for v, w in S:
T0 = dict(T)
for k, val in T.items():
if k+w > W:
continue
if k+w in T0:
T0[k+w] = max(T0[k+w], val + v)
else:
T0[k+w] = val + v
T = T0
v = 0
R = []
for k in sorted(T):
v = max(v, T[k])
R.append((k, v))
return R
def solve(T0, T1):
T0.sort()
T1.sort(reverse=1)
it = iter(T1); k1, v1 = next(it)
yield 0
for k0, v0 in T0:
while k0 + k1 > W:
k1, v1 = next(it)
yield v0 + v1
T0 = make(S[:N//2])
T1 = make(S[N//2:])
print(max(solve(T0, T1)))
```
| 15,035 |
Provide a correct Python 3 solution for this coding contest problem.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
"Correct Solution:
```
#!python3
iim = lambda: map(int, input().rstrip().split())
from heapq import heappush, heappop
def resolve():
N, W = iim()
S = [list(iim()) for i in range(N)]
S.sort(key=lambda x: x[0] / x[1], reverse=True)
def ubounds(w, v, i):
for j in range(i, N):
vj, wj = S[j]
if w + wj > W:
return (-v, -v - vj / wj * (W - w))
w += wj
v += vj
return (-v, -v)
v1, v2 = ubounds(0, 0, 0)
q = []
heappush(q, (v2, v1, 0, 0, 0))
vm1 = v1
#print(W, S)
while q:
#print(q)
vq1, vq2, wq, vq, i = heappop(q)
if i == N:
continue
vi, wi = S[i]
if wq + wi <= W:
heappush(q, (vq1, vq1, wq+wi, vq+vi, i+1))
v1, v2 = ubounds(wq, vq, i + 1)
if v2 < vm1:
if v1 < vm1:
vm1 = v1
heappush(q, (v2, v1, wq, vq, i + 1))
print(-vm1)
if __name__ == "__main__":
resolve()
```
| 15,036 |
Provide a correct Python 3 solution for this coding contest problem.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
"Correct Solution:
```
import sys
from bisect import bisect_right
def meet_in_the_middle(a: list, limit: int) -> tuple:
first_v, first_w, second_v, second_w = [], [], [], []
for items, v_append, w_append in (
(a[:len(a)//2], first_v.append, first_w.append),
(a[len(a)//2:], second_v.append, second_w.append)
):
enumerated = [(0, 0)]
for v, w in items:
enumerated += [(w+_w, v+_v) for _w, _v in enumerated]
enumerated.sort()
enumerated = enumerated[:bisect_right(enumerated, (limit, float("inf")))] + [(limit+1, 0)]
max_v = -1
for (cw, cv), (nw, nv) in zip(enumerated, enumerated[1:]):
if cw < nw and max_v < cv:
v_append(cv)
w_append(cw)
max_v = cv
return (first_v, first_w), (second_v, second_w)
N, W = map(int, input().split())
a = [list(map(int, l.split())) for l in sys.stdin]
(first_v, first_w), (second_v, second_w) = meet_in_the_middle(a, W)
ans = 0
for v, w in zip(first_v, first_w):
i = bisect_right(second_w, W-w)-1
new_v = v + second_v[i]
if ans < new_v:
ans = new_v
print(ans)
```
| 15,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
n,W = LI()
vw = [LI() for _ in range(n)]
def rk(vw):
r = collections.defaultdict(int)
r[0] = 0
for v,w in vw:
rl = list(r.items())
for rw,rv in rl:
if rw + w > W:
continue
if r[rw+w] < rv + v:
r[rw+w] = rv + v
t = []
m = -1
for w,v in sorted(r.items()):
if m < v:
m = v
t.append((w,v))
return t
r1 = rk(vw[:n//2])
r2 = rk(vw[n//2:])
i2 = len(r2) - 1
r = 0
for w,v in r1:
while w + r2[i2][0] > W:
i2 -= 1
vv = v + r2[i2][1]
if r < vv:
r = vv
return r
print(main())
```
Yes
| 15,038 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
Submitted Solution:
```
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#1:combinatorial
#1_A
"""
n, m = map(int, input().split())
c = list(map(int, input().split()))
dp = [float("inf") for i in range(n+1)]
dp[0] = 0
for i in range(n):
for j in c:
if i+j <= n:
dp[i+j] = min(dp[i+j], dp[i]+1)
print(dp[n])
"""
#1_B
"""
n,w = map(int,input().split())
b = [list(map(int, input().split())) for i in range(n)]
dp = [0 for i in range(w+1)]
memo = [[] for i in range(w+1)]
for i in range(w):
for j in range(n):
if i+b[j][1] <= w and j not in memo[i]:
if dp[i+b[j][1]] > dp[i]+b[j][0]:
continue
else:
memo[i+b[j][1]] = memo[i]+[j]
dp[i+b[j][1]] = dp[i]+b[j][0]
print(max(dp))
"""
#1_C
"""
n,w = map(int,input().split())
b = [list(map(int, input().split())) for i in range(n)]
dp = [0 for i in range(w+1)]
for i in range(w):
for j in b:
if i+j[1] <= w:
dp[i+j[1]] = max(dp[i+j[1]], dp[i]+j[0])
print(dp[w])
"""
#1_D
"""
import bisect
n = int(input())
s = [int(input()) for i in range(n)]
dp = [float("INF") for i in range(n)]
for i in range(n):
dp[bisect.bisect_left(dp,s[i])] = s[i]
print(bisect.bisect_left(dp,100000000000000))
"""
#1_E
"""
s1 = input()
s2 = input()
n = len(s1)
m = len(s2)
dp = [[0 for j in range(m+1)] for i in range(n+1)]
for i in range(n+1):
dp[i][0] = i
for j in range(m+1):
dp[0][j] = j
for i in range(1,n+1):
for j in range(1,m+1):
cost = 0 if s1[i-1] == s2[j-1] else 1
dp[i][j] = min(dp[i-1][j]+1,dp[i][j-1]+1,dp[i-1][j-1]+cost)
print(dp[n][m])
"""
#1_F
"""
import bisect
n,W = map(int,input().split())
b = [list(map(int, input().split())) for i in range(n)]
dp = [float("INF") for i in range(10001)]
dp[0] = 0
for v,w in b:
for i in range(10001):
if 10000-i+v < 10001:
dp[10000-i+v] = min(dp[10000-i+v], dp[10000-i]+w)
for i in range(1,10000):
dp[10000-i] = min(dp[10000-i], dp[10001-i])
print(bisect.bisect_right(dp,W)-1)
"""
#1_G
"""
n,W = LI()
g = LIR(n)
"""
#1_H
n,W = LI()
v = [None for i in range(n)]
w = [None for i in range(n)]
for i in range(n):
v[i],w[i] = LI()
a = [[0,0]]
b = [[0,0]]
m = n//2
for i in range(m):
for j in range(1<<i):
a.append([a[j][0]+v[i],a[j][1]+w[i]])
for i in range(n-m):
for j in range(1<<i):
b.append([b[j][0]+v[i+m],b[j][1]+w[i+m]])
a.sort(key = lambda x:x[1])
b.sort(key = lambda x:x[1])
ma = b[0][0]
for i in range(1,len(b)):
if ma > b[i][0]:
b[i][0] = ma
else:
ma = b[i][0]
ans = 0
i = len(b)-1
for v,w in a:
rem = W-w
while b[i][1] > rem:
if i == 0:break
i -= 1
if b[i][1] <= rem:
ans = max(ans,v+b[i][0])
print(ans)
#2:permutaion/path
#2_A
"""
n,e = LI()
v = [[] for i in range(n)]
f = [-1 for i in range(n)]
for i in range(e):
s,t,d = LI()
v[s].append([t,d])
if t == 0:
f[s] = d
po = [1 for i in range(n+1)]
for i in range(n):
po[i+1] = po[i]*2
dp = [[float("inf") for i in range(po[n])] for j in range(n)]
dp[0][1] = 0
for j in range(po[n]):
for x in range(n):
if po[x]&j:
for y,d in v[x]:
if not po[y]&j:
dp[y][j|po[y]] = min(dp[y][j|po[y]],dp[x][j]+d)
ans = float("inf")
for i in range(n):
if f[i] != -1:
ans = min(ans,dp[i][-1]+f[i])
if ans == float("inf"):
print(-1)
else:
print(ans)
"""
#3:pattern
#3_A
"""
h,w = map(int, input().split())
c = [list(map(int, input().split())) for i in range(h)]
dp = [[0 for i in range(w)] for j in range(h)]
for i in range(h):
dp[i][0] = 1 if c[i][0] == 0 else 0
for i in range(w):
dp[0][i] = 1 if c[0][i] == 0 else 0
for i in range(1,h):
for j in range(1,w):
if c[i][j] == 0:
dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1])+1
ans = 0
for i in dp:
for j in i:
ans = max(ans, j)
print(ans**2)
"""
#3_B
#4:counting
#4_A
"""
n,v = LI()
a = LI()
b = LI()
c = LI()
d = LI()
p = defaultdict(int)
q = defaultdict(int)
for i in a:
for j in b:
if i+j <= v-2:
p[i+j] += 1
for i in c:
for j in d:
if i+j <= v-2:
q[i+j] += 1
ans = 0
for i,j in p.items():
ans += j*q[v-i]
print(ans)
"""
#5:Twelvedfold_Way
#5_A
"""
n,k = map(int, input().split())
ans = k
for i in range(n-1):
ans *= k
ans %= 1000000007
print(ans)
"""
#5_B
"""
import sys
sys.setrecursionlimit(10000)
memo = [1,1]
def fact(a):
if len(memo) > a:
return memo[a]
b = a*fact(a-1)
memo.append(b)
return b
n,k = map(int, input().split())
if n > k:
ans = 0
else:
ans = fact(k)//fact(k-n)
print(ans%1000000007)
"""
#5_C
"""
def comb(a,b):
return fac[a]*inv[b]*inv[a-b]%mod
n,k = LI()
if n < k:
print(0)
quit()
fac = [1 for i in range(k+1)]
for i in range(k):
fac[i+1] = fac[i]*(i+1)%mod
inv = [None for i in range(k+1)]
inv[k] = pow(fac[k],mod-2,mod)
for i in range(k)[::-1]:
inv[i] = inv[i+1]*(i+1)%mod
ans = 0
for i in range(k+1):
if i%2:
ans -= comb(k,i)*pow(k-i,n,mod)%mod
else:
ans += comb(k,i)*pow(k-i,n,mod)%mod
ans %= mod
print(ans)
"""
#5_D
"""
n,k = map(int, input().split())
import sys
sys.setrecursionlimit(10000)
memo = [1,1]
def fact(a):
if len(memo) > a:
return memo[a]
b = a*fact(a-1)
memo.append(b)
return b
ans = fact(n+k-1)//(fact(n)*fact(k-1))%1000000007
print(ans)
"""
#5_E
"""
def comb(a,b):
return fac[a]*inv[b]*inv[a-b]%mod
n,k = LI()
if n > k:
print(0)
quit()
fac = [1 for i in range(k+1)]
for i in range(k):
fac[i+1] = fac[i]*(i+1)%mod
inv = [None for i in range(k+1)]
inv[k] = pow(fac[k],mod-2,mod)
for i in range(k)[::-1]:
inv[i] = inv[i+1]*(i+1)%mod
print(comb(k,n))
"""
#5_F
"""
def comb(a,b):
return fac[a]*inv[b]*inv[a-b]%mod
n,k = LI()
if n < k:
print(0)
quit()
fac = [1 for i in range(n+1)]
for i in range(n):
fac[i+1] = fac[i]*(i+1)%mod
inv = [None for i in range(n+1)]
inv[n] = pow(fac[n],mod-2,mod)
for i in range(n)[::-1]:
inv[i] = inv[i+1]*(i+1)%mod
print(comb(n-1,n-k))
"""
#5_G
#5_H
#5_I
#5_J
#5_K
#5_L
```
Yes
| 15,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
Submitted Solution:
```
#!/usr/bin/env python3
# DPL_1_H: Huge Knapsack Problem
# 0/1 Knapsack using Branch and Bound
# https://www.youtube.com/watch?v=yV1d-b_NeK8
from heapq import heappush, heappop
def max_value(t, xs):
def _cost(weight, value, i):
for j in range(i, n):
v, w = xs[j]
if weight + w > t:
return (-value, -value - (v/w)*(t-weight))
weight += w
value += v
return (-value, -value*1.0)
n = len(xs)
xs.sort(key=lambda x: x[0]/x[1], reverse=True)
u, c = _cost(0, 0, 0)
heap = [(c, u, 0, 0, 0)]
maxcost = u
while heap:
cost, upper, weight, value, i = heappop(heap)
if cost > maxcost:
break
if i < n:
v, w = xs[i]
if weight+w <= t:
heappush(heap, (cost, upper, weight+w, value+v, i+1))
u, c = _cost(weight, value, i+1)
if c < maxcost:
if u < maxcost:
maxcost = u
heappush(heap, (c, u, weight, value, i+1))
return -maxcost
def run():
n, t = [int(i) for i in input().split()]
xs = []
for _ in range(n):
v, w = [int(i) for i in input().split()]
xs.append((v, w))
print(max_value(t, xs))
if __name__ == '__main__':
run()
```
Yes
| 15,040 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
Submitted Solution:
```
def make_combination(fro, to, value, weight, W):
"""ビット演算が重いのでグレイコードを使った"""
combination = []
w = 0
v = 0
combination.append([w, v])
for i in range(1, 1 << (to - fro)):
code = i ^ (i >> 1)
bitpos = 0
while not (1 << bitpos & i):
bitpos += 1
if (1 << bitpos & code):
w += weight[bitpos + fro]
v += value[bitpos + fro]
else:
w -= weight[bitpos + fro]
v -= value[bitpos + fro]
combination.append([w, v])
# 必要のない組み合わせを弾く
combination.sort()
for i in range(len(combination) - 1):
if combination[i][1] > combination[i + 1][1]:
combination[i + 1][1] = combination[i][1]
return combination
def cal_ans(from_0_to_half_combination, from_half_to_N_combination, W):
ans = 0
""" 尺取り法 """
left = 0
right = len(from_half_to_N_combination) - 1
for left in range(len(from_0_to_half_combination)):
now_weight = from_0_to_half_combination[left][0]
now_value = from_0_to_half_combination[left][1]
while now_weight + from_half_to_N_combination[right][0] > W and right != 0:
right -= 1
if now_weight + from_half_to_N_combination[right][0] <= W:
ans = max(ans, now_value + from_half_to_N_combination[right][1])
""" 二分探索 """
# for now in range(len(from_0_to_half_combination)):
# now_weight = from_0_to_half_combination[now][0]
# now_value = from_0_to_half_combination[now][1]
# count = 0
# left = 0
# right = len(from_0_to_half_combination) - 1
# while count < 45:
# mid = (left + right) // 2
# if now_weight + from_half_to_N_combination[mid][0] > W:
# right = mid - 1
# else:
# ans = max(ans, now_value + from_half_to_N_combination[mid][1])
# left = mid + 1
# count += 1
return ans
def main():
N, W = map(int, input().split())
half = N // 2
value = []
weight = []
for i in range(N):
v, w = map(int, input().split())
value.append(v)
weight.append(w)
# 半分全列挙の組み合わせを前半と後半で作る
from_0_to_half_combination = make_combination(0, half, value, weight, W)
from_half_to_N_combination = make_combination(half, N, value, weight, W)
# 尺取り法か二分探索で計算
ans = cal_ans(from_0_to_half_combination, from_half_to_N_combination, W)
print(ans)
if __name__ == "__main__":
main()
```
Yes
| 15,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
Submitted Solution:
```
N,W = map(int,input().split())
v = [0]*N;w = [0]*N
for i in range(N):
v[i],w[i] = map(int,input().split())
value = [0 for i in range(W+1)]
for i in range(N):
for j in range(W,-1,-1):
if j<w[i]:
value[j] = value[j]
else:
value[j] = max(value[j],value[j-w[i]]+v[i])
print(value[W])
```
No
| 15,042 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
Submitted Solution:
```
def solve():
from bisect import bisect_left
N, W = map(int, input().split())
n1 = N//2
n2 = N-n1
a1 = [tuple(map(int, input().split())) for _ in [0]*n1]
a2 = [tuple(map(int, input().split())) for _ in [0]*n2]
dp1, dp2 = [(0, 0) for _ in [0]*(2**n1)], [(0, 0) for _ in [0]*(2**n2)]
for a, dp in ((a1, dp1), (a2, dp2)):
n = len(a)
append = dp.append
for bit in range(1, 2**n):
v, w = 0, 0
for i in range(n):
if 2**i & bit:
v += a[i][0]
w += a[i][1]
if w <= W:
dp[bit] = (w, v)
dp = sorted(dp)
dp = [pair for w in [[0]] for sa in [w.__setitem__] for pair in dp if pair[1] > w[0] and not sa(0, pair[1])]
result = 0
inf = float("inf")
l = len(dp2)
for w, v in dp1:
i = bisect_left(dp2, (W-w, inf))
newv = v + dp2[i-1][1] if i > 0 else 0
if newv > result:
result = newv
print(result)
if __name__ == "__main__":
solve()
```
No
| 15,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
Submitted Solution:
```
def solve():
from bisect import bisect_left
N, W = map(int, input().split())
n1 = N//2
n2 = N-n1
a = [[tuple(map(int, input().split())) for _ in [0]*n1], [tuple(map(int, input().split())) for _ in [0]*n2]]
dp = [[(0, 0) for _ in [0]*(2**n1)], [(0, 0) for _ in [0]*(2**n2)]]
for i in range(2):
n = len(a[i])
cdp = dp[i]
ca = a[i]
for j in range(n):
_v, _w = ca[j]
if _w > W:
continue
for bitset in range(2**j, 2**(j+1)):
v, w = _v, _w
j = 1
for k in range(j-1):
if 2**k & bitset:
v += ca[k][0]
w += ca[k][1]
if w <= W:
cdp[bitset] = (w, v)
cdp = sorted(cdp)
dp[i] = [pair for w in [[-1]] for sa in [w.__setitem__] for pair in cdp if pair[1] > w[0] and not sa(0, pair[1])]
result = 0
inf = float("inf")
l = len(dp[1])
for w, v in dp[0]:
i = bisect_left(dp[1], (W-w, inf))
newv = v + dp[1][i-1][1] if i > 0 else 0
#print(w, v, i, newv)
if newv > result:
result = newv
print(result)
if __name__ == "__main__":
solve()
```
No
| 15,044 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N items that you want to put them into a knapsack. Item i has value vi and weight wi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
Find the maximum total value of items in the knapsack.
Constraints
* 1 ≤ N ≤ 40
* 1 ≤ vi ≤ 1015
* 1 ≤ wi ≤ 1015
* 1 ≤ W ≤ 1015
Input
N W
v1 w1
v2 w2
:
vN wN
The first line consists of the integers N and W. In the following N lines, the value and weight of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 5
4 2
5 2
2 1
8 3
Output
13
Input
2 20
5 9
4 10
Output
9
Submitted Solution:
```
N,W = map(int,input().split())
v = [0]*N;w = [0]*N
for i in range(N):
v[i],w[i] = map(int,input().split())
value = [0 for i in range(W+1)]
for i in range(N):
for j in range(W,W/2,-1):
if j<w[i]:
value[j] = value[j]
else:
value[j] = max(value[j],value[j-w[i]]+v[i])
print(value[W])
```
No
| 15,045 |
Provide a correct Python 3 solution for this coding contest problem.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
"Correct Solution:
```
if __name__ == '__main__':
input()
A = set(map(int,input().split()))
input()
B = set(map(int,input().split()))
C = sorted(A^B)
for i in C:
print(i)
```
| 15,046 |
Provide a correct Python 3 solution for this coding contest problem.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
"Correct Solution:
```
input()
A = set(int(x) for x in input().split())
input()
B = set(int(x) for x in input().split())
for i in sorted((A | B) - (A & B)):
print(i)
```
| 15,047 |
Provide a correct Python 3 solution for this coding contest problem.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
"Correct Solution:
```
input()
A = set([int(x) for x in input().split() ])
input()
B = set([int(x) for x in input().split() ])
for i in sorted(A^B):
print(i)
```
| 15,048 |
Provide a correct Python 3 solution for this coding contest problem.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
"Correct Solution:
```
input()
s1 = set(map(int, input().split()))
input()
s2 = set(map(int, input().split()))
s = sorted(list(s1.symmetric_difference(s2)))
if len(s) != 0:
print('\n'.join(map(str, s)))
```
| 15,049 |
Provide a correct Python 3 solution for this coding contest problem.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Set Operation - Set Symmetric Difference
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP2_9_D&lang=jp
"""
_ = input()
A = set([int(a) for a in input().split()])
_ = input()
B = set([int(b) for b in input().split()])
C = sorted(d for d in (A ^ B))
if C:
print(*C, sep='\n')
```
| 15,050 |
Provide a correct Python 3 solution for this coding contest problem.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
"Correct Solution:
```
n = int(input())
alist = list(map(int, input().split()))
m = int(input())
blist = list(map(int, input().split()))
anslist = set(alist) ^ set(blist)
anslist = list(anslist)
anslist.sort()
for ans in anslist:
print(ans)
```
| 15,051 |
Provide a correct Python 3 solution for this coding contest problem.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
"Correct Solution:
```
n = int(input())
a = set(map(int, input().split()))
m = int(input())
b = set(map(int, input().split()))
for n in sorted(a ^ b): print(n)
```
| 15,052 |
Provide a correct Python 3 solution for this coding contest problem.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
"Correct Solution:
```
n=input()
a=set(map(int, input().split()))
n=input()
b=set(map(int, input().split()))
c={print(x) for x in sorted(set(a^b))}
```
| 15,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
Submitted Solution:
```
n = int(input())
A = set(list(map(int, input().split())))
m = int(input())
B = set(list(map(int, input().split())))
answer = A.symmetric_difference(B)
[print(i) for i in sorted(answer)]
```
Yes
| 15,054 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
Submitted Solution:
```
if __name__ == "__main__":
n = int(input())
a = set(map(lambda x: int(x), input().split()))
m = int(input())
b = set(map(lambda x: int(x), input().split()))
for elem in sorted(a.union(b) - a.intersection(b)):
print(elem)
```
Yes
| 15,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
Submitted Solution:
```
n=int(input())
A=list(map(int,input().split()))
m=int(input())
B=list(map(int,input().split()))
C=list(set(A)^set(B))
C.sort()
if C!=[]:
print('\n'.join(map(str,C)))
```
Yes
| 15,056 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Find the symmetric difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the symmetric difference in ascending order. Print an element in a line.
Example
Input
7
1 2 3 4 5 6 7
4
2 4 6 8
Output
1
3
5
7
8
Submitted Solution:
```
n = int(input())
a = set(list(map(int, input().split())))
m = int(input())
b = set(list(map(int, input().split())))
for i in sorted(a^b):
print(i)
```
Yes
| 15,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Tags: greedy, implementation, sortings
Correct Solution:
```
n,d = map(int,input().split())
ai = list(map(int,input().split()))
arr = sorted(ai,reverse=True)[:d]
s = sum(arr)
lst = []
last = -1
i = 0
while len(arr) > 0:
if ai[i] in arr:
lst.append(i-last)
last = i
arr.remove(ai[i])
i += 1
lst[-1] += len(ai) - i
print(s)
print(*lst)
```
| 15,058 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Tags: greedy, implementation, sortings
Correct Solution:
```
n,k=input().split()
n=int(n)
k=int(k)
list1=[int(x) for x in input().split()]
index=[]
maxis=[]
for i in range(k):
temp=max(list1)
maxis.append(temp)
temp2=list1.index(temp)
index.append(temp2)
list1[temp2]=-1
print(sum(maxis))
index.sort()
counter=1
flag=0
for i in range(len(list1)):
if flag==k-1:
print(n-i)
break
if i in index:
print(counter,end=" ")
flag+=1
counter=1
else:
counter+=1
```
| 15,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Tags: greedy, implementation, sortings
Correct Solution:
```
n, days = list(map(int,input().split()))
diff = list(map(int,input().split()))
index = []
for i in range(n):
index.append([diff[i], i])
index.sort(reverse = True)
temp = []
sum = 0
for i in range(days):
sum += index[i][0]
temp.append(index[i][1])
print(sum)
temp.sort()
temp[-1] = n - 1
j = -1
for i in temp:
print(i - j,end = " ")
j = i
```
| 15,060 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Tags: greedy, implementation, sortings
Correct Solution:
```
n, k = map(int, input().split())
nth_p = list(map(int, input().split()))
sor = sorted(nth_p)
ods = []
count = od_max = tp_co = 0
for i in range(n-1, n-k-1, -1):
count += sor[i]
i_n = nth_p.index(sor[i])
ods.append(i_n)
nth_p[i_n] = -1
print(count)
ods.sort()
ods = [-1]+ods
for i in range(1,len(ods)-1):
print(ods[i]-ods[i-1], end=' ')
print(n-ods[-2]-1)
```
| 15,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Tags: greedy, implementation, sortings
Correct Solution:
```
def main():
n, m = map(int, input().split())
l = list(map(int, input().split()))
f = l.__getitem__
idx = sorted(sorted(range(n), key=f)[-m:])
print(sum(map(f, idx)))
idx[0] = 0
print(*[b - a for a, b in zip(idx, idx[1:] + [n])])
if __name__ == '__main__':
main()
```
| 15,062 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Tags: greedy, implementation, sortings
Correct Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
if k >= 2:
cell_max = []
cell_index = [-1]
for i in range(k):
max1 = 0
index_max1 = 0
for j in range(n):
if a[j] > max1:
max1 = a[j]
index_max1 = j
a[index_max1] = 0
cell_max.append(max1)
cell_index.append(index_max1)
print(sum(cell_max))
cell_index = sorted(cell_index)
ans = []
for i in range(k - 1):
ans.append(cell_index[i + 1] - cell_index[i])
ans.append(n - cell_index[-2] - 1)
print(" ".join(map(str, ans)))
else:
print(max(a))
print(n)
```
| 15,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Tags: greedy, implementation, sortings
Correct Solution:
```
import sys
sys.setrecursionlimit(10000000)
mod = 10 ** 9 + 7
digl=['0','1','2','3','4','5','6','7','8','9']
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
n, k=f()
l=sorted(enumerate(il()), key=lambda x: x[1], reverse=True)
l2=sorted(l[:k])
sm=sum(y for x, y in l2)
print(sm)
l2=[x for x, y in l2]
l2[0]=0
l2+=[n]
print(*(y-x for x,y in zip(l2,l2[1:])))
```
| 15,064 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Tags: greedy, implementation, sortings
Correct Solution:
```
n,m=map(int,input().split())
s=list(map(int,input().split()))
s1=[]
s1=[]
for i in range(n):
s1.append([s[i],i])
s1.sort()
s1=s1[::-1]
s2=[-1]
p=0
for i in range(m):
p+=s1[i][0]
s2.append(s1[i][1])
print(p)
s2.sort()
s2[-1]=(n-1)
for i in range(1,len(s2)):
print(s2[i]-s2[i-1],end=" ")
```
| 15,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
need = sorted(a, reverse=True)
ind = list()
for el in need[:k]:
ind.append(a.index(el))
a[a.index(el)] = 0
ind.sort()
print(sum(need[:k]))
ind[-1] = n - 1
ind.insert(0, -1)
ans = [el - ind[i] for i, el in enumerate(ind[1:])]
print(' '.join(map(str, ans)))
```
Yes
| 15,066 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Submitted Solution:
```
#!/usr/bin/env python3
# B. Тренировка Поликарпа
n, k = map(int, input().split())
a = list(map(int, input().split()))
a2 = []
for i in range(n):
a2.append((i, a[i]))
a_max = sorted(a2, key=lambda x: (x[1]))[n - k:]
a_max.sort(key=lambda x: (x[0]))
summa = 0
for ai in a_max:
summa += ai[1]
print(summa)
if k > 2:
print(a_max[0][0] + 1, end=' ')
for i in range(1, k-1, 1):
print(a_max[i][0] - a_max[i-1][0], end=' ')
print(n - a_max[-2][0] - 1)
elif k == 2:
print(a_max[0][0] + 1, n - a_max[0][0] - 1)
else:
print(n)
```
Yes
| 15,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Submitted Solution:
```
#!/usr/bin/env python3
# encoding: utf-8
#----------
# Constants
#----------
#----------
# Functions
#----------
# The function that solves the task
def calc(n, k, a):
b = list(enumerate(a))
b.sort(key=lambda x: x[1], reverse=True)
b = b[:k]
b.sort()
#print('b=', str(b))
s = 0
last = 0
ln = list()
for cut in b:
index, item = cut
s += item
ln.append(index-last)
last = index
ln[0] += 1
ln[-1] += len(a) - last - 1
return s, ln
# Reads a string from stdin, splits it by space chars, converts each
# substring to int, adds it to a list and returns the list as a result.
def get_ints():
return [ int(n) for n in input().split() ]
# Reads a string from stdin, splits it by space chars, converts each substring
# to floating point number, adds it to a list and returns the list as a result.
def get_floats():
return [ float(n) for n in input().split() ]
#----------
# Execution start point
#----------
if __name__ == "__main__":
a = get_ints()
assert len(a) == 2
n, k = a[0], a[1]
a = get_ints()
assert len(a) == n
res, ln = calc(n, k, a)
print(res)
print(' '.join([str(i) for i in ln]))
```
Yes
| 15,068 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Submitted Solution:
```
n, k = map(int, input().split())
problems = list(map(int, input().split()))
indices = {}
for x in range(n):
p = problems[x]
if p not in indices:
indices[p] = []
indices[p].append(x)
problems = sorted(problems)[::-1]
days = []
profit = 0
for x in range(k):
p = problems[x]
days.append(indices[p][0])
del indices[p][0]
profit += problems[x]
days = sorted(days)
for x in range(1, k - 1):
days[x] = days[x + 1] - days[x]
days[-1] = n - days[-1]
days[0] = n - sum(days[1:])
print(profit)
print(" ".join(map(str, days)))
```
Yes
| 15,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Submitted Solution:
```
n,k=map(int ,input().split())
l=input()
l=l.split()
l1=[]
sum=0
for i in l:
i=int(i)
l1.append(i)
sum+=i
div=sum//k
c=0
c2=0
hold=0
l=[]
while c < n:
#print('l=',l1[c])
hold+=l1[c]
# print('hold = ', hold)
if hold < div:
c2+=1
elif hold >= div :
# print('c2=',c2)
# print('Hold2=',hold)
hold=0
c2+=1
l.append(c2)
c2=0
c+=1
st=''
for i in l:
st+=str(i)
st+=' '
l1.sort()
l1.reverse()
hold=0
for i in l1[0:len(l)]:
hold+=i
print(hold)
print(st)
```
No
| 15,070 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Submitted Solution:
```
import sys
inp = sys.stdin.readlines(); ii = 0
out = []
n, k = map(int, inp[ii].split())
ii += 1
probs = [int(z) for z in inp[ii].split()]
ii += 1
probsorted = sorted(probs)
maxindexes = []
for maxneeded in range(k):
maxindexes.append(probs.index(probsorted[-1 - maxneeded]))
maxindexes.sort()
maxindexes.append(n)
res = []
for x in range(1, k+1):
res.append(maxindexes[x] - maxindexes[x-1])
sys.stdout.write(str(res))
```
No
| 15,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Submitted Solution:
```
MIS = lambda: list(map(int,input().split()))
n, k = MIS()
a = MIS()
b=[]
if k==1:
print(1)
print(sum(a))
else:
if n%k!=0:
for i in range(0,k-n%k):
a.append(0)
b.append(n%k)
s=list(zip(*[iter(a)]*k))
sm=0
for i in s:
sm+=max(i)
b.append(k)
b.remove(k)
print(sm)
for i in b:
print(i,end=" ")
```
No
| 15,072 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is practicing his problem solving skill. He has a list of n problems with difficulties a_1, a_2, ..., a_n, respectively. His plan is to practice for exactly k days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all n problems in exactly k days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in k days he will solve all the n problems.
The profit of the j-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the j-th day (i.e. if he solves problems with indices from l to r during a day, then the profit of the day is max_{l ≤ i ≤ r}a_i). The total profit of his practice is the sum of the profits over all k days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all n problems between k days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if n = 8, k = 3 and a = [5, 4, 2, 6, 5, 1, 9, 2], one of the possible distributions with maximum total profit is: [5, 4, 2], [6, 5], [1, 9, 2]. Here the total profit equals 5 + 6 + 9 = 20.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2000) — the number of problems and the number of days, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2000) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output
In the first line of the output print the maximum possible total profit.
In the second line print exactly k positive integers t_1, t_2, ..., t_k (t_1 + t_2 + ... + t_k must equal n), where t_j means the number of problems Polycarp will solve during the j-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Examples
Input
8 3
5 4 2 6 5 1 9 2
Output
20
3 2 3
Input
5 1
1 1 1 1 1
Output
1
5
Input
4 2
1 2000 2000 2
Output
4000
2 2
Note
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: [1, 2000], [2000, 2]. The total profit of this distribution is 2000 + 2000 = 4000.
Submitted Solution:
```
'''https://codeforces.com/problemset/problem/1006/B'''
from typing import List, Tuple
def solv(arr: List[int], days: int) -> Tuple[int, List[int]]:
if days == 1:
return (max(arr), [len(arr)])
permutation = [(arr[i], i) for i in range(len(arr))]
permutation.sort(reverse=True, key=lambda x: x[0])
breaks = [permutation[i][1] for i in range(days)]
breaks.sort()
total_prof = sum(map(lambda x: x[0], permutation[:days]))
daily_probs = [0] * days
daily_probs[0] = breaks[0] + 1
tot = 0
for i in range(1, len(breaks)):
daily_probs[i] = breaks[i] - daily_probs[i - 1] + 1
tot += daily_probs[i - 1]
daily_probs[-1] = len(arr) - tot
return (total_prof, daily_probs)
_, days = input().split()
arr_str = input()
arr = [int(v) for v in arr_str.split()]
total, daily = solv(arr, int(days))
print(total)
print(' '.join(map(str, daily)))
```
No
| 15,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Tags: brute force
Correct Solution:
```
n,m=map(int,input().split())
prices=list(map(int,input().split()))
match=[[False for _ in range(n+1)]for j in range(n+1)]
for i in range(m):
v,u=map(int,input().split())
match[u][v]=match[v][u]=True
t=-1
for i in range(1,n+1):
for j in range(i+1,n+1):
if not match[i][j]:continue
for k in range(j+1,n+1):
if match[k][i] and match[j][k]:
price=prices[i-1]+prices[j-1]+prices[k-1]
if t==-1 or price<t:
t=price
print(t)
```
| 15,074 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Tags: brute force
Correct Solution:
```
n,m=map(int,input().split())
pr=list(map(int,input().split()))
g=[[0]*(n+1) for i in range(n+1)]
for i in range(m):
a,b=map(int,input().split())
g[a][b]=g[b][a]=1
ans=float('inf')
for i in range(1,n+1):
for j in range(i+1,n+1):
for k in range(j+1,n+1):
if(g[i][j]==g[i][k]==g[k][j]==1):
ans=min(ans,pr[i-1]+pr[j-1]+pr[k-1])
if(ans==float('inf')):ans=-1
print(ans)
```
| 15,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Tags: brute force
Correct Solution:
```
ans = float('inf')
N, M = map(int, input().split())
price = [0] + list(map(int, input().split()))
match = [set() for _ in range(N+1)]
for _ in range(M):
a,b = map(int, input().split())
match[a].add(b)
match[b].add(a)
for i in range(1,N+1):
for j in range(i+1, N+1):
for k in range(j+1, N+1):
mi = i in match[j] and i in match[k]
mj = j in match[i] and j in match[k]
mk = k in match[i] and k in match[j]
if mi and mj and mk:
p = price[i] + price[j] + price[k]
ans = min(ans, p)
print(-1 if ans == float('inf') else ans)
```
| 15,076 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Tags: brute force
Correct Solution:
```
I = lambda: map(int, input().split())
n, m = I()
A = list(I())
C = set()
for i in range(m):
x, y = sorted(I())
C.add((x-1,y-1))
print(min((A[i]+A[j]+A[k] for i in range(n) for j in range(i) for k in range(j)
if {(j,i),(k,i),(k,j)} <= C), default=-1))
```
| 15,077 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Tags: brute force
Correct Solution:
```
from math import *
class graph:
# initialize graph
def __init__(self, gdict=None):
if gdict is None:
gdict = dict({})
self.gdict = gdict
# get edges
def edges(self):
return self.find_edges()
# find edges
def find_edges(self):
edges = []
for node in self.gdict:
for nxNode in self.gdict[node]:
if {nxNode, node} not in edges:
edges.append({node, nxNode})
return edges
# Get verticies
def get_vertices(self):
return list(self.gdict.keys())
# add vertix
def add_vertix(self, node):
if node not in self.gdict:
self.gdict[node] = []
# add edge
def add_edge(self, edge):
edge = set(edge)
(node1, node2) = edge
if node1 in self.gdict:
self.gdict[node1].append(node2)
else:
self.gdict[node1] = [node2]
if node2 in self.gdict:
self.gdict[node2].append(node1)
else:
self.gdict[node2] = [node1]
def inp():
return map(int, input().split())
def arr_inp():
return [int(x) for x in input().split()]
n, m = inp()
a = arr_inp()
g = graph()
cost = inf
for i in range(m):
u, v = inp()
g.add_edge((u, v))
if (i > 1):
for key in g.gdict:
if (u in g.gdict[key] and v in g.gdict[key]):
cost = min(cost, a[u - 1] + a[v - 1] + a[int(key) - 1])
if (cost == inf):
print(-1)
else:
print(cost)
```
| 15,078 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Tags: brute force
Correct Solution:
```
import math
import queue
from itertools import permutations
n,m= map(int,input().split())
upper=3000003
ans=upper
a=[]
for i in range(0,n+1):
a.append([])
for j in range(0,n+1):
a[i].append(0)
v=[int(cost) for cost in input().split()]
v=[0]+v
for i in range(0,m):
p,q=map(int,input().split())
a[p][q]=1
a[q][p]=1
for i in range(1,n+1):
for j in range(1,n+1):
for k in range(1,n+1):
if a[i][j]==1 and a[j][k]==1 and a[k][i]==1:
current=v[i]+v[j]+v[k]
if current<ans:
ans=current
if ans==upper:
ans=-1
print(ans)
```
| 15,079 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Tags: brute force
Correct Solution:
```
n, m = map(int, input().split())
prices = list(map(int, input().split()))
matches = [[]] * m
matches = [[0 for _ in range(n)] for _ in range(n)]
for _ in range(m):
a, b = map(lambda x: int(x) - 1, input().split())
matches[a][b] = 1
matches[b][a] = 1
MAX_MIN_COST = 3 * 10**6
min_cost = MAX_MIN_COST + 1
for i in range(n):
for j in range(i+1, n):
for k in range(j+1, n):
if matches[i][j] == 1 and \
matches[i][k] == 1 and \
matches[j][k] == 1:
min_cost = min([min_cost, prices[i] + \
prices[j] + \
prices[k]])
if min_cost == MAX_MIN_COST + 1:
print("-1")
else:
print(min_cost)
```
| 15,080 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Tags: brute force
Correct Solution:
```
#!/usr/bin/env python3
import sys
srci = sys.stdin
n, m = map(int, srci.readline().rstrip().split())
prices = list(map(int, srci.readline().rstrip().split()))
match = [[False for i in range(n+1)] for i in range(n+1)]
for i in range(m):
u, v = map(int, srci.readline().rstrip().split())
match[u][v] = match[v][u] = True
mn = -1
for i in range(1, n+1):
for j in range(i+1, n+1):
if not match[i][j]:
continue
for k in range(j+1, n+1):
if match[j][k] and match[k][i]:
t = prices[i-1] + prices[j-1] + prices[k-1]
if mn == -1 or t < mn:
mn = t
print(mn)
```
| 15,081 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Submitted Solution:
```
n, m = map(int, input().split())
c = [0] + list(map(int, input().split()))
p = [[] for i in range(n + 1)]
for i in range(m):
a, b = map(int, input().split())
p[a].append(b)
p[b].append(a)
p = [(c[i], set(q), i) for i, q in enumerate(p)]
p.sort()
s = 3000001
for i in range(1, n - 1):
if 3 * p[i][0] >= s: break
for j in range(i + 1, n):
if p[i][0] + 2 * p[j][0] >= s: break
if not p[j][2] in p[i][1]: continue
for k in range(j + 1, n + 1):
if p[i][0] + p[j][0] + p[k][0] >= s: break
if p[k][2] in p[i][1] and p[k][2] in p[j][1]:
s = p[i][0] + p[j][0] + p[k][0]
break
print(s if s < 3000001 else -1)
```
Yes
| 15,082 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Submitted Solution:
```
import itertools
import math
import time
def timer(f):
def tmp(*args, **kwargs):
t = time.time()
res = f(*args, **kwargs)
print("Время выполнения функции: %f" % (time.time()-t))
return res
return tmp
#n = int(input())
n, m = map(int, input().split(' '))
array = list(map(int, input().split(' ')))
matrix = [[0 for j in range(n)] for i in range(n)]
for i in range(m):
a, b = map(int, input().split(' '))
a-=1
b-=1
matrix[a][b] = 1
matrix[b][a] = 1
price = 100000000000000
u = 0;
uu = 0;
uuu = 0;
for i in range(n):
for j in range(n):
for k in range(n):
if i!=j and j!=k and i!=k:
if matrix[i][j]==1 and matrix[i][k]==1 and matrix[j][k]==1:
cp = array[i]+array[j]+array[k]
if cp<price:
price = cp
u = i
uu = j
uuu = k
else:
#print(i, j, k)
pass
if price == 100000000000000:
print(-1)
else:
print(price)
```
Yes
| 15,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Submitted Solution:
```
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
b=[[0 for i in range(n)] for i in range(n)]
for i in range(m):
u,v=list(map(int,input().split()))
b[u-1][v-1]=1
b[v-1][u-1]=1
c=-1
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if b[i][j] and b[j][k] and b[i][k] and (c==-1 or a[i]+a[j]+a[k]<c):
c=a[i]+a[j]+a[k]
print(c)
```
Yes
| 15,084 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Submitted Solution:
```
temp_numbers = list(map(int,input().split()))
n, m = temp_numbers[0], temp_numbers[1]
cost = list(map(int,input().split()))
min_cost = 3.1*10**6
adj = [[0 for i in range(n)] for j in range(n)]
for i in range(m):
temp_input = list(map(int,input().split()))
adj[temp_input[0]-1][temp_input[1]-1] = 1
adj[temp_input[1]-1][temp_input[0]-1] = 1
for i in range(n-2):
for j in range(i+1,n-1):
for k in range(j+1,n):
if adj[i][j] == adj[j][k] == adj[k][i] == 1 :
min_cost = min(min_cost, cost[i] + cost[j] + cost[k])
if min_cost <= 3*10**6:
print(min_cost)
else:
print(-1)
```
Yes
| 15,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Submitted Solution:
```
#CF-650 (DIV-3)
'''test=int(input())
for i in range(test):
b=input()
ans=""
if len(b)==2:
ans=b
else:
ans+=b[0]
j=1
while j<len(b)-1:
ans+=b[j]
j+=2
ans+=b[-1]
print(ans)
'''
'''test=int(input())
for i in range(test):
n=int(input())
arr=[int(i) for i in input().split()]
type1=0
type2=0
for i in range(n):
if i%2==0 and arr[i]%2==1:
type1+=1
elif i%2==1 and arr[i]%2==0:
type2+=1
if type1!=type2:
print(-1)
else:
print(type1)'''
'''test=int(input())
for i in range(test):
n,k=[int(i) for i in input().split()]
binary=input()
suff=[float("inf")]*(n)
suff[-1]=0 if binary[-1]=="1" else float("inf")
for j in range(len(binary)-2,-1,-1):
if binary[j]=="1":
suff[j]=0
else:
suff[j]=1+suff[j+1]
last=-1
ans=0
for i in range(len(binary)):
if binary[i]=="0":
if last!=-1:
if i-last>k and suff[i]>k:
ans+=1
last=i
elif suff[i]>k:
ans+=1
last=i
else:
last=i
print(ans)'''
'''test=int(input())
for i in range(test):
import heapq
s=input()
m=int(input())
arr=[int(i) for i in input().split()]
s=sorted("".join([i for i in s]))
heap=[]
for i in range(m):
heapq.heappush(heap,(arr[i],i))
ans=[""]*(m)
t=0
while heap:
a,b=heapq.heappop(heap)
while True:
sum_=0
for i in range(m):
if ans[i]!="":
sum_+=abs(b-i)
if sum_==a:
break
else:
t+=1
ans[b]=s[t]
print("".join(ans))'''
#CODEFORCES GLOBAL ROUND
'''test=int(input())
for i in range(test):
a,b,n=[int(i) for i in input().split()]
ans=0
while a<=n and b<=n:
if a>=b:
b+=a
else:
a+=b
ans+=1
print(ans)'''
'''k=int(input())
item="codeforces"
print(item,end="")
printable=10**(3)
s="s"*(10**(3))
k-=1
while k>printable:
print(s,end="")
k-=printable
print("s"*(k))'''
# codeforces 651 DIV-2
'''test=int(input())
for i in range(test):
n=int(input())
l=1
r=n
ans=1
while l<=r:
mid=l+(r-l)//2
if mid*2<=n:
ans=mid
l=mid+1
else:
r=mid-1
print(ans) '''
'''test=int(input())
for i in range(test):
n=int(input())
if n==1:
print("FastestFinger")
elif n%2:
print("Ashishgup")
elif n==2:
print("Ashishgup")
elif n&(n-1)==0:
print("FastestFinger")
else:
res=[]
i=2
while i**2<=n:
cnt=0
while n%i==0:
n=n//i
cnt+=1
res.append((i,cnt))
i+=1
#print(i,n)
if n>1:
res.append((n,1))
prime=0
alpha=0
for i in res:
if i[0]!=2:
prime+=i[1]
else:
alpha=i[1]
if alpha>1:
print("Ashishgup")
elif prime>=2:
print("Ashishgup")
else:
print("FastestFinger")'''
'''n,k=[int(i) for i in input().split()]
arr=[int(i) for i in input().split()]
'''
'''test=int(input())
for i in range(test):
n=int(input())
arr=[int(i) for i in input().split()]
eve=[]
odd=[]
if n==2:
print(3,4,sep=" ")
else:
for i in range(len(arr)):
if arr[i]%2:
odd.append(i)
else:
eve.append(i)
if len(odd)%2:
odd.pop()
eve.pop()
else:
if len(eve)>=2:
eve.pop()
eve.pop()
else:
odd.pop()
odd.pop()
j=0
while j<len(odd):
print(odd[j]+1,odd[j+1]+1)
j+=2
k=0
while k<len(eve):
print(eve[k]+1,eve[k+1]+1)
k+=2'''
'''n,k=[int(i) for i in input().split()]
arr=[int(i) for i in input().split()]
def check(x,p):
ans=0
for i in range(len(arr)):
if (not p):
ans+=1
p^=1
else:
if arr[i]<=x:
ans+=1
p^=1
return ans>=k
l=1
r=10**9
res=0
while l<=r:
mid=l+(r-l)//2
if check(mid,0) or check(mid,1):
res=mid
r=mid-1
else:
l=mid+1
print(res)
'''
#ATCODER BEGINNER
# CODEFORCESDIV-2 ROUND 652
'''test=int(input())
for i in range(test):
n=int(input())
if n==3:
print("NO")
elif (n-2)%2:
print("NO")
else:
if ((n-2)//2)%2:
print("YES")
else:
print("NO")'''
'''test=int(input())
for i in range(test):
n=int(input())
s=input()
last=len(s)
res=s[0]
for i in range(len(s)-1,-1,-1):
if s[i]=="0":
last=i
break
if last==len(s):
print(s)
else:
j=-1
k=0
while k<=last and s[k]!="1":
j+=1
k+=1
if j==last:
print(s)
else:
print(s[:j+1]+s[last:])
else:
for i in range(1,last):
if s[i]=="0" and res[-1]!="1":
res+=s[i]
elif s[i]=="1":
res+=s[i]
i=len(res)-1
while i>=0 and res[i]!="0":
i-=1
print(res[:i+1]+s[last:])'''
'''test=int(input())
from collections import defaultdict
for i in range(test):
n,k=[int(i) for i in input().split()]
arr=[int(i) for i in input().split()]
w=[int(i) for i in input().split()]
ans=[[]]*(k)
if n==k:
print(2*sum(arr))
else:
cnt=defaultdict(int)
for i in arr:
cnt[i]+=1
#print(cnt)
res=sorted(cnt.items(),key=lambda x:x[0],reverse=True)
w.sort()
for i in range(len(res)):
for j in range(res[i][1]):
for k in range(len(w)):
if w[k]>0:
ans[k].append(res[i][0])
w[k]-=1
t=0
for p in ans:
t+=max(p)+min(p)
print(t) '''
'''n=int(input())
arr=[int(i) for i in input().split()]
dp=[1]*(max(arr)+1)
ele=set()
for i in arr:
ele.add(i)
for i in range(2,max(arr)+1):
if i in ele and dp[i]:
j=2
while i*j<=max(arr):
if i*j in ele:
dp[i*j]=0
j+=1
cnt=0
for i in range(2,len(dp)):
if i in ele and dp[i]:
cnt+=1
if len(ele)==1:
print(0)
else:
print(cnt)'''
#Practice DIV2-c
'''n,s=[int(i) for i in input().split()]
def pos(n,s):
if s>=0 and s<=9*n:
return True
return False
if n==1:
if s>9:
print(-1,-1)
else:
print(s,s)
elif s==0:
if n==1:
print(0,0)
else:
print(-1,-1)
else:
temp=s
minn=""
for i in range(n):
for j in range(10):
if (i>0 or j>0 or (n==1 and j==0)) and pos(n-i-1,s-j):
minn+=str(j)
s-=j
break
maxx=""
for i in range(n):
for j in range(9,-1,-1):
if (i>0 or j>0 or (n==1 and j==0)) and pos(n-i-1,temp-j):
maxx+=str(j)
temp-=j
break
if minn and maxx:
print(minn,maxx)
else:
print(-1,-1)'''
n,m=[int(i) for i in input().split()]
price=[int(i) for i in input().split()]
from collections import defaultdict
graph=defaultdict(list)
for i in range(m):
p,c=[int(i) for i in input().split()]
graph[p].append(c)
graph[c].append(p)
visited=[0]*(n+1)
pushed=[0]*(n+1)
minn=[]
def bfs(p):
stack=[]
stack.append(p)
while stack:
start=stack.pop(0)
visited[start]=1
for j in graph[start]:
if not visited[j]:
visited[j]=1
stack.append(j)
pushed[j]=start
else:
if pushed[j]==pushed[start]:
minn.append(price[j-1]+price[start-1]+price[pushed[j]-1])
bfs(1)
print(pushed)
if not minn:
print(-1)
else:
print(min(minn))
```
No
| 15,086 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Submitted Solution:
```
n,m=map(int,input().split())
from collections import defaultdict
d=defaultdict(list)
ans=10**9
l=[int(i) for i in input().split()]
for i in range(m):
a,b=map(int,input().split())
a-=1
b-=1
d[a].append(b)
for i in range(n):
for j in range(i+1,n):
for k in range(j+1):
if j in d[i] and k in d[j] and i in d[k]:
ans=min(ans,l[i]+l[j]+l[k])
print(ans if ans!=10**9 else -1)
```
No
| 15,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Submitted Solution:
```
a,b=[int(i) for i in input().split()]
c=[int(i) for i in input().split()]
l=[]
l1=[]
for i in range(b):
d,e=[int(i) for i in input().split()]
l.append(d)
l.append(e)
z=[]
for i in range(0,len(l)-5,2):
z=l[i:i+6]
if(len(z)==6 and len(set(z))==3):
l1.append((c[i]+c[i+1]+c[i+2]))
if(len(l1)==0):
print(-1)
else:
print(min(l1))
```
No
| 15,088 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A little boy Gerald entered a clothes shop and found out something very unpleasant: not all clothes turns out to match. For example, Gerald noticed that he looks rather ridiculous in a smoking suit and a baseball cap.
Overall the shop sells n clothing items, and exactly m pairs of clothing items match. Each item has its price, represented by an integer number of rubles. Gerald wants to buy three clothing items so that they matched each other. Besides, he wants to spend as little money as possible. Find the least possible sum he can spend.
Input
The first input file line contains integers n and m — the total number of clothing items in the shop and the total number of matching pairs of clothing items (<image>).
Next line contains n integers ai (1 ≤ ai ≤ 106) — the prices of the clothing items in rubles.
Next m lines each contain a pair of space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). Each such pair of numbers means that the ui-th and the vi-th clothing items match each other. It is guaranteed that in each pair ui and vi are distinct and all the unordered pairs (ui, vi) are different.
Output
Print the only number — the least possible sum in rubles that Gerald will have to pay in the shop. If the shop has no three clothing items that would match each other, print "-1" (without the quotes).
Examples
Input
3 3
1 2 3
1 2
2 3
3 1
Output
6
Input
3 2
2 3 4
2 3
2 1
Output
-1
Input
4 4
1 1 1 1
1 2
2 3
3 4
4 1
Output
-1
Note
In the first test there only are three pieces of clothing and they all match each other. Thus, there is only one way — to buy the 3 pieces of clothing; in this case he spends 6 roubles.
The second test only has three pieces of clothing as well, yet Gerald can't buy them because the first piece of clothing does not match the third one. Thus, there are no three matching pieces of clothing. The answer is -1.
In the third example there are 4 pieces of clothing, but Gerald can't buy any 3 of them simultaneously. The answer is -1.
Submitted Solution:
```
n, m = map(int, input().split())
c = [0] + list(map(int, input().split()))
p = [[] for i in range(n + 1)]
for i in range(m):
a, b = map(int, input().split())
p[a].append(b)
p[b].append(a)
p = [(c[i], set(q)) for i, q in enumerate(p)]
s = 3000001
for i in range(1, n - 1):
if 3 * p[i][0] >= s: break
for j in range(i + 1, n):
if p[i][0] + 2 * p[j][0] >= s: break
if not j in p[i][1]: continue
for k in range(j + 1, n + 1):
if p[i][0] + p[j][0] + p[k][0] >= s: break
if k in p[i][1] and k in p[j][1]:
s = p[i][0] + p[j][0] + p[k][0]
break
print(s if s < 3000001 else -1)
```
No
| 15,089 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya came up with a password to register for EatForces — a string s. The password in EatForces should be a string, consisting of lowercase and uppercase Latin letters and digits.
But since EatForces takes care of the security of its users, user passwords must contain at least one digit, at least one uppercase Latin letter and at least one lowercase Latin letter. For example, the passwords "abaCABA12", "Z7q" and "3R24m" are valid, and the passwords "qwerty", "qwerty12345" and "Password" are not.
A substring of string s is a string x = s_l s_{l + 1} ... s_{l + len - 1} (1 ≤ l ≤ |s|, 0 ≤ len ≤ |s| - l + 1). len is the length of the substring. Note that the empty string is also considered a substring of s, it has the length 0.
Vasya's password, however, may come too weak for the security settings of EatForces. He likes his password, so he wants to replace some its substring with another string of the same length in order to satisfy the above conditions. This operation should be performed exactly once, and the chosen string should have the minimal possible length.
Note that the length of s should not change after the replacement of the substring, and the string itself should contain only lowercase and uppercase Latin letters and digits.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of testcases.
Each of the next T lines contains the initial password s~(3 ≤ |s| ≤ 100), consisting of lowercase and uppercase Latin letters and digits.
Only T = 1 is allowed for hacks.
Output
For each testcase print a renewed password, which corresponds to given conditions.
The length of the replaced substring is calculated as following: write down all the changed positions. If there are none, then the length is 0. Otherwise the length is the difference between the first and the last changed position plus one. For example, the length of the changed substring between the passwords "abcdef" → "a7cdEf" is 4, because the changed positions are 2 and 5, thus (5 - 2) + 1 = 4.
It is guaranteed that such a password always exists.
If there are several suitable passwords — output any of them.
Example
Input
2
abcDCE
htQw27
Output
abcD4E
htQw27
Note
In the first example Vasya's password lacks a digit, he replaces substring "C" with "4" and gets password "abcD4E". That means, he changed the substring of length 1.
In the second example Vasya's password is ok from the beginning, and nothing has to be changed. That is the same as replacing the empty substring with another empty substring (length 0).
Tags: greedy, implementation, strings
Correct Solution:
```
from sys import stdin
input = stdin.readline
def is_good(arr):
digit = False
upper = False
lower = False
for c in arr:
if c.isdigit():
digit = True
elif c.isupper():
upper = True
else:
lower = True
return (digit and upper and lower)
def solve():
s = list(input().rstrip())
# length 0
if is_good(s):
print(*s, sep="")
return
# length 1
for i in range(len(s)):
x = s[i]
s[i] = "1"
if is_good(s):
print(*s, sep="")
return
s[i] = "a"
if is_good(s):
print(*s, sep="")
return
s[i] = "A"
if is_good(s):
print(*s, sep="")
return
s[i] = x
# length 2
for i in range(len(s)-1):
x = s[i]
y = s[i+1]
s[i] = "1"
s[i+1] = "a"
if is_good(s):
print(*s, sep="")
return
s[i] = "1"
s[i+1] = "A"
if is_good(s):
print(*s, sep="")
return
s[i] = "a"
s[i+1] = "A"
if is_good(s):
print(*s, sep="")
return
s[i] = x
s[i+1] = y
t = int(input())
for _ in range(t):
solve()
```
| 15,090 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya came up with a password to register for EatForces — a string s. The password in EatForces should be a string, consisting of lowercase and uppercase Latin letters and digits.
But since EatForces takes care of the security of its users, user passwords must contain at least one digit, at least one uppercase Latin letter and at least one lowercase Latin letter. For example, the passwords "abaCABA12", "Z7q" and "3R24m" are valid, and the passwords "qwerty", "qwerty12345" and "Password" are not.
A substring of string s is a string x = s_l s_{l + 1} ... s_{l + len - 1} (1 ≤ l ≤ |s|, 0 ≤ len ≤ |s| - l + 1). len is the length of the substring. Note that the empty string is also considered a substring of s, it has the length 0.
Vasya's password, however, may come too weak for the security settings of EatForces. He likes his password, so he wants to replace some its substring with another string of the same length in order to satisfy the above conditions. This operation should be performed exactly once, and the chosen string should have the minimal possible length.
Note that the length of s should not change after the replacement of the substring, and the string itself should contain only lowercase and uppercase Latin letters and digits.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of testcases.
Each of the next T lines contains the initial password s~(3 ≤ |s| ≤ 100), consisting of lowercase and uppercase Latin letters and digits.
Only T = 1 is allowed for hacks.
Output
For each testcase print a renewed password, which corresponds to given conditions.
The length of the replaced substring is calculated as following: write down all the changed positions. If there are none, then the length is 0. Otherwise the length is the difference between the first and the last changed position plus one. For example, the length of the changed substring between the passwords "abcdef" → "a7cdEf" is 4, because the changed positions are 2 and 5, thus (5 - 2) + 1 = 4.
It is guaranteed that such a password always exists.
If there are several suitable passwords — output any of them.
Example
Input
2
abcDCE
htQw27
Output
abcD4E
htQw27
Note
In the first example Vasya's password lacks a digit, he replaces substring "C" with "4" and gets password "abcD4E". That means, he changed the substring of length 1.
In the second example Vasya's password is ok from the beginning, and nothing has to be changed. That is the same as replacing the empty substring with another empty substring (length 0).
Tags: greedy, implementation, strings
Correct Solution:
```
n = int(input())
abc = 'qwertyuiopasdfghjklzxcvbnm'
ABC = 'QWERTYUIOPASDFGHJKLZXCVBNM'
nu = '0123456789'
d = []
for i in range(n):
coa = 0
coA = 0
co1 = 0
s = input()
for j in range(len(s)):
if s[j] in abc:
coa += 1
continue
elif s[j] in ABC:
coA += 1
continue
elif s[j] in nu:
co1 += 1
d.append(([coa, coA, co1], s))
for i in range(n):
x = d[i][0]
s = d[i][1]
for j in range(len(s)):
if x[0] == 0:
if x[1] - 1 >= 1:
if s[j] in ABC:
if j + 1 < len(s):
s = s[:j] + 'a' + s[j + 1:]
else:
s = s[:j] + 'a'
x[0] += 1
x[1] -= 1
elif x[2] - 1 >= 1:
if s[j] in nu:
if j + 1 < len(s):
s = s[:j] + 'a' + s[j + 1:]
else:
s = s[:j] + 'a'
x[2] -= 1
x[0] += 1
elif x[1] == 0:
if x[0] - 1 >= 1:
if s[j] in abc:
if j + 1 < len(s):
s = s[:j] + 'A' + s[j + 1:]
else:
s = s[:j] + 'A'
x[0] -= 1
x[1] += 1
elif x[2] - 1 >= 1:
if s[j] in nu:
if j + 1 < len(s):
s = s[:j] + 'A' + s[j + 1:]
else:
s = s[:j] + 'A'
x[2] -= 1
x[1] += 1
elif x[2] == 0:
if x[1] - 1 >= 1:
if s[j] in ABC:
if j + 1 < len(s):
s = s[:j] + '1' + s[j + 1:]
else:
s = s[:j] + '1'
x[1] -= 1
x[2] += 1
elif x[0] - 1 >= 1:
if s[j] in abc:
if j + 1 < len(s):
s = s[:j] + '1' + s[j + 1:]
else:
s = s[:j] + '1'
x[0] -= 1
x[2] += 1
print(s)
```
| 15,091 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya came up with a password to register for EatForces — a string s. The password in EatForces should be a string, consisting of lowercase and uppercase Latin letters and digits.
But since EatForces takes care of the security of its users, user passwords must contain at least one digit, at least one uppercase Latin letter and at least one lowercase Latin letter. For example, the passwords "abaCABA12", "Z7q" and "3R24m" are valid, and the passwords "qwerty", "qwerty12345" and "Password" are not.
A substring of string s is a string x = s_l s_{l + 1} ... s_{l + len - 1} (1 ≤ l ≤ |s|, 0 ≤ len ≤ |s| - l + 1). len is the length of the substring. Note that the empty string is also considered a substring of s, it has the length 0.
Vasya's password, however, may come too weak for the security settings of EatForces. He likes his password, so he wants to replace some its substring with another string of the same length in order to satisfy the above conditions. This operation should be performed exactly once, and the chosen string should have the minimal possible length.
Note that the length of s should not change after the replacement of the substring, and the string itself should contain only lowercase and uppercase Latin letters and digits.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of testcases.
Each of the next T lines contains the initial password s~(3 ≤ |s| ≤ 100), consisting of lowercase and uppercase Latin letters and digits.
Only T = 1 is allowed for hacks.
Output
For each testcase print a renewed password, which corresponds to given conditions.
The length of the replaced substring is calculated as following: write down all the changed positions. If there are none, then the length is 0. Otherwise the length is the difference between the first and the last changed position plus one. For example, the length of the changed substring between the passwords "abcdef" → "a7cdEf" is 4, because the changed positions are 2 and 5, thus (5 - 2) + 1 = 4.
It is guaranteed that such a password always exists.
If there are several suitable passwords — output any of them.
Example
Input
2
abcDCE
htQw27
Output
abcD4E
htQw27
Note
In the first example Vasya's password lacks a digit, he replaces substring "C" with "4" and gets password "abcD4E". That means, he changed the substring of length 1.
In the second example Vasya's password is ok from the beginning, and nothing has to be changed. That is the same as replacing the empty substring with another empty substring (length 0).
Tags: greedy, implementation, strings
Correct Solution:
```
def check_pass(password):
upper = False
num = False
lower = False
for ch in password:
if(ord(ch) >= 97 and ord(ch) <= 122):
lower = True
elif(ord(ch) >= 65 and ord(ch) <= 90):
upper = True
elif(int(ch) >= 0 and int(ch) <= 9):
num = True
return {'_acceptable': (upper & lower & num),'upper':upper, 'lower':lower, 'num':num}
def change_char(password, index, conditions):
new_password = list(password)
if(not conditions['upper']):
new_password[index] = 'A'
elif(not conditions['lower']):
new_password[index] = 'a'
elif(not conditions['num']):
new_password[index] = '4'
new_password = "".join(new_password)
obj = check_pass(new_password)
if(not obj['_acceptable']):
if(conditions['upper']):
if(not obj['upper']):
return password
if(conditions['lower']):
if(not obj['lower']):
return password
if(conditions['num']):
if(not obj['num']):
return password
return new_password
# Main Program
n = int(input())
passwords = []
for i in range(n):
passwords.append(input())
for password in passwords:
if(not check_pass(password)['_acceptable']):
index = 0
temp = password
while(not check_pass(password)['_acceptable']):
password = change_char(password, index, check_pass(password))
index += 1
print(password)
```
| 15,092 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya came up with a password to register for EatForces — a string s. The password in EatForces should be a string, consisting of lowercase and uppercase Latin letters and digits.
But since EatForces takes care of the security of its users, user passwords must contain at least one digit, at least one uppercase Latin letter and at least one lowercase Latin letter. For example, the passwords "abaCABA12", "Z7q" and "3R24m" are valid, and the passwords "qwerty", "qwerty12345" and "Password" are not.
A substring of string s is a string x = s_l s_{l + 1} ... s_{l + len - 1} (1 ≤ l ≤ |s|, 0 ≤ len ≤ |s| - l + 1). len is the length of the substring. Note that the empty string is also considered a substring of s, it has the length 0.
Vasya's password, however, may come too weak for the security settings of EatForces. He likes his password, so he wants to replace some its substring with another string of the same length in order to satisfy the above conditions. This operation should be performed exactly once, and the chosen string should have the minimal possible length.
Note that the length of s should not change after the replacement of the substring, and the string itself should contain only lowercase and uppercase Latin letters and digits.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of testcases.
Each of the next T lines contains the initial password s~(3 ≤ |s| ≤ 100), consisting of lowercase and uppercase Latin letters and digits.
Only T = 1 is allowed for hacks.
Output
For each testcase print a renewed password, which corresponds to given conditions.
The length of the replaced substring is calculated as following: write down all the changed positions. If there are none, then the length is 0. Otherwise the length is the difference between the first and the last changed position plus one. For example, the length of the changed substring between the passwords "abcdef" → "a7cdEf" is 4, because the changed positions are 2 and 5, thus (5 - 2) + 1 = 4.
It is guaranteed that such a password always exists.
If there are several suitable passwords — output any of them.
Example
Input
2
abcDCE
htQw27
Output
abcD4E
htQw27
Note
In the first example Vasya's password lacks a digit, he replaces substring "C" with "4" and gets password "abcD4E". That means, he changed the substring of length 1.
In the second example Vasya's password is ok from the beginning, and nothing has to be changed. That is the same as replacing the empty substring with another empty substring (length 0).
Tags: greedy, implementation, strings
Correct Solution:
```
t = int(input())
for _ in range(t):
s = str(input())
l = []
u = []
d = []
for i, c in enumerate(s):
if c.islower():
l.append(i)
elif c.isupper():
u.append(i)
else:
d.append(i)
s = list(s)
if l and u and d:
pass
elif not l and u and d:
if len(u) > len(d):
s[u[0]] = 'a'
else:
s[d[0]] = 'a'
elif l and not u and d:
if len(l) > len(d):
s[l[0]] = 'A'
else:
s[d[0]] = 'A'
elif l and u and not d:
if len(l) > len(u):
s[l[0]] = '1'
else:
s[u[0]] = '1'
elif l and not u and not d:
s[l[0]] = 'A'
s[l[1]] = '1'
elif not l and u and not d:
s[u[0]] = 'a'
s[u[1]] = '1'
elif not l and not u and d:
s[d[0]] = 'a'
s[d[1]] = 'A'
print(''.join(s))
```
| 15,093 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya came up with a password to register for EatForces — a string s. The password in EatForces should be a string, consisting of lowercase and uppercase Latin letters and digits.
But since EatForces takes care of the security of its users, user passwords must contain at least one digit, at least one uppercase Latin letter and at least one lowercase Latin letter. For example, the passwords "abaCABA12", "Z7q" and "3R24m" are valid, and the passwords "qwerty", "qwerty12345" and "Password" are not.
A substring of string s is a string x = s_l s_{l + 1} ... s_{l + len - 1} (1 ≤ l ≤ |s|, 0 ≤ len ≤ |s| - l + 1). len is the length of the substring. Note that the empty string is also considered a substring of s, it has the length 0.
Vasya's password, however, may come too weak for the security settings of EatForces. He likes his password, so he wants to replace some its substring with another string of the same length in order to satisfy the above conditions. This operation should be performed exactly once, and the chosen string should have the minimal possible length.
Note that the length of s should not change after the replacement of the substring, and the string itself should contain only lowercase and uppercase Latin letters and digits.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of testcases.
Each of the next T lines contains the initial password s~(3 ≤ |s| ≤ 100), consisting of lowercase and uppercase Latin letters and digits.
Only T = 1 is allowed for hacks.
Output
For each testcase print a renewed password, which corresponds to given conditions.
The length of the replaced substring is calculated as following: write down all the changed positions. If there are none, then the length is 0. Otherwise the length is the difference between the first and the last changed position plus one. For example, the length of the changed substring between the passwords "abcdef" → "a7cdEf" is 4, because the changed positions are 2 and 5, thus (5 - 2) + 1 = 4.
It is guaranteed that such a password always exists.
If there are several suitable passwords — output any of them.
Example
Input
2
abcDCE
htQw27
Output
abcD4E
htQw27
Note
In the first example Vasya's password lacks a digit, he replaces substring "C" with "4" and gets password "abcD4E". That means, he changed the substring of length 1.
In the second example Vasya's password is ok from the beginning, and nothing has to be changed. That is the same as replacing the empty substring with another empty substring (length 0).
Tags: greedy, implementation, strings
Correct Solution:
```
for _ in range(int(input())):
C, s = {'0':0, 'A':0, 'a':0}, input()
first = '0' if s[0].isdigit() else 'A' if s[0].isupper() else 'a'
last = '0' if s[-1].isdigit() else 'A' if s[-1].isupper() else 'a'
for ch in s:
if ch.isdigit():
C['0'] += 1
elif ch.isupper():
C['A'] += 1
else:
C['a'] += 1
zeros = sum(not C[x] for x in '0Aa')
if zeros == 2:
print(''.join(set('0Aa') - {first}) + s[2:])
elif zeros == 1:
if C[first] > 1:
print(''.join(x for x, c in C.items() if c == 0) + s[1:])
else:
print(s[:-1] + ''.join(x for x, c in C.items() if c == 0))
else:
print(s)
```
| 15,094 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya came up with a password to register for EatForces — a string s. The password in EatForces should be a string, consisting of lowercase and uppercase Latin letters and digits.
But since EatForces takes care of the security of its users, user passwords must contain at least one digit, at least one uppercase Latin letter and at least one lowercase Latin letter. For example, the passwords "abaCABA12", "Z7q" and "3R24m" are valid, and the passwords "qwerty", "qwerty12345" and "Password" are not.
A substring of string s is a string x = s_l s_{l + 1} ... s_{l + len - 1} (1 ≤ l ≤ |s|, 0 ≤ len ≤ |s| - l + 1). len is the length of the substring. Note that the empty string is also considered a substring of s, it has the length 0.
Vasya's password, however, may come too weak for the security settings of EatForces. He likes his password, so he wants to replace some its substring with another string of the same length in order to satisfy the above conditions. This operation should be performed exactly once, and the chosen string should have the minimal possible length.
Note that the length of s should not change after the replacement of the substring, and the string itself should contain only lowercase and uppercase Latin letters and digits.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of testcases.
Each of the next T lines contains the initial password s~(3 ≤ |s| ≤ 100), consisting of lowercase and uppercase Latin letters and digits.
Only T = 1 is allowed for hacks.
Output
For each testcase print a renewed password, which corresponds to given conditions.
The length of the replaced substring is calculated as following: write down all the changed positions. If there are none, then the length is 0. Otherwise the length is the difference between the first and the last changed position plus one. For example, the length of the changed substring between the passwords "abcdef" → "a7cdEf" is 4, because the changed positions are 2 and 5, thus (5 - 2) + 1 = 4.
It is guaranteed that such a password always exists.
If there are several suitable passwords — output any of them.
Example
Input
2
abcDCE
htQw27
Output
abcD4E
htQw27
Note
In the first example Vasya's password lacks a digit, he replaces substring "C" with "4" and gets password "abcD4E". That means, he changed the substring of length 1.
In the second example Vasya's password is ok from the beginning, and nothing has to be changed. That is the same as replacing the empty substring with another empty substring (length 0).
Tags: greedy, implementation, strings
Correct Solution:
```
for _ in range(int(input())):
s=input()
counta=0
countA=0
count1=0
for j in range(len(s)):
if ord('a')<=ord(s[j])<=ord('z'):
counta+=1
elif ord('A')<=ord(s[j])<=ord('Z'):
countA+=1
else:
count1+=1
k=0;l=0
if count1!=0 and counta!=0 and countA!=0:
print(s)
elif count1+counta+countA==count1:
s=s[:len(s)-1]+'a'
s=s[:len(s)-2]+'A'+s[-1]
print(s)
elif count1+counta+countA==count1:
s=s[:len(s)-1]+'a'
s=s[:len(s)-2]+'A'+s[-1]
print(s)
elif count1+counta+countA==counta:
s=s[:len(s)-1]+'1'
s=s[:len(s)-2]+'A'+s[-1]
print(s)
elif count1+counta+countA==countA:
s=s[:len(s)-1]+'1'
s=s[:len(s)-2]+'a'+s[-1]
print(s)
elif count1==0:
for i in range(len(s)):
if ord('a')<=ord(s[i])<=ord('z'):
k+=1
if ord('A')<=ord(s[i])<=ord('Z'):
l+=1
if k>1 or l>1:
s=s[:i]+'1'+s[i+1:]
print(s)
break
elif counta==0:
for i in range(len(s)):
if ord('0')<=ord(s[i])<=ord('9'):
k+=1
if ord('A')<=ord(s[i])<=ord('Z'):
l+=1
if k>1 or l>1:
s=s[:i]+'a'+s[i+1:]
print(s)
break
elif countA==0:
for i in range(len(s)):
if ord('a')<=ord(s[i])<=ord('z'):
k+=1
if ord('0')<=ord(s[i])<=ord('9'):
l+=1
if k>1 or l>1:
s=s[:i]+'A'+s[i+1:]
print(s)
break
```
| 15,095 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya came up with a password to register for EatForces — a string s. The password in EatForces should be a string, consisting of lowercase and uppercase Latin letters and digits.
But since EatForces takes care of the security of its users, user passwords must contain at least one digit, at least one uppercase Latin letter and at least one lowercase Latin letter. For example, the passwords "abaCABA12", "Z7q" and "3R24m" are valid, and the passwords "qwerty", "qwerty12345" and "Password" are not.
A substring of string s is a string x = s_l s_{l + 1} ... s_{l + len - 1} (1 ≤ l ≤ |s|, 0 ≤ len ≤ |s| - l + 1). len is the length of the substring. Note that the empty string is also considered a substring of s, it has the length 0.
Vasya's password, however, may come too weak for the security settings of EatForces. He likes his password, so he wants to replace some its substring with another string of the same length in order to satisfy the above conditions. This operation should be performed exactly once, and the chosen string should have the minimal possible length.
Note that the length of s should not change after the replacement of the substring, and the string itself should contain only lowercase and uppercase Latin letters and digits.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of testcases.
Each of the next T lines contains the initial password s~(3 ≤ |s| ≤ 100), consisting of lowercase and uppercase Latin letters and digits.
Only T = 1 is allowed for hacks.
Output
For each testcase print a renewed password, which corresponds to given conditions.
The length of the replaced substring is calculated as following: write down all the changed positions. If there are none, then the length is 0. Otherwise the length is the difference between the first and the last changed position plus one. For example, the length of the changed substring between the passwords "abcdef" → "a7cdEf" is 4, because the changed positions are 2 and 5, thus (5 - 2) + 1 = 4.
It is guaranteed that such a password always exists.
If there are several suitable passwords — output any of them.
Example
Input
2
abcDCE
htQw27
Output
abcD4E
htQw27
Note
In the first example Vasya's password lacks a digit, he replaces substring "C" with "4" and gets password "abcD4E". That means, he changed the substring of length 1.
In the second example Vasya's password is ok from the beginning, and nothing has to be changed. That is the same as replacing the empty substring with another empty substring (length 0).
Tags: greedy, implementation, strings
Correct Solution:
```
import string
(t,) = map(int, input().split())
def invalid(s):
minus = len(list(filter(lambda x: x in string.ascii_lowercase, s)))
mayus = len(list(filter(lambda x: x in string.ascii_uppercase, s)))
digits = len(list(filter(lambda x: x in string.digits, s)))
return any((minus == 0, mayus == 0, digits == 0))
def gen_str(s):
minus = len(list(filter(lambda x: x in string.ascii_lowercase, s)))
mayus = len(list(filter(lambda x: x in string.ascii_uppercase, s)))
digits = len(list(filter(lambda x: x in string.digits, s)))
result = ''
if minus == 0:
result += 'a'
if mayus == 0:
result += 'A'
if digits == 0:
result += '0'
return result
for _ in range(t):
s = input()
new_s = s
if invalid(s):
t = gen_str(s)
new_s = t + s[len(t):]
if invalid(new_s):
new_s = s[:-len(t)] + t
print(new_s)
```
| 15,096 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya came up with a password to register for EatForces — a string s. The password in EatForces should be a string, consisting of lowercase and uppercase Latin letters and digits.
But since EatForces takes care of the security of its users, user passwords must contain at least one digit, at least one uppercase Latin letter and at least one lowercase Latin letter. For example, the passwords "abaCABA12", "Z7q" and "3R24m" are valid, and the passwords "qwerty", "qwerty12345" and "Password" are not.
A substring of string s is a string x = s_l s_{l + 1} ... s_{l + len - 1} (1 ≤ l ≤ |s|, 0 ≤ len ≤ |s| - l + 1). len is the length of the substring. Note that the empty string is also considered a substring of s, it has the length 0.
Vasya's password, however, may come too weak for the security settings of EatForces. He likes his password, so he wants to replace some its substring with another string of the same length in order to satisfy the above conditions. This operation should be performed exactly once, and the chosen string should have the minimal possible length.
Note that the length of s should not change after the replacement of the substring, and the string itself should contain only lowercase and uppercase Latin letters and digits.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of testcases.
Each of the next T lines contains the initial password s~(3 ≤ |s| ≤ 100), consisting of lowercase and uppercase Latin letters and digits.
Only T = 1 is allowed for hacks.
Output
For each testcase print a renewed password, which corresponds to given conditions.
The length of the replaced substring is calculated as following: write down all the changed positions. If there are none, then the length is 0. Otherwise the length is the difference between the first and the last changed position plus one. For example, the length of the changed substring between the passwords "abcdef" → "a7cdEf" is 4, because the changed positions are 2 and 5, thus (5 - 2) + 1 = 4.
It is guaranteed that such a password always exists.
If there are several suitable passwords — output any of them.
Example
Input
2
abcDCE
htQw27
Output
abcD4E
htQw27
Note
In the first example Vasya's password lacks a digit, he replaces substring "C" with "4" and gets password "abcD4E". That means, he changed the substring of length 1.
In the second example Vasya's password is ok from the beginning, and nothing has to be changed. That is the same as replacing the empty substring with another empty substring (length 0).
Tags: greedy, implementation, strings
Correct Solution:
```
n = int(input())
B = [{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"},{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"} ,{"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"}]
for i in range(n):
s = input()
A = [0] * 3
for i in range(len(s)):
for j in range(3):
if s[i] in B[j]:
A[j] += 1
if A[0] != 0 and A[1] != 0 and A[2] != 0:
print(s)
else:
for j1 in range(3):
j2 = (j1 + 1) % 3
j3 = (j1 + 2) % 3
if A[j1] == 0 and A[j2] != 0 and A[j3] != 0:
if (s[0] in B[j2] and A[j2] > 1) or (s[0] in B[j3] and A[j3] > 1):
h = str(B[j1].pop())
B[j1].add(h)
print(h + s[1:])
break
else:
h = str(B[j1].pop())
B[j1].add(h)
print(s[0] + str(h) + s[2:])
break
elif A[j1] == 0:
h = str(B[j1].pop())
B[j1].add(h)
if A[j2] == 0:
h1 = str(B[j2].pop())
B[j2].add(h1)
print(h + h1 + s[2:])
break
else:
h1 = str(B[j3].pop())
B[j3].add(h1)
print(h + h1 + s[2:])
break
```
| 15,097 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya came up with a password to register for EatForces — a string s. The password in EatForces should be a string, consisting of lowercase and uppercase Latin letters and digits.
But since EatForces takes care of the security of its users, user passwords must contain at least one digit, at least one uppercase Latin letter and at least one lowercase Latin letter. For example, the passwords "abaCABA12", "Z7q" and "3R24m" are valid, and the passwords "qwerty", "qwerty12345" and "Password" are not.
A substring of string s is a string x = s_l s_{l + 1} ... s_{l + len - 1} (1 ≤ l ≤ |s|, 0 ≤ len ≤ |s| - l + 1). len is the length of the substring. Note that the empty string is also considered a substring of s, it has the length 0.
Vasya's password, however, may come too weak for the security settings of EatForces. He likes his password, so he wants to replace some its substring with another string of the same length in order to satisfy the above conditions. This operation should be performed exactly once, and the chosen string should have the minimal possible length.
Note that the length of s should not change after the replacement of the substring, and the string itself should contain only lowercase and uppercase Latin letters and digits.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of testcases.
Each of the next T lines contains the initial password s~(3 ≤ |s| ≤ 100), consisting of lowercase and uppercase Latin letters and digits.
Only T = 1 is allowed for hacks.
Output
For each testcase print a renewed password, which corresponds to given conditions.
The length of the replaced substring is calculated as following: write down all the changed positions. If there are none, then the length is 0. Otherwise the length is the difference between the first and the last changed position plus one. For example, the length of the changed substring between the passwords "abcdef" → "a7cdEf" is 4, because the changed positions are 2 and 5, thus (5 - 2) + 1 = 4.
It is guaranteed that such a password always exists.
If there are several suitable passwords — output any of them.
Example
Input
2
abcDCE
htQw27
Output
abcD4E
htQw27
Note
In the first example Vasya's password lacks a digit, he replaces substring "C" with "4" and gets password "abcD4E". That means, he changed the substring of length 1.
In the second example Vasya's password is ok from the beginning, and nothing has to be changed. That is the same as replacing the empty substring with another empty substring (length 0).
Submitted Solution:
```
import string
n = int(input())
def chr2id(c):
if c in string.ascii_uppercase:
return 1
if c in string.digits:
return 2
return 0
repl = ['a', 'A', '1']
for _ in range(n):
s = input()
arr = [0] * len(s)
chr_ids = [0] * len(s)
last_n = [0] * 3
id_counts = [0] * 3
last_id = chr2id(s[0])
id_counts[last_id] = 1
chr_ids[0] = last_id
for i, c in enumerate(s[1:]):
c_id = chr2id(c)
chr_ids[i+1] = c_id
id_counts[c_id] += 1
if last_id == c_id:
arr[i+1] = arr[i] + 1
if arr[i+1] < len(last_n):
last_n[arr[i+1]] = i + 1
else:
last_n.append(i+1)
last_id = c_id
change_count = sum(map(lambda x: x == 0, id_counts))
if change_count == 0:
print(s)
continue
l = change_count
while last_n[l] == 0 and l > 0:
l -= 1
i = last_n[l]
if l == 0:
left = 0
right = 0
for i, c in enumerate(chr_ids):
if chr_ids[left] == chr_ids[i] and id_counts[c] > change_count:
right = i
else:
left = right = i
if right - left >= change_count:
break
i = right
i += 1
c = 0
s = list(s)
for j in range(i - change_count, i):
while(id_counts[c] > 0):
c += 1
s[j] = repl[c]
c += 1
print(''.join(s))
```
Yes
| 15,098 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya came up with a password to register for EatForces — a string s. The password in EatForces should be a string, consisting of lowercase and uppercase Latin letters and digits.
But since EatForces takes care of the security of its users, user passwords must contain at least one digit, at least one uppercase Latin letter and at least one lowercase Latin letter. For example, the passwords "abaCABA12", "Z7q" and "3R24m" are valid, and the passwords "qwerty", "qwerty12345" and "Password" are not.
A substring of string s is a string x = s_l s_{l + 1} ... s_{l + len - 1} (1 ≤ l ≤ |s|, 0 ≤ len ≤ |s| - l + 1). len is the length of the substring. Note that the empty string is also considered a substring of s, it has the length 0.
Vasya's password, however, may come too weak for the security settings of EatForces. He likes his password, so he wants to replace some its substring with another string of the same length in order to satisfy the above conditions. This operation should be performed exactly once, and the chosen string should have the minimal possible length.
Note that the length of s should not change after the replacement of the substring, and the string itself should contain only lowercase and uppercase Latin letters and digits.
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of testcases.
Each of the next T lines contains the initial password s~(3 ≤ |s| ≤ 100), consisting of lowercase and uppercase Latin letters and digits.
Only T = 1 is allowed for hacks.
Output
For each testcase print a renewed password, which corresponds to given conditions.
The length of the replaced substring is calculated as following: write down all the changed positions. If there are none, then the length is 0. Otherwise the length is the difference between the first and the last changed position plus one. For example, the length of the changed substring between the passwords "abcdef" → "a7cdEf" is 4, because the changed positions are 2 and 5, thus (5 - 2) + 1 = 4.
It is guaranteed that such a password always exists.
If there are several suitable passwords — output any of them.
Example
Input
2
abcDCE
htQw27
Output
abcD4E
htQw27
Note
In the first example Vasya's password lacks a digit, he replaces substring "C" with "4" and gets password "abcD4E". That means, he changed the substring of length 1.
In the second example Vasya's password is ok from the beginning, and nothing has to be changed. That is the same as replacing the empty substring with another empty substring (length 0).
Submitted Solution:
```
from collections import defaultdict
t = []
for i in range(int(input())):
t.append(input())
v_const = {
'upper': 'A',
'lower': 'a',
'numbers': '1',
}
char_types = list(v_const.keys())
n_const = [str(i) for i in range(10)]
for p in t:
indexes = defaultdict(list)
for i, v in enumerate(p):
if v in n_const:
indexes['numbers'].append(i)
elif v.islower():
indexes['lower'].append(i)
else:
indexes['upper'].append(i)
missing_arrays = {key: None for key in char_types if key not in indexes}
keys = list(missing_arrays.keys())
if len(keys) == 0:
print(p)
elif len(keys) == 1:
for key, val in indexes.items():
if len(val) > 1:
missing_arrays[keys[0]] = val[0]
break
n_p = list(p)
n_p[missing_arrays[keys[0]]] = v_const[keys[0]]
print(''.join(n_p))
else:
n_p = list(p)
n_p[0] = v_const[keys[0]]
n_p[1] = v_const[keys[1]]
print(''.join(n_p))
```
Yes
| 15,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.