message stringlengths 2 22.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 16 109k | cluster float64 1 1 | __index_level_0__ int64 32 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in the country where the Old Peykan lives. These cities are located on a straight line, we'll denote them from left to right as c1, c2, ..., cn. The Old Peykan wants to travel from city c1 to cn using roads. There are (n - 1) one way roads, the i-th road goes from city ci to city ci + 1 and is di kilometers long.
The Old Peykan travels 1 kilometer in 1 hour and consumes 1 liter of fuel during this time.
Each city ci (except for the last city cn) has a supply of si liters of fuel which immediately transfers to the Old Peykan if it passes the city or stays in it. This supply refreshes instantly k hours after it transfers. The Old Peykan can stay in a city for a while and fill its fuel tank many times.
Initially (at time zero) the Old Peykan is at city c1 and s1 liters of fuel is transferred to it's empty tank from c1's supply. The Old Peykan's fuel tank capacity is unlimited. Old Peykan can not continue its travel if its tank is emptied strictly between two cities.
Find the minimum time the Old Peykan needs to reach city cn.
Input
The first line of the input contains two space-separated integers m and k (1 β€ m, k β€ 1000). The value m specifies the number of roads between cities which is equal to n - 1.
The next line contains m space-separated integers d1, d2, ..., dm (1 β€ di β€ 1000) and the following line contains m space-separated integers s1, s2, ..., sm (1 β€ si β€ 1000).
Output
In the only line of the output print a single integer β the minimum time required for The Old Peykan to reach city cn from city c1.
Examples
Input
4 6
1 2 5 2
2 3 3 4
Output
10
Input
2 3
5 6
5 5
Output
14
Note
In the second sample above, the Old Peykan stays in c1 for 3 hours.
Submitted Solution:
```
import sys
import math
n,k = sys.stdin.readline().split()
arr = sys.stdin.readline().split()
arr2 = sys.stdin.readline().split()
arr = [ int(x) for x in arr]
arr2 = [ int(x) for x in arr2]
n = int(n)
k = int(k)
res = sum(arr)
for i in range(n):
if arr[i] > arr2[i]:
res += math.ceil(arr[i] / arr[i])
print(res)
``` | instruction | 0 | 19,719 | 1 | 39,438 |
No | output | 1 | 19,719 | 1 | 39,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in the country where the Old Peykan lives. These cities are located on a straight line, we'll denote them from left to right as c1, c2, ..., cn. The Old Peykan wants to travel from city c1 to cn using roads. There are (n - 1) one way roads, the i-th road goes from city ci to city ci + 1 and is di kilometers long.
The Old Peykan travels 1 kilometer in 1 hour and consumes 1 liter of fuel during this time.
Each city ci (except for the last city cn) has a supply of si liters of fuel which immediately transfers to the Old Peykan if it passes the city or stays in it. This supply refreshes instantly k hours after it transfers. The Old Peykan can stay in a city for a while and fill its fuel tank many times.
Initially (at time zero) the Old Peykan is at city c1 and s1 liters of fuel is transferred to it's empty tank from c1's supply. The Old Peykan's fuel tank capacity is unlimited. Old Peykan can not continue its travel if its tank is emptied strictly between two cities.
Find the minimum time the Old Peykan needs to reach city cn.
Input
The first line of the input contains two space-separated integers m and k (1 β€ m, k β€ 1000). The value m specifies the number of roads between cities which is equal to n - 1.
The next line contains m space-separated integers d1, d2, ..., dm (1 β€ di β€ 1000) and the following line contains m space-separated integers s1, s2, ..., sm (1 β€ si β€ 1000).
Output
In the only line of the output print a single integer β the minimum time required for The Old Peykan to reach city cn from city c1.
Examples
Input
4 6
1 2 5 2
2 3 3 4
Output
10
Input
2 3
5 6
5 5
Output
14
Note
In the second sample above, the Old Peykan stays in c1 for 3 hours.
Submitted Solution:
```
estradas,k = [int(i) for i in input().split()]
d = [int(i) for i in input().split()]
s = [int(i) for i in input().split()]
gas = s[0]
fuel = 0
time = 0
for i in range(estradas):
fuel+=s[i]
while(fuel<d[i]):
time+=k
if(s[i]>gas):
gas = s[i]
fuel+=gas
fuel-=d[i]
time+=d[i]
print(time)
``` | instruction | 0 | 19,720 | 1 | 39,440 |
No | output | 1 | 19,720 | 1 | 39,441 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub got lost in a very big desert. The desert can be represented as a n Γ n square matrix, where each cell is a zone of the desert. The cell (i, j) represents the cell at row i and column j (1 β€ i, j β€ n). Iahub can go from one cell (i, j) only down or right, that is to cells (i + 1, j) or (i, j + 1).
Also, there are m cells that are occupied by volcanoes, which Iahub cannot enter.
Iahub is initially at cell (1, 1) and he needs to travel to cell (n, n). Knowing that Iahub needs 1 second to travel from one cell to another, find the minimum time in which he can arrive in cell (n, n).
Input
The first line contains two integers n (1 β€ n β€ 109) and m (1 β€ m β€ 105). Each of the next m lines contains a pair of integers, x and y (1 β€ x, y β€ n), representing the coordinates of the volcanoes.
Consider matrix rows are numbered from 1 to n from top to bottom, and matrix columns are numbered from 1 to n from left to right. There is no volcano in cell (1, 1). No two volcanoes occupy the same location.
Output
Print one integer, the minimum time in which Iahub can arrive at cell (n, n). If no solution exists (there is no path to the final cell), print -1.
Examples
Input
4 2
1 3
1 4
Output
6
Input
7 8
1 6
2 6
3 5
3 6
4 3
5 1
5 2
5 3
Output
12
Input
2 2
1 2
2 1
Output
-1
Note
Consider the first sample. A possible road is: (1, 1) β (1, 2) β (2, 2) β (2, 3) β (3, 3) β (3, 4) β (4, 4). | instruction | 0 | 19,751 | 1 | 39,502 |
Tags: binary search, implementation, sortings, two pointers
Correct Solution:
```
__author__ = 'Pavel Mavrin'
n, m = [int(x) for x in input().split()]
a = []
for i in range(m):
a.append([int(x) - 1 for x in input().split()])
a.sort(key=lambda x: x[0] * n + x[1])
a.append([n - 1, n])
d = [[0, 1]]
r = 0
i = 0
while i < len(a):
if a[i][0] == r:
dd = []
j = 0
while i < len(a) and a[i][0] == r and j < len(d):
if a[i][1] < d[j][0]:
i += 1
elif a[i][1] == d[j][0]:
d[j][0] += 1
if d[j][0] >= d[j][1]:
j += 1
i += 1
else:
dd.append([d[j][0], a[i][1]])
d[j][0] = a[i][1] + 1
while j < len(d) and d[j][1] <= a[i][1] + 1:
j += 1
if j < len(d):
d[j][0] = max(d[j][0], a[i][1] + 1)
if j < len(d):
dd.append([d[j][0], n])
while i < len(a) and (a[i][0] == r):
i += 1
d = dd
r += 1
if len(d) == 0:
break
else:
r = a[i][0]
d = [[d[0][0], n]]
#print(r, i, d)
if len(d) == 0 or d[len(d) - 1][1] < n:
print(-1)
else:
print(2 * (n - 1))
``` | output | 1 | 19,751 | 1 | 39,503 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub got lost in a very big desert. The desert can be represented as a n Γ n square matrix, where each cell is a zone of the desert. The cell (i, j) represents the cell at row i and column j (1 β€ i, j β€ n). Iahub can go from one cell (i, j) only down or right, that is to cells (i + 1, j) or (i, j + 1).
Also, there are m cells that are occupied by volcanoes, which Iahub cannot enter.
Iahub is initially at cell (1, 1) and he needs to travel to cell (n, n). Knowing that Iahub needs 1 second to travel from one cell to another, find the minimum time in which he can arrive in cell (n, n).
Input
The first line contains two integers n (1 β€ n β€ 109) and m (1 β€ m β€ 105). Each of the next m lines contains a pair of integers, x and y (1 β€ x, y β€ n), representing the coordinates of the volcanoes.
Consider matrix rows are numbered from 1 to n from top to bottom, and matrix columns are numbered from 1 to n from left to right. There is no volcano in cell (1, 1). No two volcanoes occupy the same location.
Output
Print one integer, the minimum time in which Iahub can arrive at cell (n, n). If no solution exists (there is no path to the final cell), print -1.
Examples
Input
4 2
1 3
1 4
Output
6
Input
7 8
1 6
2 6
3 5
3 6
4 3
5 1
5 2
5 3
Output
12
Input
2 2
1 2
2 1
Output
-1
Note
Consider the first sample. A possible road is: (1, 1) β (1, 2) β (2, 2) β (2, 3) β (3, 3) β (3, 4) β (4, 4). | instruction | 0 | 19,752 | 1 | 39,504 |
Tags: binary search, implementation, sortings, two pointers
Correct Solution:
```
from collections import defaultdict
def f(u, v):
s, l = [], len(v)
i = j = 0
for i in range(len(u)):
while v[j][1] <= u[i][0]:
j += 1
if j == l: return s
if u[i][1] <= v[j][0]: continue
if u[i][0] >= v[j][0]: s.append(u[i])
else: s.append((v[j][0], u[i][1]))
return s
n, m = map(int, input().split())
p = defaultdict(list)
for i in range(m):
x, y = map(int, input().split())
p[x].append(y)
for x in p:
if len(p[x]) > 1: p[x].sort()
t, i = [], 1
for j in p[x]:
if i != j: t.append((i, j))
i = j + 1
if i != n + 1: t.append((i, n + 1))
p[x] = t
k, s = 1, [(1, 2)]
for x in sorted(p.keys()):
if x == k: s = f(p[x], s)
else: s = f(p[x], [(s[0][0], n + 1)])
if not s: break
k = x + 1
if s and k == n + 1 and s[-1][1] != k: s = []
print(2 * (n - 1) if s else -1)
``` | output | 1 | 19,752 | 1 | 39,505 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iahub got lost in a very big desert. The desert can be represented as a n Γ n square matrix, where each cell is a zone of the desert. The cell (i, j) represents the cell at row i and column j (1 β€ i, j β€ n). Iahub can go from one cell (i, j) only down or right, that is to cells (i + 1, j) or (i, j + 1).
Also, there are m cells that are occupied by volcanoes, which Iahub cannot enter.
Iahub is initially at cell (1, 1) and he needs to travel to cell (n, n). Knowing that Iahub needs 1 second to travel from one cell to another, find the minimum time in which he can arrive in cell (n, n).
Input
The first line contains two integers n (1 β€ n β€ 109) and m (1 β€ m β€ 105). Each of the next m lines contains a pair of integers, x and y (1 β€ x, y β€ n), representing the coordinates of the volcanoes.
Consider matrix rows are numbered from 1 to n from top to bottom, and matrix columns are numbered from 1 to n from left to right. There is no volcano in cell (1, 1). No two volcanoes occupy the same location.
Output
Print one integer, the minimum time in which Iahub can arrive at cell (n, n). If no solution exists (there is no path to the final cell), print -1.
Examples
Input
4 2
1 3
1 4
Output
6
Input
7 8
1 6
2 6
3 5
3 6
4 3
5 1
5 2
5 3
Output
12
Input
2 2
1 2
2 1
Output
-1
Note
Consider the first sample. A possible road is: (1, 1) β (1, 2) β (2, 2) β (2, 3) β (3, 3) β (3, 4) β (4, 4).
Submitted Solution:
```
__author__ = 'Pavel Mavrin'
n, m = [int(x) for x in input().split()]
a = []
for i in range(m):
a.append([int(x) - 1 for x in input().split()])
a.sort(key=lambda x: x[0] * n + x[1])
a.append([n - 1, n])
d = [[0, 1]]
r = 0
i = 0
while i < len(a):
if a[i][0] == r:
dd = []
j = 0
while i < len(a) and a[i][0] == r and j < len(d):
if a[i][1] < d[j][0]:
i += 1
elif a[i][1] == d[j][0]:
d[j][0] += 1
if d[j][0] >= d[j][1]:
j += 1
i += 1
else:
dd.append([d[j][0], a[i][1]])
d[j][0] = a[i][1] + 1
while j < len(d) and d[j][1] <= a[i][1] + 1:
j += 1
i += 1
if j < len(d):
dd.append([d[j][0], n])
while i < len(a) and (a[i][0] == r):
i += 1
d = dd
r += 1
if len(d) == 0:
break
else:
r = a[i][0]
d = [[d[0][0], n]]
#print(r, i, d)
if len(d) == 0 or d[len(d) - 1][1] < n - 1:
print(-1)
else:
print(2 * (n - 1))
``` | instruction | 0 | 19,753 | 1 | 39,506 |
No | output | 1 | 19,753 | 1 | 39,507 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iahub got lost in a very big desert. The desert can be represented as a n Γ n square matrix, where each cell is a zone of the desert. The cell (i, j) represents the cell at row i and column j (1 β€ i, j β€ n). Iahub can go from one cell (i, j) only down or right, that is to cells (i + 1, j) or (i, j + 1).
Also, there are m cells that are occupied by volcanoes, which Iahub cannot enter.
Iahub is initially at cell (1, 1) and he needs to travel to cell (n, n). Knowing that Iahub needs 1 second to travel from one cell to another, find the minimum time in which he can arrive in cell (n, n).
Input
The first line contains two integers n (1 β€ n β€ 109) and m (1 β€ m β€ 105). Each of the next m lines contains a pair of integers, x and y (1 β€ x, y β€ n), representing the coordinates of the volcanoes.
Consider matrix rows are numbered from 1 to n from top to bottom, and matrix columns are numbered from 1 to n from left to right. There is no volcano in cell (1, 1). No two volcanoes occupy the same location.
Output
Print one integer, the minimum time in which Iahub can arrive at cell (n, n). If no solution exists (there is no path to the final cell), print -1.
Examples
Input
4 2
1 3
1 4
Output
6
Input
7 8
1 6
2 6
3 5
3 6
4 3
5 1
5 2
5 3
Output
12
Input
2 2
1 2
2 1
Output
-1
Note
Consider the first sample. A possible road is: (1, 1) β (1, 2) β (2, 2) β (2, 3) β (3, 3) β (3, 4) β (4, 4).
Submitted Solution:
```
__author__ = 'Pavel Mavrin'
n, m = [int(x) for x in input().split()]
a = []
for i in range(m):
a.append([int(x) - 1 for x in input().split()])
a.sort(key=lambda x: x[0] * x[1])
a.append([n - 1, n])
d = [[0, 1]]
r = 0
i = 0
while i < len(a):
if a[i][0] == r:
dd = []
j = 0
while i < len(a) and a[i][0] == r and j < len(d):
if a[i][1] < d[j][0]:
i += 1
elif a[i][1] == d[j][0]:
d[j][0] += 1
if d[j][0] >= d[j][1]:
j += 1
i += 1
else:
dd.append([d[j][0], a[i][1]])
d[j][0] = a[i][1] + 1
while j < len(d) and d[j][1] <= a[i][1] + 1:
j += 1
i += 1
if j < len(d):
dd.append([d[j][0], n])
while i < len(a) and (a[i][0] == r):
i += 1
d = dd
r += 1
if len(d) == 0:
break
else:
r = a[i][0]
d = [[d[0][0], n]]
print(r, i, d)
if len(d) == 0 or d[len(d) - 1][1] < n - 1:
print(-1)
else:
print(2 * (n - 1))
``` | instruction | 0 | 19,754 | 1 | 39,508 |
No | output | 1 | 19,754 | 1 | 39,509 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iahub got lost in a very big desert. The desert can be represented as a n Γ n square matrix, where each cell is a zone of the desert. The cell (i, j) represents the cell at row i and column j (1 β€ i, j β€ n). Iahub can go from one cell (i, j) only down or right, that is to cells (i + 1, j) or (i, j + 1).
Also, there are m cells that are occupied by volcanoes, which Iahub cannot enter.
Iahub is initially at cell (1, 1) and he needs to travel to cell (n, n). Knowing that Iahub needs 1 second to travel from one cell to another, find the minimum time in which he can arrive in cell (n, n).
Input
The first line contains two integers n (1 β€ n β€ 109) and m (1 β€ m β€ 105). Each of the next m lines contains a pair of integers, x and y (1 β€ x, y β€ n), representing the coordinates of the volcanoes.
Consider matrix rows are numbered from 1 to n from top to bottom, and matrix columns are numbered from 1 to n from left to right. There is no volcano in cell (1, 1). No two volcanoes occupy the same location.
Output
Print one integer, the minimum time in which Iahub can arrive at cell (n, n). If no solution exists (there is no path to the final cell), print -1.
Examples
Input
4 2
1 3
1 4
Output
6
Input
7 8
1 6
2 6
3 5
3 6
4 3
5 1
5 2
5 3
Output
12
Input
2 2
1 2
2 1
Output
-1
Note
Consider the first sample. A possible road is: (1, 1) β (1, 2) β (2, 2) β (2, 3) β (3, 3) β (3, 4) β (4, 4).
Submitted Solution:
```
__author__ = 'Pavel Mavrin'
n, m = [int(x) for x in input().split()]
a = []
for i in range(m):
a.append([int(x) - 1 for x in input().split()])
a.sort(key=lambda x: x[0] * x[1])
a.append([n - 1, n])
d = [[0, 1]]
r = 0
i = 0
while i < len(a):
if a[i][0] == r:
dd = []
j = 0
while i < len(a) and a[i][0] == r and j < len(d):
if a[i][1] < d[j][0]:
i += 1
elif a[i][1] == d[j][0]:
d[j][0] += 1
if d[j][0] >= d[j][1]:
j += 1
else:
dd.append([d[j][0], a[i][1]])
d[j][0] = a[i][1] + 1
if d[j][0] >= d[j][1]:
j += 1
i += 1
if j < len(d):
dd.append([d[j][0], n])
while i < len(a) and (a[i][0] == r):
i += 1
d = dd
r += 1
if len(d) == 0:
break
else:
r = a[i][0]
d = [[d[0][0], n]]
# print(r, i, d)
if len(d) == 0 or d[len(d) - 1][1] < n - 1:
print(-1)
else:
print(2 * (n - 1))
``` | instruction | 0 | 19,755 | 1 | 39,510 |
No | output | 1 | 19,755 | 1 | 39,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iahub got lost in a very big desert. The desert can be represented as a n Γ n square matrix, where each cell is a zone of the desert. The cell (i, j) represents the cell at row i and column j (1 β€ i, j β€ n). Iahub can go from one cell (i, j) only down or right, that is to cells (i + 1, j) or (i, j + 1).
Also, there are m cells that are occupied by volcanoes, which Iahub cannot enter.
Iahub is initially at cell (1, 1) and he needs to travel to cell (n, n). Knowing that Iahub needs 1 second to travel from one cell to another, find the minimum time in which he can arrive in cell (n, n).
Input
The first line contains two integers n (1 β€ n β€ 109) and m (1 β€ m β€ 105). Each of the next m lines contains a pair of integers, x and y (1 β€ x, y β€ n), representing the coordinates of the volcanoes.
Consider matrix rows are numbered from 1 to n from top to bottom, and matrix columns are numbered from 1 to n from left to right. There is no volcano in cell (1, 1). No two volcanoes occupy the same location.
Output
Print one integer, the minimum time in which Iahub can arrive at cell (n, n). If no solution exists (there is no path to the final cell), print -1.
Examples
Input
4 2
1 3
1 4
Output
6
Input
7 8
1 6
2 6
3 5
3 6
4 3
5 1
5 2
5 3
Output
12
Input
2 2
1 2
2 1
Output
-1
Note
Consider the first sample. A possible road is: (1, 1) β (1, 2) β (2, 2) β (2, 3) β (3, 3) β (3, 4) β (4, 4).
Submitted Solution:
```
__author__ = 'Pavel Mavrin'
n, m = [int(x) for x in input().split()]
a = []
for i in range(m):
a.append([int(x) - 1 for x in input().split()])
a.sort(key=lambda x: x[0] * x[1])
d = [[0, 1]]
r = 0
i = 0
while i < len(a):
if a[i][0] == r:
dd = []
j = 0
while i < len(a) and a[i][0] == r and j < len(d):
if a[i][1] < d[j][0]:
i += 1
elif a[i][1] == d[j][0]:
d[j][0] += 1
if d[j][0] >= d[j][1]:
j += 1
else:
dd.append([d[j][0], a[i][0]])
d[j][0] = a[i][0] + 1
if d[j][0] >= d[j][1]:
j += 1
i += 1
if j < len(d):
dd.append([d[j][0], n])
d = dd
r += 1
if len(d) == 0:
break
else:
r = a[i][0]
d = [[d[0][0], n]]
# print(r, d)
if len(d) == 0:
print(-1)
else:
print(2 * (n - 1))
``` | instruction | 0 | 19,756 | 1 | 39,512 |
No | output | 1 | 19,756 | 1 | 39,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5 | instruction | 0 | 19,890 | 1 | 39,780 |
Tags: greedy, number theory, sortings
Correct Solution:
```
import math,sys,re,itertools,pprint,collections,copy
rs,ri,rai,raf=input,lambda:int(input()),lambda:list(map(int, input().split())),lambda:list(map(float, input().split()))
n, n1, n2 = rai()
a = rai()
a.sort(reverse=True)
if n1 < n2:
print(sum(a[:n1])/n1 + sum(a[n1:n1+n2])/n2)
else:
print(sum(a[:n2])/n2 + sum(a[n2:n2 + n1])/n1)
``` | output | 1 | 19,890 | 1 | 39,781 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5 | instruction | 0 | 19,891 | 1 | 39,782 |
Tags: greedy, number theory, sortings
Correct Solution:
```
from copy import *
n,n1,n2=map(int,input().split())
a=list(map(int,input().split()))
a=sorted(a)
if n>n1+n2:
a=a[n-n1-n2:len(a)]
if n2>n1:
n1,n2=n2,n1
b=a[:n1]
c=a[n1:n1+n2]
print(sum(b)/n1+sum(c)/n2)
``` | output | 1 | 19,891 | 1 | 39,783 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5 | instruction | 0 | 19,892 | 1 | 39,784 |
Tags: greedy, number theory, sortings
Correct Solution:
```
n, n1, n2 = (int(x) for x in input().split())
a = list(int(x) for x in input().split())
a = sorted(a, reverse=True)
if n1 < n2:
s = 0
for i in range(n1):
s += a[i]
d = 0
for j in range(n1,n1+n2):
d += a[j]
#print(s , d)
s /= n1
d /= n2
else:
s = 0
for i in range(n2):
s += a[i]
d = 0
for j in range(n2 , n1 + n2):
#print(a[i])
d += a[j]
#print(s , d)
s /= n2
d /= n1
print(s+d)
#print(a)
``` | output | 1 | 19,892 | 1 | 39,785 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5 | instruction | 0 | 19,893 | 1 | 39,786 |
Tags: greedy, number theory, sortings
Correct Solution:
```
n, n1, n2 = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
if n1 > n2:
n1, n2 = n2, n1
a.sort(reverse=True)
print((sum(a[:n1]) / n1) + (sum(a[n1:n1+n2])/n2))
``` | output | 1 | 19,893 | 1 | 39,787 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5 | instruction | 0 | 19,894 | 1 | 39,788 |
Tags: greedy, number theory, sortings
Correct Solution:
```
n, n1, n2 = map(int, input().split())
arr = [int(x) for x in input().split()]
arr.sort()
arr.reverse()
minimum = min(n1, n2)
maximum = max(n1, n2)
add = 0
add2 = 0
#print(arr)
for i in range(minimum):
add = add + arr[i]
ans1 = add / minimum
for j in range(minimum, minimum + maximum):
add2 += arr[j]
ans2 = add2 / maximum
print("{:.8f}".format(ans1 + ans2))
``` | output | 1 | 19,894 | 1 | 39,789 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5 | instruction | 0 | 19,895 | 1 | 39,790 |
Tags: greedy, number theory, sortings
Correct Solution:
```
def solve():
n,n1,n2=list(map(int,input().split()))
l=list(map(int,input().split()))
l.sort(reverse=True)
sum1,sum2,sum3,sum4=0,0,0,0
for i in range(0,n1):
sum1+=l[i]
for i in range(0,n2):
sum3+=l[i]
for i in range(n1,n1+n2):
sum2+=l[i]
for i in range(n2,n2+n1):
sum4+=l[i]
if(sum1/n1+sum2/n2<=sum3/n2+sum4/n1):
print('%.8f'%(sum3/n2+sum4/n1))
else:
print('%8f'%(sum1/n1+sum2/n2))
solve()
``` | output | 1 | 19,895 | 1 | 39,791 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5 | instruction | 0 | 19,896 | 1 | 39,792 |
Tags: greedy, number theory, sortings
Correct Solution:
```
n, n1, n2 = map(int, input().split())
xs = [int(x) for x in input().split()]
xs.sort()
minn = min(n1, n2)
maxn = max(n1, n2)
mean1 = 0
for i in range(minn):
mean1 += xs[len(xs) - i - 1]
mean1 /= minn
mean2 = 0
for i in range(maxn):
mean2 += xs[len(xs) - i - 1 - minn]
mean2 /= maxn
print (mean1 + mean2)
``` | output | 1 | 19,896 | 1 | 39,793 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5 | instruction | 0 | 19,897 | 1 | 39,794 |
Tags: greedy, number theory, sortings
Correct Solution:
```
n, n1, n2 = list(map(int,input().split(' ')))
l = sorted(list(map(int,input().split(' '))),reverse = 1)
l1 = []
l2 = []
if n2<n1:n1,n2 = n2,n1
curr = 1
l1 = l[:n1]
l2 = l[n1:n1 + n2]
print(sum(l1)/n1 + sum(l2)/n2)
``` | output | 1 | 19,897 | 1 | 39,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
Submitted Solution:
```
n = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
l.sort()
ind = 0
if n[1] <= n[2]:
ind = len(l) - n[1]
s1 = sum(l[ind:])/n[1]
s2 = sum(l[ind-n[2]:ind])/n[2]
print('%.8f' %(s1+s2))
else:
ind = len(l) - n[2]
s1 = sum(l[ind:])/n[2]
s2 = sum(l[ind-n[1]:ind])/n[1]
print('%.8f' %(s1+s2))
``` | instruction | 0 | 19,898 | 1 | 39,796 |
Yes | output | 1 | 19,898 | 1 | 39,797 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
Submitted Solution:
```
n,n1,n2=map(int ,input().split());
l=list(map(int,input().split()));
l.sort(reverse=True)
n1,n2=max(n1,n2),min(n1,n2);
s1=0
s2=0
for i in range(n2):
s1+=l[i]
for i in range(n2,n1+n2):
s2+=l[i]
print(s1/n2+s2/n1)
``` | instruction | 0 | 19,899 | 1 | 39,798 |
Yes | output | 1 | 19,899 | 1 | 39,799 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
Submitted Solution:
```
n, n1, n2=map(int, input().split())
a=sorted([int(x) for x in input().split()],reverse=True)
#print(a)
s1=0
s2=0
mn=min(n1,n2)
mx=max(n1,n2)
for i in range(mn):
#print(a[i])
s1+=a[i]
for i in range(mn,mx+mn):
#print(a[i])
s2+=a[i]
print(format(s1/mn+s2/mx,'.8f'))
``` | instruction | 0 | 19,900 | 1 | 39,800 |
Yes | output | 1 | 19,900 | 1 | 39,801 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
Submitted Solution:
```
n,k1,k2=map(int,input().split())
l=list(map(int,input().split()))
l.sort()
l.reverse()
if(k1>k2):
t=k1
k1=k2
k2=t
x=0
y=0
for i in range(0,k1+k2):
if i>=k1:
y+=l[i]
else :
x+=l[i]
x/=k1
y/=k2
print(x+y)
``` | instruction | 0 | 19,901 | 1 | 39,802 |
Yes | output | 1 | 19,901 | 1 | 39,803 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
Submitted Solution:
```
import sys
from os import path
if (path.exists('input.txt') and path.exists('output.txt')):
sys.stdout = open('output.txt', 'w')
sys.stdin = open('input.txt', 'r')
def main():
n, n1, n2 = (int(i) for i in input().split())
l = sorted([int(i) for i in input().split()], reverse=True)
if n1 > n2: n1, n2 = n2, n1
ans = sum(l[:n1]) / n1 + sum(l[n1:n2 + 1]) / n2
print(ans)
main()
``` | instruction | 0 | 19,902 | 1 | 39,804 |
No | output | 1 | 19,902 | 1 | 39,805 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
Submitted Solution:
```
n, n1, n2 = map(int, input().split())
arr = [int(x) for x in input().split()]
arr.sort()
arr.reverse()
minimum = min(n1, n2)
maximum = max(n1, n2)
add = 0
add2 = 0
#print(arr)
for i in range(minimum):
add = add + arr[i]
ans1 = add / minimum
for j in range(minimum, maximum + 1):
add2 += arr[j]
ans2 = add2 / maximum
print("{:.8f}".format(ans1 + ans2))
``` | instruction | 0 | 19,903 | 1 | 39,806 |
No | output | 1 | 19,903 | 1 | 39,807 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
Submitted Solution:
```
n, n1, n2 = map(int, input().split())
arr = [int(x) for x in input().split()]
arr.sort()
arr.reverse()
minimum = min(n1, n2)
maximum = max(n1, n2)
add = 0
add2 = 0
print(arr)
for i in range(minimum):
add = add + arr[i]
ans1 = add / minimum
for j in range(minimum, maximum + 1):
add2 += arr[j]
ans2 = add2 / maximum
print(ans1 + ans2)
``` | instruction | 0 | 19,904 | 1 | 39,808 |
No | output | 1 | 19,904 | 1 | 39,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
Input
The first line of the input contains three integers n, n1 and n2 (1 β€ n, n1, n2 β€ 100 000, n1 + n2 β€ n) β the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
Output
Print one real value β the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 1 1
1 5
Output
6.00000000
Input
4 2 1
1 4 2 3
Output
6.50000000
Note
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
Submitted Solution:
```
from sys import stdin
n,premier,second=map(int,input().split())
candidats=list(map(int,stdin.readline().split()))
candidats.sort(reverse=True)
if premier>second:
premier,second=second,premier
ville1=candidats[0]
candidat1=1
ville2=candidats[1]
candidat2=1
i=2
while premier+second>i:
richesse=candidats[i]
tot=ville1/candidat1+(ville2+richesse)/(candidat2+1)
tot2=(ville1+richesse)/(candidat1+1)+ville2/candidat2
if candidat1 < premier and tot2>tot:
candidat1+=1
ville1+=richesse
else:
candidat2+=1
ville2+=richesse
i+=1
print( (ville1/candidat1) + (ville2/candidat2) )
``` | instruction | 0 | 19,905 | 1 | 39,810 |
No | output | 1 | 19,905 | 1 | 39,811 |
Provide a correct Python 3 solution for this coding contest problem.
Training is indispensable for achieving good results at ICPC. Rabbit wants to win at ICPC, so he decided to practice today as well.
Today's training is to gain the power of business by running around the city and conducting trade.
I want to earn as much money as possible for future training.
In this world, roads in the north, south, east, and west directions are lined up at equal intervals, forming a grid pattern. The position of the only existing market is (0, 0), and the x-coordinate and y-coordinate are fixed in the city (points with integer coordinates correspond to intersections). Rabbits can only move along the road, and it takes one minute to move between adjacent intersections. There are towns at some intersections. In trade, you get the profit of the price difference by buying goods in the city and selling them in the market.
Rabbits have enough initial funds, and there is no such thing as being unable to purchase products due to lack of money. However, each product has a weight, and a rabbit can only carry products with a total weight of up to W at the same time. Therefore, it is necessary to repeatedly purchase products in the city and return to the market. In some cases, you may end up buying goods in multiple cities before returning to the market.
It is assumed that the purchase of products in the city and the sale of products in the market can be done in an instant. In addition, it is unlikely that the products in the city will be out of stock, and you can purchase them indefinitely.
For Usagi, the name of each product that we are going to buy and sell this time, the weight and selling price of each product, and the x-coordinate, y-coordinate and the name and price of the product for sale in each town are summarized in the data. The rabbit is now in the position of the market (0, 0). I want to find out how much I can earn during the time limit of T minutes using a program.
Input
N M W T
S1 V1 P1
...
SM VM PM
L1 X1 Y1
R1,1 Q1,1
...
R1, L1 Q1, L1
...
LN XN YN
RN, 1 QN, 1
...
RN, LN QN, LN
N is the number of towns and M is the number of product types. Si, Vi, and Pi (1 β€ i β€ M) are the name of the i-th product, the weight per product, and the selling price per product, respectively. A city is represented by an integer greater than or equal to 1 and less than or equal to N. Lj, Xj, and Yj (1 β€ j β€ N) are the number of types of goods sold in the city j, the x-coordinate of the city j, and the y-coordinate, respectively. Rj, k, Qj, k (1 β€ j β€ N, 1 β€ k β€ Lj) are the names and prices of the kth products sold in town j, respectively.
1 β€ N β€ 7, 1 β€ M β€ 7, 1 β€ W β€ 10,000, 1 β€ T β€ 10,000, 1 β€ Vi β€ W, 1 β€ Pi β€ 10,000, 1 β€ Lj β€ M, -10,000 β€ Xj β€ 10,000,- Satisfy 10,000 β€ Yj β€ 10,000, 1 β€ Qj, k β€ 10,000. The product name is a character string consisting of lowercase letters and having a length of 1 or more and 7 or less. All other values ββare integers. Si are all different. The same set as (Xj, Yj) does not appear multiple times, and (Xj, Yj) = (0, 0) does not hold. For each j, Rj and k are all different, and each Rj and k matches any Si.
Output
Output the maximum profit that the rabbit can get on one line.
Examples
Input
2 2 100 20
alfalfa 10 10
carrot 5 10
1 1 6
carrot 4
1 -3 0
alfalfa 5
Output
170
Input
2 3 100 20
vim 10 10
emacs 5 10
vstudio 65 100
2 1 6
emacs 4
vstudio 13
3 -3 0
vim 5
emacs 9
vstudio 62
Output
183 | instruction | 0 | 20,224 | 1 | 40,448 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N, M, W, T = map(int, readline().split())
cur = 0
n_map = {}
ws = [0]*M; P = [0]*M
for i in range(M):
s, v, p = readline().split()
n_map[s] = i
ws[i] = int(v)
P[i] = int(p)
ts = [[] for i in range(N)]
X = [0]*N; Y = [0]*N
for i in range(N):
l, x, y = map(int, readline().split())
X[i] = x; Y[i] = y
r = 0
t = ts[i]
for j in range(l):
r, q = readline().split(); q = int(q)
k = n_map[r]
if P[k] <= q:
continue
t.append((k, P[k] - q))
E = [[0]*N for i in range(N)]
E1 = [0]*N
for i in range(N):
for j in range(i):
E[i][j] = E[j][i] = abs(X[i] - X[j]) + abs(Y[i] - Y[j])
E1[i] = abs(X[i]) + abs(Y[i])
INF = 10**18
SN = 1 << N
D0 = [[0]*N for i in range(SN)]
dp1 = [0]*(T+1)
for s in range(1, SN):
d1 = INF
for i in range(N):
bi = (1 << i)
r = INF
if s & bi:
si = s ^ bi
if si == 0:
r = E1[i]
else:
for j in range(N):
if i == j or s & (1 << j) == 0:
continue
r = min(r, D0[si][j] + E[j][i])
D0[s][i] = r
d1 = min(d1, r + E1[i])
vs = [-1]*M
for i in range(N):
if s & (1 << i):
for k, d in ts[i]:
vs[k] = max(vs[k], d)
dp0 = [0]*(W+1)
for i in range(M):
if vs[i] == -1:
continue
w = ws[i]; v = vs[i]
for j in range(W-w+1):
dp0[j + w] = max(dp0[j] + v, dp0[j + w])
v1 = max(dp0)
for j in range(T-d1+1):
dp1[j + d1] = max(dp1[j] + v1, dp1[j + d1])
write("%d\n" % max(dp1))
solve()
``` | output | 1 | 20,224 | 1 | 40,449 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sergey Semyonovich is a mayor of a county city N and he used to spend his days and nights in thoughts of further improvements of Nkers' lives. Unfortunately for him, anything and everything has been done already, and there are no more possible improvements he can think of during the day (he now prefers to sleep at night). However, his assistants have found a solution and they now draw an imaginary city on a paper sheet and suggest the mayor can propose its improvements.
Right now he has a map of some imaginary city with n subway stations. Some stations are directly connected with tunnels in such a way that the whole map is a tree (assistants were short on time and enthusiasm). It means that there exists exactly one simple path between each pair of station. We call a path simple if it uses each tunnel no more than once.
One of Sergey Semyonovich's favorite quality objectives is the sum of all pairwise distances between every pair of stations. The distance between two stations is the minimum possible number of tunnels on a path between them.
Sergey Semyonovich decided to add new tunnels to the subway map. In particular, he connected any two stations u and v that were not connected with a direct tunnel but share a common neighbor, i.e. there exists such a station w that the original map has a tunnel between u and w and a tunnel between w and v. You are given a task to compute the sum of pairwise distances between all pairs of stations in the new map.
Input
The first line of the input contains a single integer n (2 β€ n β€ 200 000) β the number of subway stations in the imaginary city drawn by mayor's assistants. Each of the following n - 1 lines contains two integers u_i and v_i (1 β€ u_i, v_i β€ n, u_i β v_i), meaning the station with these indices are connected with a direct tunnel.
It is guaranteed that these n stations and n - 1 tunnels form a tree.
Output
Print one integer that is equal to the sum of distances between all pairs of stations after Sergey Semyonovich draws new tunnels between all pairs of stations that share a common neighbor in the original map.
Examples
Input
4
1 2
1 3
1 4
Output
6
Input
4
1 2
2 3
3 4
Output
7
Note
In the first sample, in the new map all pairs of stations share a direct connection, so the sum of distances is 6.
In the second sample, the new map has a direct tunnel between all pairs of stations except for the pair (1, 4). For these two stations the distance is 2. | instruction | 0 | 20,296 | 1 | 40,592 |
Tags: dfs and similar, dp, trees
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
def main():
n = int(input())
path = [[] for _ in range(n)]
for _ in range(n-1):
a1,b1 = map(lambda xx:int(xx)-1,input().split())
path[a1].append(b1)
path[b1].append(a1)
st,poi,visi = [0],[0]*n,[1]+[0]*(n-1)
dp,su = [[1.0,0.0] for _ in range(n)],0.0
# even ; odd
while len(st):
x,y = st[-1],path[st[-1]]
if poi[x] != len(y) and visi[y[poi[x]]]:
poi[x] += 1
if poi[x] == len(y):
su += dp[st.pop()][1]
if len(st):
dp[st[-1]][0] += dp[x][1]
dp[st[-1]][1] += dp[x][0]
else:
st.append(y[poi[x]])
visi[st[-1]] = 1
poi[x] += 1
st,poi,visi,ans,xor = [0],[0]*n,[1]+[0]*(n-1),su,0
dp1 = [su]*n
while len(st):
x,y = st[-1],path[st[-1]]
if poi[x] != len(y) and visi[y[poi[x]]]:
poi[x] += 1
if poi[x] == len(y):
st.pop()
xor ^= 1
else:
i = y[poi[x]]
dp1[i] = dp1[x]-dp[i][0]+dp[0][xor]-dp[i][1]
ans += dp1[i]
st.append(i)
visi[i] = 1
poi[x] += 1
xor ^= 1
print(int(ans/2))
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self,file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
self.newlines = b.count(b"\n")+(not b)
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd,self.buffer.getvalue())
self.buffer.truncate(0),self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self,file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s:self.buffer.write(s.encode("ascii"))
self.read = lambda:self.buffer.read().decode("ascii")
self.readline = lambda:self.buffer.readline().decode("ascii")
sys.stdin,sys.stdout = IOWrapper(sys.stdin),IOWrapper(sys.stdout)
input = lambda:sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 20,296 | 1 | 40,593 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sergey Semyonovich is a mayor of a county city N and he used to spend his days and nights in thoughts of further improvements of Nkers' lives. Unfortunately for him, anything and everything has been done already, and there are no more possible improvements he can think of during the day (he now prefers to sleep at night). However, his assistants have found a solution and they now draw an imaginary city on a paper sheet and suggest the mayor can propose its improvements.
Right now he has a map of some imaginary city with n subway stations. Some stations are directly connected with tunnels in such a way that the whole map is a tree (assistants were short on time and enthusiasm). It means that there exists exactly one simple path between each pair of station. We call a path simple if it uses each tunnel no more than once.
One of Sergey Semyonovich's favorite quality objectives is the sum of all pairwise distances between every pair of stations. The distance between two stations is the minimum possible number of tunnels on a path between them.
Sergey Semyonovich decided to add new tunnels to the subway map. In particular, he connected any two stations u and v that were not connected with a direct tunnel but share a common neighbor, i.e. there exists such a station w that the original map has a tunnel between u and w and a tunnel between w and v. You are given a task to compute the sum of pairwise distances between all pairs of stations in the new map.
Input
The first line of the input contains a single integer n (2 β€ n β€ 200 000) β the number of subway stations in the imaginary city drawn by mayor's assistants. Each of the following n - 1 lines contains two integers u_i and v_i (1 β€ u_i, v_i β€ n, u_i β v_i), meaning the station with these indices are connected with a direct tunnel.
It is guaranteed that these n stations and n - 1 tunnels form a tree.
Output
Print one integer that is equal to the sum of distances between all pairs of stations after Sergey Semyonovich draws new tunnels between all pairs of stations that share a common neighbor in the original map.
Examples
Input
4
1 2
1 3
1 4
Output
6
Input
4
1 2
2 3
3 4
Output
7
Note
In the first sample, in the new map all pairs of stations share a direct connection, so the sum of distances is 6.
In the second sample, the new map has a direct tunnel between all pairs of stations except for the pair (1, 4). For these two stations the distance is 2. | instruction | 0 | 20,297 | 1 | 40,594 |
Tags: dfs and similar, dp, trees
Correct Solution:
```
an=0
import sys
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
# sys.setrecursionlimit(2*100000)
@bootstrap
def dfs(node,c):
vis[node]=1
x[c]+=1
global an
dp[node]=1
for i in adj[node]:
if not vis[i]:
yield dfs(i,c^1)
dp[node]+=dp[i]
an+=dp[node]*(n-dp[node])
yield
n=int(input())
adj=[[] for i in range(n) ]
dp=[0]*n
for i in range(n-1):
u,v=map(int,input().split())
u-=1
v-=1
adj[u].append(v)
adj[v].append(u)
vis=[0]*n
x=[0,0]
dfs(0,0)
# print(dp)
print((an+x[0]*x[1])//2)
``` | output | 1 | 20,297 | 1 | 40,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sergey Semyonovich is a mayor of a county city N and he used to spend his days and nights in thoughts of further improvements of Nkers' lives. Unfortunately for him, anything and everything has been done already, and there are no more possible improvements he can think of during the day (he now prefers to sleep at night). However, his assistants have found a solution and they now draw an imaginary city on a paper sheet and suggest the mayor can propose its improvements.
Right now he has a map of some imaginary city with n subway stations. Some stations are directly connected with tunnels in such a way that the whole map is a tree (assistants were short on time and enthusiasm). It means that there exists exactly one simple path between each pair of station. We call a path simple if it uses each tunnel no more than once.
One of Sergey Semyonovich's favorite quality objectives is the sum of all pairwise distances between every pair of stations. The distance between two stations is the minimum possible number of tunnels on a path between them.
Sergey Semyonovich decided to add new tunnels to the subway map. In particular, he connected any two stations u and v that were not connected with a direct tunnel but share a common neighbor, i.e. there exists such a station w that the original map has a tunnel between u and w and a tunnel between w and v. You are given a task to compute the sum of pairwise distances between all pairs of stations in the new map.
Input
The first line of the input contains a single integer n (2 β€ n β€ 200 000) β the number of subway stations in the imaginary city drawn by mayor's assistants. Each of the following n - 1 lines contains two integers u_i and v_i (1 β€ u_i, v_i β€ n, u_i β v_i), meaning the station with these indices are connected with a direct tunnel.
It is guaranteed that these n stations and n - 1 tunnels form a tree.
Output
Print one integer that is equal to the sum of distances between all pairs of stations after Sergey Semyonovich draws new tunnels between all pairs of stations that share a common neighbor in the original map.
Examples
Input
4
1 2
1 3
1 4
Output
6
Input
4
1 2
2 3
3 4
Output
7
Note
In the first sample, in the new map all pairs of stations share a direct connection, so the sum of distances is 6.
In the second sample, the new map has a direct tunnel between all pairs of stations except for the pair (1, 4). For these two stations the distance is 2.
Submitted Solution:
```
import sys
def dfs(node, f):
subtree_even[node] = 1
subtree_odd[node] = 0
dp_even[node] = 0
dp_odd[node] = 0
for child in adj[node]:
if child == f: continue
dfs(child, node)
subtree_even[node] += subtree_odd[child]
subtree_odd[node] += subtree_even[child]
dp_even[node] += dp_odd[child] + subtree_odd[child]
dp_odd[node] += dp_even[child] + subtree_even[child]
def rotate(node, f):
global ans
ans += (dp_even[node] / 2) + ((dp_odd[node] + subtree_odd[node]) / 2)
# i = node
# print('node: {}, odd-sum: {}, odd-even: {}, subtree-odd:{}, subtree-even:{}'
# .format(i, dp_odd[i], dp_even[i], subtree_odd[i], subtree_even[i]))
for child in adj[node]:
if child == f: continue
dp_even[node] -= dp_odd[child] + subtree_odd[child]
dp_odd[node] -= dp_even[child] + subtree_even[child]
subtree_odd[node] -= subtree_even[child]
subtree_even[node] -= subtree_odd[child]
dp_even[child] += dp_odd[node] + subtree_odd[node]
dp_odd[child] += dp_even[node] + subtree_even[node]
subtree_even[child] += subtree_odd[node]
subtree_odd[child] += subtree_even[node]
rotate(child, node)
subtree_odd[child] -= subtree_even[node]
subtree_even[child] -= subtree_odd[node]
dp_odd[child] -= dp_even[node] + subtree_even[node]
dp_even[child] -= dp_odd[node] + subtree_odd[node]
subtree_even[node] += subtree_odd[child]
subtree_odd[node] += subtree_even[child]
dp_odd[node] += dp_even[child] + subtree_even[child]
dp_even[node] += dp_odd[child] + subtree_odd[child]
inp = [int(x) for x in sys.stdin.read().split()]
n = inp[0]
subtree_even = [0] * (n + 1)
subtree_odd = [0] * (n + 1)
dp_even = [0] * (n + 1)
dp_odd = [0] * (n + 1)
adj = [[] for i in range(n + 1)]
for i in range(1, len(inp), 2):
x, y = inp[i], inp[i + 1]
adj[x].append(y)
adj[y].append(x)
dfs(1, 0)
#for i in range(1, n + 1):
#print(i)
#print('node: {}, odd-sum: {}, odd-even: {}, subtree-odd:{}, subtree-even:{}'
# .format(i, dp_odd[i], dp_even[i], subtree_odd[i], subtree_even[i]))
ans = int(0)
rotate(1, 0)
print(ans / 2)
'''
'''
``` | instruction | 0 | 20,298 | 1 | 40,596 |
No | output | 1 | 20,298 | 1 | 40,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sergey Semyonovich is a mayor of a county city N and he used to spend his days and nights in thoughts of further improvements of Nkers' lives. Unfortunately for him, anything and everything has been done already, and there are no more possible improvements he can think of during the day (he now prefers to sleep at night). However, his assistants have found a solution and they now draw an imaginary city on a paper sheet and suggest the mayor can propose its improvements.
Right now he has a map of some imaginary city with n subway stations. Some stations are directly connected with tunnels in such a way that the whole map is a tree (assistants were short on time and enthusiasm). It means that there exists exactly one simple path between each pair of station. We call a path simple if it uses each tunnel no more than once.
One of Sergey Semyonovich's favorite quality objectives is the sum of all pairwise distances between every pair of stations. The distance between two stations is the minimum possible number of tunnels on a path between them.
Sergey Semyonovich decided to add new tunnels to the subway map. In particular, he connected any two stations u and v that were not connected with a direct tunnel but share a common neighbor, i.e. there exists such a station w that the original map has a tunnel between u and w and a tunnel between w and v. You are given a task to compute the sum of pairwise distances between all pairs of stations in the new map.
Input
The first line of the input contains a single integer n (2 β€ n β€ 200 000) β the number of subway stations in the imaginary city drawn by mayor's assistants. Each of the following n - 1 lines contains two integers u_i and v_i (1 β€ u_i, v_i β€ n, u_i β v_i), meaning the station with these indices are connected with a direct tunnel.
It is guaranteed that these n stations and n - 1 tunnels form a tree.
Output
Print one integer that is equal to the sum of distances between all pairs of stations after Sergey Semyonovich draws new tunnels between all pairs of stations that share a common neighbor in the original map.
Examples
Input
4
1 2
1 3
1 4
Output
6
Input
4
1 2
2 3
3 4
Output
7
Note
In the first sample, in the new map all pairs of stations share a direct connection, so the sum of distances is 6.
In the second sample, the new map has a direct tunnel between all pairs of stations except for the pair (1, 4). For these two stations the distance is 2.
Submitted Solution:
```
import sys
def dfs(node, f):
subtree_even[node] = 1
subtree_odd[node] = 0
dp_even[node] = 0
dp_odd[node] = 0
for child in adj[node]:
if child == f: continue
dfs(child, node)
subtree_even[node] += subtree_odd[child]
subtree_odd[node] += subtree_even[child]
dp_even[node] += dp_odd[child] + subtree_odd[child]
dp_odd[node] += dp_even[child] + subtree_even[child]
def rotate(node, f):
global ans
ans += (dp_even[node] / 2) + ((dp_odd[node] + subtree_odd[node]) / 2)
# i = node
# print('node: {}, odd-sum: {}, odd-even: {}, subtree-odd:{}, subtree-even:{}'
# .format(i, dp_odd[i], dp_even[i], subtree_odd[i], subtree_even[i]))
for child in adj[node]:
if child == f: continue
dp_even[node] -= dp_odd[child] + subtree_odd[child]
dp_odd[node] -= dp_even[child] + subtree_even[child]
subtree_odd[node] -= subtree_even[child]
subtree_even[node] -= subtree_odd[child]
dp_even[child] += dp_odd[node] + subtree_odd[node]
dp_odd[child] += dp_even[node] + subtree_even[node]
subtree_even[child] += subtree_odd[node]
subtree_odd[child] += subtree_even[node]
rotate(child, node)
subtree_odd[child] -= subtree_even[node]
subtree_even[child] -= subtree_odd[node]
dp_odd[child] -= dp_even[node] + subtree_even[node]
dp_even[child] -= dp_odd[node] + subtree_odd[node]
subtree_even[node] += subtree_odd[child]
subtree_odd[node] += subtree_even[child]
dp_odd[node] += dp_even[child] + subtree_even[child]
dp_even[node] += dp_odd[child] + subtree_odd[child]
inp = [int(x) for x in sys.stdin.read().split()]
n = inp[0]
subtree_even = [0] * (n + 1)
subtree_odd = [0] * (n + 1)
dp_even = [0] * (n + 1)
dp_odd = [0] * (n + 1)
adj = [[] for i in range(n + 1)]
for i in range(1, len(inp), 2):
x, y = inp[i], inp[i + 1]
adj[x].append(y)
adj[y].append(x)
dfs(1, 0)
#for i in range(1, n + 1):
#print(i)
#print('node: {}, odd-sum: {}, odd-even: {}, subtree-odd:{}, subtree-even:{}'
# .format(i, dp_odd[i], dp_even[i], subtree_odd[i], subtree_even[i]))
ans = 0
rotate(1, 0)
print(ans / 2)
'''
'''
``` | instruction | 0 | 20,299 | 1 | 40,598 |
No | output | 1 | 20,299 | 1 | 40,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sergey Semyonovich is a mayor of a county city N and he used to spend his days and nights in thoughts of further improvements of Nkers' lives. Unfortunately for him, anything and everything has been done already, and there are no more possible improvements he can think of during the day (he now prefers to sleep at night). However, his assistants have found a solution and they now draw an imaginary city on a paper sheet and suggest the mayor can propose its improvements.
Right now he has a map of some imaginary city with n subway stations. Some stations are directly connected with tunnels in such a way that the whole map is a tree (assistants were short on time and enthusiasm). It means that there exists exactly one simple path between each pair of station. We call a path simple if it uses each tunnel no more than once.
One of Sergey Semyonovich's favorite quality objectives is the sum of all pairwise distances between every pair of stations. The distance between two stations is the minimum possible number of tunnels on a path between them.
Sergey Semyonovich decided to add new tunnels to the subway map. In particular, he connected any two stations u and v that were not connected with a direct tunnel but share a common neighbor, i.e. there exists such a station w that the original map has a tunnel between u and w and a tunnel between w and v. You are given a task to compute the sum of pairwise distances between all pairs of stations in the new map.
Input
The first line of the input contains a single integer n (2 β€ n β€ 200 000) β the number of subway stations in the imaginary city drawn by mayor's assistants. Each of the following n - 1 lines contains two integers u_i and v_i (1 β€ u_i, v_i β€ n, u_i β v_i), meaning the station with these indices are connected with a direct tunnel.
It is guaranteed that these n stations and n - 1 tunnels form a tree.
Output
Print one integer that is equal to the sum of distances between all pairs of stations after Sergey Semyonovich draws new tunnels between all pairs of stations that share a common neighbor in the original map.
Examples
Input
4
1 2
1 3
1 4
Output
6
Input
4
1 2
2 3
3 4
Output
7
Note
In the first sample, in the new map all pairs of stations share a direct connection, so the sum of distances is 6.
In the second sample, the new map has a direct tunnel between all pairs of stations except for the pair (1, 4). For these two stations the distance is 2.
Submitted Solution:
```
import sys
lines = sys.stdin.readlines()
n = int(lines[0])
lines = lines[1:]
g = [list() for i in range(n)]
# print(g)
for i in range(n-1):
words = lines[i].split(' ')
g[int(words[0])-1].append(int(words[1])-1)
# print(g)
ch = [False] * n
# print(ch)
ans = 0
def rec(k, even, odd, s_even, s_odd):
global ans
ch[k] = True
o = 0
e = 1
so = 0
se = 0
# print(type(even))
# print(type(odd))
# print(type(s_even))
# print(type(s_odd))
ans += s_even//2 + (s_odd-odd)//2 + odd
for node in g[k]:
if not ch[node]:
tup = rec(node, odd+o, even+e, s_odd+odd+so+o, s_even+even+se+e)
o += tup[0]
e += tup[1]
so += tup[2] + tup[0]
se += tup[3] + tup[1]
return (e, o, se, so)
rec(0, 0, 0, 0, 0)
# print(type(ans))
print(ans)
``` | instruction | 0 | 20,300 | 1 | 40,600 |
No | output | 1 | 20,300 | 1 | 40,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sergey Semyonovich is a mayor of a county city N and he used to spend his days and nights in thoughts of further improvements of Nkers' lives. Unfortunately for him, anything and everything has been done already, and there are no more possible improvements he can think of during the day (he now prefers to sleep at night). However, his assistants have found a solution and they now draw an imaginary city on a paper sheet and suggest the mayor can propose its improvements.
Right now he has a map of some imaginary city with n subway stations. Some stations are directly connected with tunnels in such a way that the whole map is a tree (assistants were short on time and enthusiasm). It means that there exists exactly one simple path between each pair of station. We call a path simple if it uses each tunnel no more than once.
One of Sergey Semyonovich's favorite quality objectives is the sum of all pairwise distances between every pair of stations. The distance between two stations is the minimum possible number of tunnels on a path between them.
Sergey Semyonovich decided to add new tunnels to the subway map. In particular, he connected any two stations u and v that were not connected with a direct tunnel but share a common neighbor, i.e. there exists such a station w that the original map has a tunnel between u and w and a tunnel between w and v. You are given a task to compute the sum of pairwise distances between all pairs of stations in the new map.
Input
The first line of the input contains a single integer n (2 β€ n β€ 200 000) β the number of subway stations in the imaginary city drawn by mayor's assistants. Each of the following n - 1 lines contains two integers u_i and v_i (1 β€ u_i, v_i β€ n, u_i β v_i), meaning the station with these indices are connected with a direct tunnel.
It is guaranteed that these n stations and n - 1 tunnels form a tree.
Output
Print one integer that is equal to the sum of distances between all pairs of stations after Sergey Semyonovich draws new tunnels between all pairs of stations that share a common neighbor in the original map.
Examples
Input
4
1 2
1 3
1 4
Output
6
Input
4
1 2
2 3
3 4
Output
7
Note
In the first sample, in the new map all pairs of stations share a direct connection, so the sum of distances is 6.
In the second sample, the new map has a direct tunnel between all pairs of stations except for the pair (1, 4). For these two stations the distance is 2.
Submitted Solution:
```
from sys import stdin
def fread():
return [int(x) for x in stdin.readline().rstrip().split()]
n = int(input())
e = [[] for i in range(n + 1)]
for i in range(1, n):
x, y = fread()
e[x] += [y]
e[y] += [x]
ans = 0
siz = [[1, 0] for i in range(n + 1)]
def dfs(u, fu):
for v in e[u]:
if v != fu:
dfs(v, u)
global ans
ans += sum(siz[v]) * (n - sum(siz[v])) + siz[v][0] * siz[u][1] + siz[v][1] * siz[u][0]
siz[u][0] += siz[v][1]
siz[u][1] += siz[v][0]
dfs(1, 0)
print(ans >> 1)
``` | instruction | 0 | 20,301 | 1 | 40,602 |
No | output | 1 | 20,301 | 1 | 40,603 |
Provide a correct Python 3 solution for this coding contest problem.
Bridge Construction Planning
There is a city consisting of many small islands, and the citizens live in these islands. Citizens feel inconvenience in requiring ferry rides between these islands. The city mayor decided to build bridges connecting all the islands.
The city has two construction companies, A and B. The mayor requested these companies for proposals, and obtained proposals in the form: "Company A (or B) can build a bridge between islands u and v in w hundred million yen."
The mayor wants to accept some of these proposals to make a plan with the lowest budget. However, if the mayor accepts too many proposals of one company, the other may go bankrupt, which is not desirable for the city with only two construction companies. However, on the other hand, to avoid criticism on wasteful construction, the mayor can only accept the minimum number (i.e., n β 1) of bridges for connecting all the islands. Thus, the mayor made a decision that exactly k proposals by the company A and exactly n β 1 β k proposals by the company B should be accepted.
Your task is to write a program that computes the cost of the plan with the lowest budget that satisfies the constraints. Here, the cost of a plan means the sum of all the costs mentioned in the accepted proposals.
Input
The input consists of multiple datasets. The number of datasets is at most 30. Each dataset is in the following format.
> n m k
> u1 v1 w1 l1
> ...
> um vm wm lm
>
The first line contains three integers n, m, and k, where n is the number of islands, m is the total number of proposals, and k is the number of proposals that are to be ordered to company A (2 β€ n β€ 200, 1 β€ m β€ 600, and 0 β€ k β€ nβ1). Islands are identified by integers, 1 through n. The following m lines denote the proposals each of which is described with three integers ui, vi, wi and one character li, where ui and vi denote two bridged islands, wi is the cost of the bridge (in hundred million yen), and li is the name of the company that submits this proposal (1 β€ ui β€ n, 1 β€ vi β€ n, 1 β€ wi β€ 100, and li = 'A' or 'B'). You can assume that each bridge connects distinct islands, i.e., ui β vi, and each company gives at most one proposal for each pair of islands, i.e., {ui, vi} β {uj, vj} if i β j and li = lj.
The end of the input is indicated by a line with three zeros separated by single spaces.
Output
For each dataset, output a single line containing a single integer that denotes the cost (in hundred million yen) of the plan with the lowest budget. If there are no plans that satisfy the constraints, output β1.
Sample Input
4 5 2
1 2 2 A
1 3 2 A
1 4 2 A
2 3 1 B
3 4 1 B
5 8 2
1 2 1 A
2 3 1 A
3 4 3 A
4 5 3 A
1 2 5 B
2 3 5 B
3 4 8 B
4 5 8 B
5 5 1
1 2 1 A
2 3 1 A
3 4 1 A
4 5 1 B
3 5 1 B
4 5 3
1 2 2 A
2 4 3 B
3 4 4 B
2 3 5 A
3 1 6 A
0 0 0
Output for the Sample Input
5
16
-1
-1
Example
Input
4 5 2
1 2 2 A
1 3 2 A
1 4 2 A
2 3 1 B
3 4 1 B
5 8 2
1 2 1 A
2 3 1 A
3 4 3 A
4 5 3 A
1 2 5 B
2 3 5 B
3 4 8 B
4 5 8 B
5 5 1
1 2 1 A
2 3 1 A
3 4 1 A
4 5 1 B
3 5 1 B
4 5 3
1 2 2 A
2 4 3 B
3 4 4 B
2 3 5 A
3 1 6 A
0 0 0
Output
5
16
-1
-1 | instruction | 0 | 21,117 | 1 | 42,234 |
"Correct Solution:
```
from collections import deque
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N, M, K = map(int, readline().split())
if N == 0:
return False
def root(x):
if prt[x] == x:
return x
prt[x] = y = root(prt[x])
return y
def unite(x, y):
px = root(x); py = root(y)
if px == py:
return 0
if px < py:
prt[py] = px
else:
prt[px] = py
return 1
E = []
for i in range(M):
u, v, w, l = readline().strip().split()
u = int(u); v = int(v); w = int(w)
if l == "A":
E.append((w, u-1, v-1, 0))
else:
E.append((w, u-1, v-1, 1))
E.sort()
U = [0]*M
cnt = 0; ec = 0
ans = 0
*prt, = range(N)
for i, (w, u, v, d) in enumerate(E):
if unite(u, v):
U[i] = 1
if d == 0:
cnt += 1
ec += 1
ans += w
if ec != N-1:
write("-1\n")
return True
if cnt < K:
m = 0
else:
m = 1
que = deque()
used = [0]*N; zeros = [0]*N
G = [[] for i in range(N)]
for i in range(M):
if not U[i]:
continue
w, u, v, d = E[i]
if d == m:
G[u].append((v, 0, -1))
G[v].append((u, 0, -1))
else:
G[u].append((v, w, i))
G[v].append((u, w, i))
for t in range(abs(K - cnt)):
s = 10**18; p = q = -1
for i in range(M):
if U[i]:
continue
wi, ui, vi, di = E[i]
if di != m:
continue
que.append((ui, 0, -1))
used[:] = zeros
used[ui] = 1
while que:
u, r, j = que.popleft()
if u == vi:
wj = r
break
for v, w, k in G[u]:
if used[v]:
continue
if k != -1 and r < w:
que.append((v, w, k))
else:
que.append((v, r, j))
used[v] = 1
que.clear()
if wi - wj < s and j != -1:
s = wi - wj
p = i; q = j
if p == -1:
write("-1\n")
return True
wq, uq, vq, dq = E[q]
g = G[uq]
for i in range(len(g)):
if g[i][0] == vq:
g.pop(i)
break
g = G[vq]
for i in range(len(g)):
if g[i][0] == uq:
g.pop(i)
break
wp, up, vp, dp = E[p]
G[up].append((vp, 0, -1))
G[vp].append((up, 0, -1))
U[p] = 1; U[q] = 0
ans += s
write("%d\n" % ans)
return True
while solve():
...
``` | output | 1 | 21,117 | 1 | 42,235 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2. | instruction | 0 | 21,330 | 1 | 42,660 |
Tags: dfs and similar, dp, greedy, sortings, trees
Correct Solution:
```
from sys import stdin
from collections import defaultdict, deque
debug = False
def join(_s, _l):
return _s.join(map(str, _l))
def read(_f=None):
if _f == None:
return stdin.readline().strip()
return _f(stdin.readline().strip())
def readlist(_f=None):
_l = stdin.readline().strip().split()
if _f == None:
return _l
return map(_f, _l)
readint = lambda: read(int)
readints = lambda: readlist(int)
printval = lambda _r: print(_r, end=" ")
printline = lambda _s, _r: print(join(_s, _r), end="\n")
graph = defaultdict(list)
levels = defaultdict(list)
def get_height(depth):
queue = deque()
queue.append((0, -1))
d = 0
while queue:
size = len(queue)
for _ in range(size):
node, parent = queue.popleft()
depth[node] = d
levels[d].append(node)
for neigh in graph[node]:
if neigh != parent:
queue.append((neigh, node))
d += 1
return d
def paths(max_depth, depth, priority):
for d in range(max_depth, -1, -1):
for node in levels[d]:
for parent in graph[node]:
if depth[node] > depth[parent]:
priority[parent] += priority[node] + 1
def solve():
n, k = readints()
if k >= n:
return 0
for _ in range(n - 1):
u, v = readlist(lambda x: int(x) - 1)
graph[u].append(v)
graph[v].append(u)
priority = [0] * n
depth = [0] * n
# get all heights and nodes in each level
max_depth = get_height(depth)
# count the paths that passes from each node
paths(max_depth, depth, priority)
# set the priority by weighting with the height
for node in range(n):
priority[node] -= depth[node]
priority.sort()
return sum(priority[k:])
if __name__ == "__main__":
if debug:
print("-" * 20)
if debug:
print("ANS: ", end="")
ans = solve()
print(ans)
``` | output | 1 | 21,330 | 1 | 42,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2. | instruction | 0 | 21,331 | 1 | 42,662 |
Tags: dfs and similar, dp, greedy, sortings, trees
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 MI1(): return map(int1, 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]
def main():
def dfs():
first=[True]*n
stack=[(0,-1)]
while stack:
u,pu=stack.pop()
if first[u]:
first[u]=False
stack.append((u,pu))
for v in to[u]:
if v == pu: continue
dep[v] = dep[u] + 1
stack.append((v,u))
else:
for v in to[u]:
if v==pu:continue
chi[u]+=chi[v]+1
n,k=MI()
to=[[] for _ in range(n)]
for _ in range(n-1):
u,v=MI1()
to[u].append(v)
to[v].append(u)
dep=[0]*n
chi=[0]*n
dfs()
vv=[dep[u]-chi[u] for u in range(n)]
vv.sort(reverse=True)
ans=sum(vv[:k])
print(ans)
main()
``` | output | 1 | 21,331 | 1 | 42,663 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2. | instruction | 0 | 21,332 | 1 | 42,664 |
Tags: dfs and similar, dp, greedy, sortings, trees
Correct Solution:
```
def main():
for _ in inputt(1):
n, k = inputi()
P = [[] for i in range(n + 1)]
T = [0] * (n + 1)
D = [0] * (n + 1)
for _ in range(n - 1):
a, b = inputi()
P[a].append(b)
P[b].append(a)
S = [(1, 1, 0)]
i = 0
while S:
p, t, d = S.pop()
if not T[p]:
T[p] = 1
S.append((p, t, i))
for nxt in P[p]:
if not T[nxt]:
S.append((nxt, t + 1, 0))
else:
i += 1
D[p] = t - (i - d)
D = sorted(D[1:], reverse = True)
print(sum(D[:k]))
# region M
# region import
# ζζimportι¨ε
from math import *
from heapq import *
from itertools import *
from functools import reduce, lru_cache, partial
from collections import Counter, defaultdict
import re, copy, operator, cmath
import sys, io, os, builtins
sys.setrecursionlimit(1000)
# endregion
# region fastio
# εΏ«ιioοΌθ½ζε倧ιζΆι΄
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = io.BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
sys.stdout.write(kwargs.pop("split", " ").join(map(str, args)))
sys.stdout.write(kwargs.pop("end", "\n"))
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip()
inputt = lambda t = 0: range(t) if t else range(int(input()))
inputs = lambda: input().split()
inputi = lambda: map(int, inputs())
inputl = lambda t = 0, k = inputi: map(list, (k() for _ in range(t))) if t else list(k())
# endregion
# region bisect
# δΊεζη΄’οΌζ εεΊζ²‘ζε½ζ°εζ°
def len(a):
if isinstance(a, range):
return -((a.start - a.stop) // a.step)
return builtins.len(a)
def bisect_left(a, x, key = None, lo = 0, hi = None):
if lo < 0: lo = 0
if hi == None: hi = len(a)
if key == None: key = do_nothing
while lo < hi:
mid = (lo + hi) // 2
if key(a[mid]) < x: lo = mid + 1
else: hi = mid
return lo
def bisect_right(a, x, key = None, lo = 0, hi = None):
if lo < 0: lo = 0
if hi == None: hi = len(a)
if key == None: key = do_nothing
while lo < hi:
mid = (lo + hi) // 2
if x < key(a[mid]): hi = mid
else: lo = mid + 1
return lo
def insort_left(a, x, key = None, lo = 0, hi = None):
lo = bisect_left(a, x, key, lo, hi)
a.insert(lo, x)
def insort_right(a, x, key = None, lo = 0, hi = None):
lo = bisect_right(a, x, key, lo, hi)
a.insert(lo, x)
do_nothing = lambda x: x
bisect = bisect_right
insort = insort_right
def index(a, x, default = None, key = None, lo = 0, hi = None):
if lo < 0: lo = 0
if hi == None: hi = len(a)
if key == None: key = do_nothing
i = bisect_left(a, x, key, lo, hi)
if lo <= i < hi and key(a[i]) == x: return a[i]
if default != None: return default
raise ValueError
def find_lt(a, x, default = None, key = None, lo = 0, hi = None):
if lo < 0: lo = 0
if hi == None: hi = len(a)
i = bisect_left(a, x, key, lo, hi)
if lo < i <= hi: return a[i - 1]
if default != None: return default
raise ValueError
def find_le(a, x, default = None, key = None, lo = 0, hi = None):
if lo < 0: lo = 0
if hi == None: hi = len(a)
i = bisect_right(a, x, key, lo, hi)
if lo < i <= hi: return a[i - 1]
if default != None: return default
raise ValueError
def find_gt(a, x, default = None, key = None, lo = 0, hi = None):
if lo < 0: lo = 0
if hi == None: hi = len(a)
i = bisect_right(a, x, key, lo, hi)
if lo <= i < hi: return a[i]
if default != None: return default
raise ValueError
def find_ge(a, x, default = None, key = None, lo = 0, hi = None):
if lo < 0: lo = 0
if hi == None: hi = len(a)
i = bisect_left(a, x, key, lo, hi)
if lo <= i < hi: return a[i]
if default != None: return default
raise ValueError
# endregion
# region main
# main ε½ζ°ι¨ε
if __name__ == "__main__":
main()
# endregion
# endregion
``` | output | 1 | 21,332 | 1 | 42,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2. | instruction | 0 | 21,333 | 1 | 42,666 |
Tags: dfs and similar, dp, greedy, sortings, trees
Correct Solution:
```
import sys
from collections import defaultdict as dd
from collections import deque as dq
input = sys.stdin.readline
N, K = map(int, input().split())
e = dd(list)
for _ in range(N - 1):
u, v = map(int, input().split())
e[u].append(v)
e[v].append(u)
Q = dq([1])
d = [N for i in range(N + 1)]
d[1] = 0
while len(Q):
x = Q.popleft()
for y in e[x]:
if d[y] > d[x] + 1:
d[y] = d[x] + 1
Q.append(y)
s = [1]
vis = [0] * (N + 1)
parent = [0] * (N + 1)
order = []
while len(s):
x = s.pop()
order.append(x)
vis[x] = 1
for y in e[x]:
if vis[y]: continue
s.append(y)
parent[y] = x
size = [1] * (N + 1)
for x in order[: : -1]:
y = parent[x]
size[y] += size[x]
table = [(d[i] - size[i] + 1, i) for i in range(N + 1)]
table.sort()
res = 0
while K:
x, i = table.pop()
if i in range(2, N + 1):
K -= 1
res += x
print(res)
``` | output | 1 | 21,333 | 1 | 42,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2. | instruction | 0 | 21,334 | 1 | 42,668 |
Tags: dfs and similar, dp, greedy, sortings, trees
Correct Solution:
```
import collections
n,k=map(int,input().split())
g=[[] for _ in range(n+1)]
for _ in range(n-1):
a,b=map(int,input().split())
g[a].append(b)
g[b].append(a)
q=collections.deque()
q.append((1,0))
checked=[0]*(n+1)
checked[1]=1
ds=[[] for _ in range(n+1)]
pairs={}
while len(q)!=0:
v,d=q.popleft()
ds[d].append(v)
for u in g[v]:
if checked[u]==0:
checked[u]=1
q.append((u,d+1))
pairs[u]=v
cnt=[0]*(n+1)
tmp=[]
for i in range(n,0,-1):
for v in ds[i]:
cnt[pairs[v]]+=cnt[v]+1
tmp.append(i-cnt[v])
tmp=sorted(tmp,reverse=True)
print(sum(tmp[:k]))
``` | output | 1 | 21,334 | 1 | 42,669 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2. | instruction | 0 | 21,335 | 1 | 42,670 |
Tags: dfs and similar, dp, greedy, sortings, trees
Correct Solution:
```
import io,os
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
import sys
from collections import deque
def main():
n,k=map(int,input().split())
Edges=[[] for _ in range(n)]
for _ in range(n-1):
a,b=map(int,input().split())
a-=1; b-=1
Edges[a].append(b)
Edges[b].append(a)
Depth=[-1]*n
Depth[0]=0
Depth_pair=[(0,0)]
Size=[0]*n
Chi=[[] for _ in range(n)]
Par=[-1]*n
q=deque()
q.append(0)
while q:
par=q.popleft()
for chi in Edges[par]:
if Depth[chi]==-1:
Depth[chi]=Depth[par]+1
Depth_pair.append((Depth[par]+1,chi))
Chi[par].append(chi)
Par[chi]=par
q.append(chi)
#print(Depth,Chi,Par)
L=[]
for i in range(n):
if len(Chi[i])==0:
L.append(i)
q=deque(L)
#print(L)
Depth_pair.sort(reverse=True)
Score=[0]*n
Size=[1]*n
for d,v in Depth_pair:
for chi in Chi[v]:
Size[v]+=Size[chi]
Score[v]=Depth[v]-Size[v]+1
#print(Score,Size)
Score.sort(reverse=True)
ans=sum(Score[:k])
sys.stdout.write(str(ans)+'\n')
if __name__=='__main__':
main()
``` | output | 1 | 21,335 | 1 | 42,671 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2. | instruction | 0 | 21,336 | 1 | 42,672 |
Tags: dfs and similar, dp, greedy, sortings, trees
Correct Solution:
```
import math,sys
#from itertools import permutations, combinations;import heapq,random;
from collections import defaultdict,deque
import bisect as bi
def yes():print('YES')
def no():print('NO')
def I():return (int(sys.stdin.readline()))
def In():return(map(int,sys.stdin.readline().split()))
def Sn():return sys.stdin.readline().strip()
#sys.setrecursionlimit(1500)
def dict(a):
d={}
for x in a:
if d.get(x,-1)!=-1:
d[x]+=1
else:
d[x]=1
return d
def find_gt(a, x):
'Find leftmost value greater than x'
i = bi.bisect_left(a, x)
if i != len(a):
return i
else:
return -1
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
@bootstrap
def dfs(d,node,hig):
if not visit[node]:
ans=1;visit[node]=True
for x in d[node]:
if not visit[x]:
ans+=yield(dfs(d,x,hig+1))
child.append((node,ans-hig))
yield (ans)
def main():
try:
n,k=In()
d=defaultdict(list)
global child,visit,ans
child=[];ans=0
visit=[False]*(n+1)
for x in range(n-1):
a,b=In()
d[a].append(b)
d[b].append(a)
dfs(d,1,1)
child.sort(key=lambda x:x[1],reverse=True)
# print(child)
for i in range((n-k)):
ans+=(child[i][1])
print(ans)
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
# for _ in range(I()):main()
for _ in range(1):main()
# ******************* All The Best ******************* #
``` | output | 1 | 21,336 | 1 | 42,673 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2. | instruction | 0 | 21,337 | 1 | 42,674 |
Tags: dfs and similar, dp, greedy, sortings, trees
Correct Solution:
```
import sys
lines = sys.stdin.readlines()
(n, k) = map(int, lines[0].strip().split(" "))
edges = {}
for i in range(1, n):
(a, b) = map(int, lines[i].strip().split(" "))
if a not in edges: edges[a] = []
if b not in edges: edges[b] = []
edges[a].append(b)
edges[b].append(a)
seen = set([1])
stack = [1]
level = {1:0}
parent = {1:0}
while stack:
node = stack.pop()
for adj in edges[node]:
if adj not in seen:
seen.add(adj)
level[adj] = level[node] + 1
stack.append(adj)
parent[adj] = node
noChild = {}
stack = [1]
while stack:
node = stack.pop()
all = True
for adj in edges[node]:
if adj != parent[node] and adj not in noChild:
all = False; break
if all:
tmp = 0
for adj in edges[node]:
if adj == parent[node]: continue
tmp += noChild[adj] + 1
noChild[node] = tmp
else:
stack.append(node)
for adj in edges[node]:
if adj == parent[node]: continue
if adj not in noChild: stack.append(adj)
res = [(level[i] - noChild[i]) for i in range(1, n+1)]
res.sort(reverse = True)
print(sum(res[:k] ))
``` | output | 1 | 21,337 | 1 | 42,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2.
Submitted Solution:
```
import sys
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
n, k = list(map(lambda x: int(x), input().split()))
from collections import deque
def readTree(n):
adj = [set() for _ in range(n)]
for _ in range(n - 1):
u, v = map(int, sys.stdin.readline().split())
adj[u - 1].add(v - 1)
adj[v - 1].add(u - 1)
return adj
adj = readTree(n)
dq = deque()
dq.append(0)
parent = [-2] + [-1] * (n - 1)
depth = [0] * n
while dq:
nd = dq.popleft()
for a in adj[nd]:
if parent[a] < 0:
parent[a] = nd
depth[a] = depth[nd] + 1
dq.append(a)
depth[0] = 0
subtree_size = [0 for _ in range(n)]
visited = [False for _ in range(n)]
@bootstrap
def DFSUtil(v, visited):
global subtree_size
visited[v] = True
cnt = 1
for i in adj[v]:
if visited[i] == False:
yield DFSUtil(i, visited)
cnt += subtree_size[i]
subtree_size[v] = cnt
yield
DFSUtil(0, visited)
# print(subtree_size)
for i in range(0, len(depth)):
depth[i] = (i, -subtree_size[i] + depth[i]+1)
depth.sort(key=lambda x: (x[1]), reverse=True)
h = 0
# print(depth)
print(sum([x[1] for x in depth[0:k]]))
# import sys
# from collections import deque
# from heapq import *
#
# input = lambda: sys.stdin.readline().rstrip()
#
# n, k = map(int, input().split())
# G = [[] for _ in range(n)]
# for i in range(1, n):
# u, v = map(int, input().split())
# G[u - 1].append(v - 1)
# G[v - 1].append(u - 1)
#
# bfs = [0]
# P = [-1 for _ in range(n)]
# for cur in bfs:
# for nb in G[cur]:
# del G[nb][G[nb].index(cur)]
# P[nb] = cur
# bfs.append(nb)
#
# SZ = [1] * n
# for cur in bfs[1:][::-1]:
# SZ[P[cur]] += SZ[cur]
#
# dep = [1] * n
# for cur in bfs[1:]:
# dep[cur] = dep[P[cur]] + 1
#
# sc = [dep[cur] - SZ[cur] for cur in range(n)]
# print(sc)
# print(sum(sorted(sc, reverse=True)[:k]))
``` | instruction | 0 | 21,338 | 1 | 42,676 |
Yes | output | 1 | 21,338 | 1 | 42,677 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2.
Submitted Solution:
```
import io
import os
import sys
import heapq
from copy import copy
from typing import NamedTuple
from collections import deque
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
fileno = sys.stdin.fileno()
input = io.BytesIO(
os.read(fileno, os.fstat(fileno).st_size)
).readline
class Record(NamedTuple):
profit: int
vertex: int
def __lt__(self, other):
return self.profit > other.profit
def bfs(root):
q = deque([root])
parent[0] = -1
depth[0] = 0
order = []
while q:
root = q.popleft()
order.append(root)
for vertex in A[root]:
if parent[vertex] is None:
children[root] += 1
parent[vertex] = root
depth[vertex] = depth[root] + 1
q.append(vertex)
for vertex in reversed(order):
p = parent[vertex]
if p != -1:
subtree[p] += subtree[vertex]
N, k = list(map(int, input().split()))
A = [[] for i in range(N)]
depth = [None for i in range(N)]
parent = [None for i in range(N)]
subtree = [1 for i in range(N)]
children = [0 for i in range(N)]
for i in range(N - 1):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
A[x].append(y)
A[y].append(x)
bfs(0)
# print(parent)
# print(subtree)
# print(depth)
# print(children)
ans = 0
h = []
for i in range(N):
if subtree[i] == 1:
h.append(Record(profit=depth[i], vertex=i))
heapq.heapify(h)
for i in range(k):
root = heapq.heappop(h)
ans += root.profit
p = parent[root.vertex]
if p != -1:
children[p] -= 1
if children[p] == 0:
record = Record(
profit=depth[p]-subtree[p] + 1,
vertex=p
)
heapq.heappush(h, record)
print(ans)
``` | instruction | 0 | 21,339 | 1 | 42,678 |
Yes | output | 1 | 21,339 | 1 | 42,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2.
Submitted Solution:
```
'''
from heapq import *
t=int(input())
for i in range(t):
n=int(input())
arr=[0 for i in range(n)]
heap=[]
heappush(heap,[n,1])
while heap:
pop=heappop(heap)
'''
import sys, threading
sys.setrecursionlimit(300000)
threading.stack_size(10**8)
def solve():
n,k=map(int,input().split())
n1=[n,k]
adj={}
depths={}
cities=[]
subtrees={}
nums={}
for i in range(n-1):
a,b=map(int,input().split())
if a not in adj:
adj[a]=[]
if b not in adj:
adj[b]=[]
adj[a].append(b)
adj[b].append(a)
v=set()
def dfs(node,depth):
v.add(node)
depths[node]=depth
subtrees[node]=0
for child in adj.get(node,[]):
if child not in v:
#parent[child]=node
r=dfs(child,depth+1)
if type(r)==int:
subtrees[node]+=r
return subtrees[node]+1
dfs(1,0)
ans=[]
for i in range(1,n+1):
ans.append(depths.get(i,0)-subtrees.get(i,0))
ans.sort(reverse=True)
print(sum(ans[:k]))
threading.Thread(target=solve).start()
``` | instruction | 0 | 21,340 | 1 | 42,680 |
Yes | output | 1 | 21,340 | 1 | 42,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2.
Submitted Solution:
```
import sys
from array import array # noqa: F401
from heapq import heappop, heappush
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n, k = map(int, input().split())
deg = [10**9] + [0] * n
adj = [[] for _ in range(n)]
for u, v in (map(int, input().split()) for _ in range(n - 1)):
adj[u - 1].append(v - 1)
adj[v - 1].append(u - 1)
deg[u - 1], deg[v - 1] = deg[u - 1] + 1, deg[v - 1] + 1
subt = [1] * n
stack = [i for i in range(1, n) if deg[i] == 1]
while stack:
v = stack.pop()
deg[v] = 0
for dest in adj[v]:
if deg[dest] == 0:
continue
subt[dest] += subt[v]
deg[dest] -= 1
if deg[dest] == 1:
stack.append(dest)
ans = 0
hq = [(-(subt[0] - 1), 0, 1, -1)]
for _ in range(n - k):
score, v, depth, parent = heappop(hq)
ans -= score
for dest in adj[v]:
if dest == parent:
continue
heappush(hq, (depth * subt[dest] - (depth + 1) * (subt[dest] - 1), dest, depth + 1, v))
print(ans)
``` | instruction | 0 | 21,341 | 1 | 42,682 |
Yes | output | 1 | 21,341 | 1 | 42,683 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2.
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
# main code
inp=inp()
n,k=inp[0],inp[1]
pos=2
d=[[] for i in range(n+1)]
for i in range(n-1):
u,v=inp[pos],inp[pos+1]
pos+=2
d[u].append(v)
d[v].append(u)
#arr=[]
q=[1]
vis=[0]*(n+1)
wt=[0]*(n+1)
vis[1]=1
#wt[1]=1
pos=0
while pos<n:
x=q[pos]
pos+=1
for i in d[x]:
if not vis[i]:
vis[i]=1
wt[i]=wt[x]+1
q.append(i)
dp=[0]*(n+1)
arr=[]
while q:
x=q.pop()
c=0
vis[x]=0
for i in d[x]:
if not vis[i]:
c+=dp[i]
dp[x]=c+1
arr.append((wt[x]-c,x))
arr.sort(reverse=True)
for i in range(k):
vis[arr[i][1]]=1
q.append((1,1))
vis[1]=1
ans=0
while q:
x,p=q.pop()
for i in d[x]:
if not vis[i]:
vis[i]=1
q.append((i,x))
elif vis[i] and i!=p:
#print i,dp[i],w
ans+=(dp[i]*wt[i])
pr_num(ans)
``` | instruction | 0 | 21,342 | 1 | 42,684 |
Yes | output | 1 | 21,342 | 1 | 42,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2.
Submitted Solution:
```
import sys
input=sys.stdin.readline
n,k=map(int,input().split())
li=[0]*n
dic={}
dico={}
for i in range(n-1):
xx,yy=map(int,input().split())
if(xx in dic):
dic[xx].append(yy)
dico[xx].append(yy)
else:
dic[xx]=[yy]
dico[xx]=[yy]
if(yy in dic):
dic[yy].append(xx)
dico[yy].append(xx)
else:
dic[yy]=[xx]
dico[yy]=[xx]
#---------------
depth={1:0}
se={1}
xx={1}
level=0
while xx:
tem=set({})
level+=1
for i in xx:
yy=dic[i]
for j in yy:
if(not(j in se)):
se.add(j)
tem.add(j)
depth[j]=level
xx=tem.copy()
for i in dic:
dic[i].sort(key=lambda x:depth[x])
dico[i].sort(key=lambda x:depth[x])
#--------------
li[0]=1
cur=1
while(dic[cur]):
xx=dic[cur].pop()
if(li[xx-1]==0):
li[xx-1]=1
else:
li[xx-1]+=li[cur-1]
cur=xx
#----------
kk=[]
for i in range(1,n+1):
kk.append(i)
kk.sort(key=lambda x:(-li[x-1],depth[x]))
se=set({})
for i in range(n-k):
se.add(kk[i])
li=[-1]*n
li[0]=0
cur=1
while(dico[cur]):
xx=dico[cur].pop()
if(li[xx-1]==-1):
if(xx in se):
li[xx-1]=0
else:
li[xx-1]=1
else:
li[xx-1]+=li[cur-1]
cur=xx
ans=0
for i in se:
ans+=li[i-1]
print(ans)
``` | instruction | 0 | 21,343 | 1 | 42,686 |
No | output | 1 | 21,343 | 1 | 42,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2.
Submitted Solution:
```
n, k = map(int,input().split())
edge = []
edge2 = []
visit_city = [0] * (n+1)
visit_city2 = [0] * (n+1)
for i in range(n+1):
edge.append([])
edge2.append([])
for i in range(n-1):
u,v = map(int,input().split())
edge[v].append(u) # εΈ°γγγ
edge[u].append(v) # εΈ°γγγ
edge2[u].append(v) # θ‘γγγ
edge2[v].append(u) # εΈ°γγγ
# print(edge)
# print(edge2)
def dfs(start):
stack = [start]
used = set()
used.add(start)
while stack:
here = stack.pop()
visit_city[here] += 1
if here == 1:
pass
else:
for i in edge[here]:
if i not in used:
if visit_city2[i] > visit_city2[here]:
pass
else:
stack.append(i)
used.add(i)
def dfs2(start):
stack = [start]
used = set()
used.add(start)
while stack:
here = stack.pop()
for i in edge2[here]:
if i not in used:
stack.append(i)
used.add(i)
visit_city2[i] = visit_city2[here] + 1
dfs2(1)
# print(visit_city2)
path_dfs = []
for i in range(1,n+1):
path_dfs.append((i,visit_city2[i]))
path_dfs.sort(key=lambda x:x[1], reverse=True)
# print(path_dfs, "path")
for i in range(len(path_dfs)):
dfs(path_dfs[i][0])
# print(visit_city)
cnt = []
for i in range(1, n+1):
cnt.append((i, visit_city[i], visit_city2[i]))
cnt.sort(key=lambda x:(x[1], -x[2]))
edge_cnt = 0
# print(cnt)
for i in range(k, len(cnt)):
# print(visit_city2[cnt[i][0]])
edge_cnt += visit_city2[cnt[i][0]]
# print(edge_cnt)
all_u = 0
for i in range(k, len(cnt)):
all_u += cnt[i][1]
print(all_u - (n-k) - edge_cnt)
``` | instruction | 0 | 21,344 | 1 | 42,688 |
No | output | 1 | 21,344 | 1 | 42,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2.
Submitted Solution:
```
import sys,threading
def dfs(adj,x,v,t,d,s):
v[x]=1
t1=t
for y in adj[x]:
if v[y]==0:
dfs(adj,y,v,t1+1,d,s)
s[x]+=s[y]
d.append((t,s[x]))
return
def main():
n,k=list(map(int,input().split()))
adj=[[] for i in range(n+1)]
for i in range(n-1):
a,b=list(map(int,input().split()))
adj[a].append(b)
adj[b].append(a)
v=[0]*(n+1)
v[1]=1
d=[]
s=[1]*(n+1)
dfs(adj,1,v,0,d,s)
d.sort(key=lambda x:(-(x[0]-x[1]+1)))
ans=0
for i in range(k):
ans=ans+d[i][0]-d[i][1]+1
print(ans)
if __name__ == "__main__":
sys.setrecursionlimit(1000000)
threading.stack_size(10**6)
thread = threading.Thread(target=main)
thread.start()
thread.join()
``` | instruction | 0 | 21,345 | 1 | 42,690 |
No | output | 1 | 21,345 | 1 | 42,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Writing light novels is the most important thing in Linova's life. Last night, Linova dreamed about a fantastic kingdom. She began to write a light novel for the kingdom as soon as she woke up, and of course, she is the queen of it.
<image>
There are n cities and n-1 two-way roads connecting pairs of cities in the kingdom. From any city, you can reach any other city by walking through some roads. The cities are numbered from 1 to n, and the city 1 is the capital of the kingdom. So, the kingdom has a tree structure.
As the queen, Linova plans to choose exactly k cities developing industry, while the other cities will develop tourism. The capital also can be either industrial or tourism city.
A meeting is held in the capital once a year. To attend the meeting, each industry city sends an envoy. All envoys will follow the shortest path from the departure city to the capital (which is unique).
Traveling in tourism cities is pleasant. For each envoy, his happiness is equal to the number of tourism cities on his path.
In order to be a queen loved by people, Linova wants to choose k cities which can maximize the sum of happinesses of all envoys. Can you calculate the maximum sum for her?
Input
The first line contains two integers n and k (2β€ nβ€ 2 β
10^5, 1β€ k< n) β the number of cities and industry cities respectively.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is a road connecting city u and city v.
It is guaranteed that from any city, you can reach any other city by the roads.
Output
Print the only line containing a single integer β the maximum possible sum of happinesses of all envoys.
Examples
Input
7 4
1 2
1 3
1 4
3 5
3 6
4 7
Output
7
Input
4 1
1 2
1 3
2 4
Output
2
Input
8 5
7 5
1 7
6 1
3 7
8 3
2 1
4 5
Output
9
Note
<image>
In the first example, Linova can choose cities 2, 5, 6, 7 to develop industry, then the happiness of the envoy from city 2 is 1, the happiness of envoys from cities 5, 6, 7 is 2. The sum of happinesses is 7, and it can be proved to be the maximum one.
<image>
In the second example, choosing cities 3, 4 developing industry can reach a sum of 3, but remember that Linova plans to choose exactly k cities developing industry, then the maximum sum is 2.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 1000000007
INF = float('inf')
# ------------------------------
def main():
n, k = RL()
gp = defaultdict(list)
for _ in range(n-1):
a, b = RL()
gp[a].append(b)
gp[b].append(a)
q = [(1, 0)]
vis = [0]*(n+1)
rec = [0]*(n+1)
vis[1] = 1
sbrec = [1]*(n+1)
par = [0]*(n+1)
for nd, le in q:
rec[nd] = le
for nex in gp[nd]:
if vis[nex]: continue
vis[nex] = 1
par[nex] = nd
q.append((nex, le+1))
# print(rec)
for l, nd in sorted([(v, i+2) for i, v in enumerate(rec[2:])], reverse=1):
sbrec[par[nd]]+=sbrec[nd]
res = sorted([rec[i]-sbrec[i]+1 for i in range(n+1)], reverse=1)
print(sum(res[:k]))
if __name__ == "__main__":
main()
``` | instruction | 0 | 21,346 | 1 | 42,692 |
No | output | 1 | 21,346 | 1 | 42,693 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 β€ i β€ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 β€ n β€ 105; 1 β€ m β€ 106) β the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 β€ ti, Ti, xi, costi β€ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer β the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles. | instruction | 0 | 21,478 | 1 | 42,956 |
Tags: greedy
Correct Solution:
```
import math
n, m = [int(x) for x in input().split()]
num = 0
for i in range(n):
t, T, x, cost = [int(x) for x in input().split()]
if T >= (t + m):
num += cost
else:
if T > t:
k = T - t
num += min(x * m + cost, cost * (math.ceil(m / k)))
else:
num += x * m + cost
print(num)
``` | output | 1 | 21,478 | 1 | 42,957 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.