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 |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it. | instruction | 0 | 62,410 | 1 | 124,820 |
Tags: brute force, geometry, greedy, implementation
Correct Solution:
```
(n, sx, sy) = map(int, input().split())
boy = list()
for i in range(n):
(x, y) = map(int, input().split())
boy.append([x, y])
test = list()
test.append([0, sx, sy + 1])
test.append([0, sx + 1, sy])
test.append([0, sx, sy - 1])
test.append([0, sx - 1, sy])
for i in range(n):
if boy[i][1] > sy:
test[0][0] += 1
if boy[i][1] < sy:
test[2][0] += 1
if boy[i][0] < sx:
test[3][0] += 1
if boy[i][0] > sx:
test[1][0] += 1
for i in range(4):
if test[i][1] < 0 or test[i][2] < 0:
test[i][0] = 0
if test[i][1] > 10**9 or test[i][2] > 10**9:
test[i][0] = 0
test.sort(reverse=True)
print(test[0][0])
print(test[0][1], test[0][2])
``` | output | 1 | 62,410 | 1 | 124,821 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it. | instruction | 0 | 62,411 | 1 | 124,822 |
Tags: brute force, geometry, greedy, implementation
Correct Solution:
```
import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
###################################################
def num():
return int(input())
def line():
return map(int, input().split())
from itertools import repeat
from operator import itemgetter as ig
def sign(x):
if x==0:
return 0
if x>0:
return 1
return -1
n,*s = line()
q = [0,0,0,0]
for x,y in (line() for _ in repeat(None, n)):
x,y = x-s[0],y-s[1]
if x>0:
q[0]+=1
if x<0:
q[1]+=1
if y>0:
q[2]+=1
if y<0:
q[3]+=1
v = max(enumerate(q), key=ig(1))
print(v[1])
if v[0]==0:
print(s[0]+1, s[1])
if v[0]==1:
print(s[0]-1, s[1])
if v[0]==2:
print(s[0], s[1]+1)
if v[0]==3:
print(s[0], s[1]-1)
``` | output | 1 | 62,411 | 1 | 124,823 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it. | instruction | 0 | 62,412 | 1 | 124,824 |
Tags: brute force, geometry, greedy, implementation
Correct Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
#from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br #c++ upperbound br(array,element)
from collections import defaultdict
def main():
n,sx,sy=map(int,input().split(" "))
cnt1=0
cnt2=0
cnt3=0
cnt4=0
cnt5=0
cnt6=0
cnt7=0
cnt8=0
for x in range(n):
a,b=map(int,input().split(" "))
if a>sx and b>sy:
cnt1+=1
if a<sx and b>sy:
cnt2+=1
if a<sx and b<sy:
cnt3+=1
if a>sx and b<sy:
cnt4+=1
if a==sx and b>sy:
cnt5+=1
if a==sx and b<sy:
cnt6+=1
if b==sy and a>sx:
cnt7+=1
if b==sy and a<sx:
cnt8+=1
if max(cnt1+cnt2+cnt5,cnt3+cnt4+cnt6,cnt2+cnt3+cnt8,cnt1+cnt4+cnt7)==cnt1+cnt2+cnt5:
print(cnt1+cnt2+cnt5)
print(sx,sy+1)
elif max(cnt1+cnt2+cnt5,cnt3+cnt4+cnt6,cnt2+cnt3+cnt8,cnt1+cnt4+cnt7)==cnt3+cnt4+cnt6:
print(cnt3+cnt4+cnt6)
print(sx,sy-1)
elif max(cnt1+cnt2+cnt5,cnt3+cnt4+cnt6,cnt2+cnt3+cnt8,cnt1+cnt4+cnt7)==cnt2+cnt3+cnt8:
print(cnt2+cnt3+cnt8)
print(sx-1,sy)
elif max(cnt1+cnt2+cnt5,cnt3+cnt4+cnt6,cnt2+cnt3+cnt8,cnt1+cnt4+cnt7)==cnt1+cnt4+cnt7:
print(cnt1+cnt4+cnt7)
print(sx+1,sy)
#-----------------------------BOSS-------------------------------------!
# 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")
# endregion
if __name__ == "__main__":
main()
``` | output | 1 | 62,412 | 1 | 124,825 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it. | instruction | 0 | 62,413 | 1 | 124,826 |
Tags: brute force, geometry, greedy, implementation
Correct Solution:
```
import sys
def LI():
return map(int, sys.stdin.readline().split())
[N, sx, sy] = LI()
pts = [(0, 1), (1, 0), (0, -1), (-1, 0)]
v = [0] * 4
for _ in range(N):
[x, y] = LI()
if x > sx: v[1] += 1
if x < sx: v[3] += 1
if y > sy: v[0] += 1
if y < sy: v[2] += 1
c = [(v, x, y) for (v, x, y) in
[(v[i], sx + pts[i][0], sy + pts[i][1]) for i in range(4)]
if 0 <= x <= 10**9 and 0 <= y <= 10**9]
(v, x, y) = max(c, key=lambda t: t[0])
print(v)
print(x, y)
``` | output | 1 | 62,413 | 1 | 124,827 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it. | instruction | 0 | 62,414 | 1 | 124,828 |
Tags: brute force, geometry, greedy, implementation
Correct Solution:
```
from sys import stdin, stdout
input = stdin.readline
def inputnums():
return(map(int,input().split()))
n, sx, sy = inputnums()
N = 0
S = 0
E = 0
W = 0
for i in range(n):
l = [int(x) for x in input().split(' ')]
if l[1] > sy:
N += 1
elif l[1] < sy:
S += 1
if l[0] > sx:
E += 1
elif l[0] < sx:
W += 1
mx = max([N, S, E, W])
print(mx)
if N == mx:
print(sx, sy+1)
elif S == mx:
print(sx, sy-1)
elif E == mx:
print(sx+1, sy)
else:
print(sx-1, sy)
``` | output | 1 | 62,414 | 1 | 124,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
Submitted Solution:
```
n,sx,sy=map(int,input().split())
t1,t2=sx-1,sy
t3,t4=sx+1,sy
t5,t6=sx,sy+1
t7,t8=sx,sy-1
c1,c2,c3,c4=0,0,0,0
for i in range(n):
x,y=map(int,input().split())
temp=abs(sx-x)+abs(sy-y)
if(temp)>=(abs(t1-x)+abs(t2-y)):
c1+=1
if(temp)>=(abs(t3-x)+abs(t4-y)):
c2+=1
if(temp)>=(abs(t5-x)+abs(t6-y)):
c3+=1
if(temp)>=(abs(t7-x)+abs(t8-y)):
c4+=1
count = max(c1,c2,c3,c4)
if(count==c1):
print(c1)
print(t1,t2)
#print(t2)
elif(count==c2):
print(c2)
print(t3,t4)
#print(t4)
elif(count==c3):
print(c3)
print(t5,t6)
#print(t6)
elif(count==c4):
print(c4)
print(t7,t8)
# ?print(t8)
``` | instruction | 0 | 62,415 | 1 | 124,830 |
Yes | output | 1 | 62,415 | 1 | 124,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
Submitted Solution:
```
from sys import stdin
n, x, y = map(int, input().split())
right, up, left, down = 0, 0, 0, 0
for i in range(n):
xi, yi = map(int, stdin.readline().split())
if xi > x:
right += 1
if yi > y:
up += 1
if xi < x:
left += 1
if yi < y:
down += 1
c = max(right, up, left, down)
print(c)
if right == c:
print(x + 1, y)
elif up == c:
print(x, y + 1)
elif left == c:
print(x - 1, y)
elif down == c:
print(x, y - 1)
# noinspection PyShadowingBuiltins
def input():
return stdin.readline().rstrip("\r\n")
``` | instruction | 0 | 62,416 | 1 | 124,832 |
Yes | output | 1 | 62,416 | 1 | 124,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
Submitted Solution:
```
import sys
def main():
input = sys.stdin.read()
data = list(map(int, input.split()))
n, x, y = data[0:3]
idx = [0]*5
# print(x,y)
for i in range(3,len(data),2):
# print(data[i], data[i+1])
if data[i] > x:
idx[1] += 1
elif data[i] < x:
idx[2] += 1
if data[i+1] > y:
idx[3] += 1
elif data[i+1] < y:
idx[4] += 1
nt = 0
ans = 0
for i in range(1,5):
if idx[i] > ans:
ans = idx[i]
nt = i
# print(nt)
# print(idx)
print(ans)
if nt == 1:
print(str(x+1) + " " + str(y))
elif nt == 2:
print(str(x-1) + " " + str(y))
elif nt == 3:
print(str(x) + " " + str(y+1))
else:
print(str(x) + " " + str(y-1))
if __name__ == '__main__':
main()
``` | instruction | 0 | 62,417 | 1 | 124,834 |
Yes | output | 1 | 62,417 | 1 | 124,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
Submitted Solution:
```
a,b,c=map(int,input().split())
l,r,u1,d1=0,0,0,0
for _ in " "*a:
u,v=map(int,input().split())
if u==b:
if v<c:l+=1
else:r+=1
elif v==c:
if u<b:u1+=1
else:d1+=1
elif u>b and v<c:l+=1;d1+=1
elif u<b and v<c:l+=1;u1+=1
elif u<b and v>c:u1+=1;r+=1
else:d1+=1;r+=1
print(max(l,r,d1,u1))
if max(l,r,d1,u1)==l:print(b,c-1)
elif max(l,r,d1,u1)==r:print(b,c+1)
elif max(l,r,d1,u1)==u1:print(b-1,c)
else:print(b+1,c)
``` | instruction | 0 | 62,418 | 1 | 124,836 |
Yes | output | 1 | 62,418 | 1 | 124,837 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
pr=stdout.write
raw_input = stdin.readline
def ni():
return int(raw_input())
def li():
return list(map(int,raw_input().split()))
def pn(n):
stdout.write(str(n)+'\n')
def pa(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
n,sx,sy=li()
c1,c2,c3,c4=0,0,0,0
for i in range(n):
x,y=li()
if x>sx:
c1+=1
if x<sx:
c2+=1
if y>sy:
c3+=1
if y<sy:
c4+=1
mx=max(c1,c2,c3,c4)
pn(mx)
if mx==c1:
pa([sx+1,sy])
elif mx==c2:
pa([sx-1,sy])
elif mx==c3:
pa([sx,sy+1])
else:
pa([sx,sy-1])
``` | instruction | 0 | 62,419 | 1 | 124,838 |
Yes | output | 1 | 62,419 | 1 | 124,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
Submitted Solution:
```
def zip_sorted(a,b): return zip(*sorted(zip(a,b)))[0],zip(*sorted(zip(a,b)))[1]
def gcd(a,b): return math.gcd(a,b)
def lcm(a,b): return ((a*b)//math.gcd(a,b))
def ncr(n,r): return math.comb(n,r)
def npr(n,r): return (math.factorial(n)//math.factorial(n-r))
def decimal_to_binary(n): return bin(n).replace("0b", "")
def binary_to_decimal(s): return int(s,2)
import sys, os.path
import math
from collections import defaultdict,deque
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
S = lambda : list(map(str,input1()))
def main():
n,sx,sy = I()
x_1= []
y_1= []
x_2= []
y_2= []
x_3= []
y_3= []
x_4= []
y_4= []
y_p= []
y_n= []
x_p= []
x_n= []
for i in range(n):
xi,yi = I()
if xi==sx:
if yi-sy>0:
y_p.append(yi)
else:
y_n.append(yi)
elif yi==sy:
if xi-sx>0:
x_p.append(xi)
else:
x_n.append(xi)
elif xi-sx>0:
if yi-sy>0:
x_1.append(xi)
y_1.append(yi)
elif yi-sy<0:
x_4.append(xi)
y_4.append(yi)
elif xi-sx<0:
if yi-sy>0:
x_2.append(xi)
y_2.append(yi)
elif yi-sy<0:
x_3.append(xi)
y_3.append(yi)
x_1 = x_1+x_4+x_p
x_2 = x_2+x_3+x_n
y_1 = y_1+y_2+y_p
y_3 = y_3+y_4+y_n
x_1 = sorted(x_1)
x_2 = sorted(x_2)
y_1 = sorted(y_1)
y_2 = sorted(y_3)
if len(x_1)==max(len(x_1),len(x_2),len(y_1),len(y_2)):
print(len(x_1))
print(min(x_1),sy)
elif len(x_2)==max(len(x_1),len(x_2),len(y_1),len(y_2)):
print(len(x_2))
print(min(x_2),sy)
elif len(y_1)==max(len(x_1),len(x_2),len(y_1),len(y_2)):
print(len(y_1))
print(sx,min(y_1))
elif len(y_2)==max(len(x_1),len(x_2),len(y_1),len(y_2)):
print(len(y_2))
print(sx,min(y_2))
main()
``` | instruction | 0 | 62,420 | 1 | 124,840 |
No | output | 1 | 62,420 | 1 | 124,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
Submitted Solution:
```
n,sx,sy = map(int,input().split())
l1 = 0;l2 = 0;u1 = 0;u2 = 0
for i in range(n):
x,y = map(int,input().split())
if(x>=sx and y>sy):
u1+=1
elif(x<sx and y>=sy):
u2+=1
elif(x>sx and y<=sy):
l2+=1
else:
l1+=1
A = [l1,l2,u1,u2]
print(max(A))
if(max(A)==u1):
print(sx,sy+1)
if(max(A)==u2):
print(sx-1,sy)
if(max(A)==l2):
print(sx+1,sy)
else:
print(sx,sy-1)
``` | instruction | 0 | 62,421 | 1 | 124,842 |
No | output | 1 | 62,421 | 1 | 124,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
Submitted Solution:
```
a,b,c=map(int,input().split())
t=(b,c)
lst_left=[]
lst_right=[]
lst_up=[]
lst_down=[]
for i in range(a):
n,m=map(int,input().split())
if n<b:
lst_right.append((n,m))
if n>b:
lst_left.append((n,m))
if m<c:
lst_up.append((n,m))
if m>c:
lst_down.append((n,m))
lst=[len(lst_left),len(lst_right),len(lst_up),len(lst_down)]
batman=max(lst)
print(batman)
if batman==lst[0]:
b+=1
if batman==lst[1]:
b-=1
if batman==lst[2]:
c-=1
if batman==lst[3]:
c+=1
print(b,c)
``` | instruction | 0 | 62,422 | 1 | 124,844 |
No | output | 1 | 62,422 | 1 | 124,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
Submitted Solution:
```
n, s_x, s_y = map(int, input().split())
east = west = north = south = 0
for i in range(n):
x, y = map(int, input().split())
if x < s_x:
west += 1
else:
east += 1
if y < s_y:
# south-west
south += 1
else:
north += 1
ans = max([east, west, north, south])
print(ans)
if east == ans:
print(s_x + 1, s_y)
elif west == ans:
print(s_x - 1, s_y)
elif north == ans:
print(s_x, s_y + 1)
else:
print(s_x, s_y-1)
``` | instruction | 0 | 62,423 | 1 | 124,846 |
No | output | 1 | 62,423 | 1 | 124,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements. | instruction | 0 | 62,495 | 1 | 124,990 |
Tags: dsu, graphs, greedy
Correct Solution:
```
from collections import defaultdict
from math import ceil, sqrt, floor
from heapq import heappush,heappop
import sys
inf = float("inf")
class DisjointSet:
def __init__(self, n):
self.n = n
self.par = [-1] * n
self.nc = n
def findParent(self, i):
if self.par[i] == -1:
return i #no parent yet
else:
var = self.findParent(self.par[i])
self.par[i] = var
return var
def union(self, a, b):
aPar = self.findParent(a)
bPar = self.findParent(b)
if aPar != bPar:
self.par[aPar] = bPar
self.nc -= 1
def numComponents(self):
return self.nc
def primMSTFaster(adj, source=0):
edgesUsed = set()
fringe = list()
start = (0, source, None) # dist, node, parent
heappush(fringe, start)
mstSet = set()
key = defaultdict(lambda: None)
key[source] = 0
while len(fringe) > 0:
curTup = heappop(fringe)
curCost = curTup[0]
cur = curTup[1]
curParent = curTup[2]
if cur in mstSet:
continue
mstSet.add(cur)
if curParent is not None:
edgesUsed.add((curParent, cur, curCost))
for neighborTup in adj[cur]:
neighbor = neighborTup[0]
cost = neighborTup[1]
if (cost != -1) and (neighbor not in mstSet) and (key[neighbor] is None or key[neighbor] > cost):
key[neighbor] = cost
heappush(fringe, (cost, neighbor, cur))
return edgesUsed, key
'''def primMST(adj, source=0):
edgesUsed = set()
fringe = list()
start = (0, source, None) # dist, node, parent
heappush(fringe, start)
mstSet = set()
key = defaultdict(lambda: None)
key[source] = 0
parent = defaultdict(lambda: None)
while len(fringe) > 0:
curTup = heappop(fringe)
curCost = curTup[0]
cur = curTup[1]
curParent = curTup[2]
if cur in mstSet:
continue
mstSet.add(cur)
if curParent is not None:
edgesUsed.add((curParent, cur, cost))
parent[cur] = curParent
for neighbor in adj[cur]:
cost = adj[cur][neighbor]
if (neighbor not in mstSet) and (key[neighbor] is None or key[neighbor] > cost):
key[neighbor] = cost
heappush(fringe, (cost, neighbor, cur))
return edgesUsed, key, parent'''
t = int(input())
res = list()
for dsskfljl in range(t):
splitted = [int(amit) for amit in sys.stdin.readline().split(" ")]
n = splitted[0]
m = splitted[1]
k = splitted[2]
ds = DisjointSet(n)
edges = list()
minDelta = inf
minEdge = None
for i in range(m):
edge = [int(amit) for amit in sys.stdin.readline().split(" ")]
if edge[2] <= k:
ds.union(edge[0]-1, edge[1]-1)
edges.append((edge[0], edge[1], edge[2]))
if abs(edge[2] - k) < minDelta:
minDelta = abs(edge[2] - k)
minEdge = edge
if ds.numComponents() == 1:
# connected case, find edge with min |si - k| and make a spanning tree with this edge
totalCost = abs(minEdge[2] - k)
res.append(str(totalCost))
else:
# unconnected case, must add other edges
#adj = defaultdict(lambda: dict())
adj = list()
for i in range(n):
adj.append(set())
for edge in edges:
s = edge[0] - 1
t = edge[1] -1
cost = max(0, edge[2] - k)
adj[s].add((t, cost))
adj[t].add((s, cost))
mst = primMSTFaster(adj, 0)
edgesUsed = mst[0]
#print (edgesUsed)
totalCost = 0
for edge in edgesUsed:
#print (edge)
cost = edge[2]
totalCost += cost
res.append(str(totalCost))
sys.stdout.write("\n".join(res))
``` | output | 1 | 62,495 | 1 | 124,991 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements. | instruction | 0 | 62,496 | 1 | 124,992 |
Tags: dsu, graphs, greedy
Correct Solution:
```
"""
Author - Satwik Tiwari .
15th Dec , 2020 - Tuesday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O 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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def testcase(t):
for pp in range(t):
solve(pp)
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))
def find(self, a):
acopy = a
while a != self.parent[a]:
a = self.parent[a]
while acopy != a:
self.parent[acopy], acopy = a, self.parent[acopy]
return a
def merge(self, a, b):
self.parent[self.find(b)] = self.find(a)
def kruskal(n, U, V, W):
union = UnionFind(n)
cost, merge_cnt = 0, 0
mst_u, mst_v = [], []
order = sorted(range(len(W)), key=lambda x: W[x])
taken = []
for i in range(len(W)):
u, v = U[order[i]], V[order[i]]
find_u, find_v = union.find(u), union.find(v)
if find_u != find_v:
cost += W[order[i]]
merge_cnt += 1
union.parent[find_v] = find_u
mst_u.append(u), mst_v.append(v)
taken.append(order[i])
if(merge_cnt == n-1):
break
return taken
def solve(case):
n,m,k = sep()
u = []
v = []
w = []
for i in range(m):
a,b,c = sep()
a-=1
b-=1
u.append(a)
v.append(b)
w.append(c)
ans = 0
f = True
taken = kruskal(n,u,v,w)
currmax = -inf
have = set()
for i in taken:
have.add(i)
currmax = max(currmax,w[i])
if(w[i] >= k):
f = False
ans += abs(k - w[i])
# print(w)
# print(taken)
if(f):
ans = abs(k - currmax)
for i in range(m):
if(i in have):
continue
if(w[i] > currmax):
ans = min(ans,abs(k - w[i]))
print(ans)
else:
print(ans)
# ans = abs(k - currmax)
# for i in range(m):
# if(i in have):
# continue
# if(w[i] <= currmax):
# continue
# ans = min(ans,abs(k-w[i]))
#
# print(ans)
# testcase(1)
testcase(int(inp()))
``` | output | 1 | 62,496 | 1 | 124,993 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements. | instruction | 0 | 62,497 | 1 | 124,994 |
Tags: dsu, graphs, greedy
Correct Solution:
```
from collections import defaultdict
class DisjointSet:
def __init__(self, element_num=None):
self._father = {}
self._rank = {}
if element_num is not None:
for i in range(element_num):
self.add(i)
def add(self, x):
if x in self._father:
return
self._father[x] = x
self._rank[x] = 0
def _query(self, x):
if self._father[x] == x:
return x
self._father[x] = self._query(self._father[x])
return self._father[x]
def merge(self, x, y):
if x not in self._father:
self.add(x)
if y not in self._father:
self.add(y)
x = self._query(x)
y = self._query(y)
if x == y:
return
if self._rank[x] < self._rank[y]:
self._father[x] = y
else:
self._father[y] = x
if self._rank[x] == self._rank[y]:
self._rank[x] += 1
def same(self, x, y):
return self._query(x) == self._query(y)
if __name__ == "__main__":
t = int(input())
for z in range(t):
n, m, k = list(map(int, input().split(' ')))
edges = []
for i in range(m):
u, v, s = list(map(int, input().split(' ')))
edges.append((u, v, s))
ret = 0
cur = 1e9
dset = DisjointSet(n + 1)
edges = sorted(edges, key=lambda x: x[2])
used = defaultdict(bool)
for i, e in enumerate(edges):
if dset.same(e[0], e[1]):
continue
else:
dset.merge(e[0], e[1])
ret += max(0, e[2] - k)
cur = min(cur, abs(e[2] - k))
used[i] = True
if ret > 0:
print(ret)
continue
else:
for i, e in enumerate(edges):
if used[i] or abs(e[2] - k) > cur:
continue
cur = abs(e[2] - k)
print(cur)
``` | output | 1 | 62,497 | 1 | 124,995 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements. | instruction | 0 | 62,498 | 1 | 124,996 |
Tags: dsu, graphs, greedy
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
def __init__(self, file):
self.newlines = 0
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()
# --------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def S(): return input().strip()
def print_list(l): print(' '.join(map(str, l)))
# sys.setrecursionlimit(100000)
# import random
# from functools import reduce
# from functools import lru_cache
# from heapq import *
# from collections import deque as dq
# from math import gcd
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
##########################
## code from silvertint ##
##########################
class DSU:
def __init__(self, n):
self.uf = {i: i for i in range(n)}
self.rank = {i: 1 for i in range(n)}
def find(self, x):
if self.uf[x] != x:
self.uf[x] = self.find(self.uf[x])
return self.uf[x]
def union(self, x, y):
px, py = self.find(x), self.find(y)
if px != py:
if self.rank[px] > self.rank[py]:
px, py = py, px
self.rank[py] += self.rank[px]
self.uf[px] = py
return True
return False
for _ in range(N()):
n, m, k = RL()
edges = sorted([RLL() for _ in range(m)], key=lambda x: x[2])
dsu = DSU(n)
ans = 0
for x, y, t in edges:
if dsu.union(x - 1, y - 1):
ans += max(0, t - k)
if ans <= 0:
ans = min(abs(p[2] - k) for p in edges)
print(ans)
``` | output | 1 | 62,498 | 1 | 124,997 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements. | instruction | 0 | 62,499 | 1 | 124,998 |
Tags: dsu, graphs, greedy
Correct Solution:
```
"""
#If FastIO not needed, use this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
import time
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
#start_time = time.time()
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def getMat(n):
return [getInts() for _ in range(n)]
def isInt(s):
return '0' <= s[0] <= '9'
MOD = 10**9 + 7
"""
Take an edge as close as possible in value to K, and build out the minimum spanning tree from that?
Delete edges greedily except for one single edge as close as possible to K
"""
def solve():
N, M, K = getInts()
edges = []
for m in range(M):
x,y,s = getInts()
edges.append((s,x-1,y-1))
edges.sort()
#print(edges)
#MST1
def find(a):
if a != p[a]:
p[a] = find(p[a])
return p[a]
def union(a, b):
a, b = find(a), find(b)
if a == b: return
if size[a] > size[b]:
a, b = b, a
p[a] = b
size[b] += size[a]
return
p = [i for i in range(N)]
size = [1]*N
ans1 = 0
best = 10**18
best_ind = -1
i = 0
for s,x,y in edges:
if find(x) != find(y):
union(x,y)
ans1 += max(0,s-K)
max_used = s
diff = abs(s-K)
if diff < best:
best = diff
best_ind = i
i += 1
if not ans1: ans1 += abs(K-max_used)
ans2 = best
i = 0
p = [i for i in range(N)]
size = [1]*N
s,x,y = edges[best_ind]
union(x,y)
for s,x,y in edges:
if find(x) != find(y):
union(x,y)
ans2 += max(0,s-K)
#print(ans1,ans2)
return min(ans1,ans2)
for _ in range(getInt()):
print(solve())
#solve()
#print(time.time()-start_time)
``` | output | 1 | 62,499 | 1 | 124,999 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements. | instruction | 0 | 62,500 | 1 | 125,000 |
Tags: dsu, graphs, greedy
Correct Solution:
```
import math
from sys import stdin
def uf_find(n,p):
ufl = []
while p[n] != n:
ufl.append(n)
n = p[n]
for i in ufl:
p[i] = n
return n
def uf_union(a,b,p,rank):
ap = uf_find(a,p)
bp = uf_find(b,p)
if ap == bp:
return True
else:
if rank[ap] > rank[bp]:
p[bp] = ap
elif rank[ap] < rank[bp]:
p[ap] = bp
else:
p[bp] = ap
rank[ap] += 1
return False
tt = int(input())
for loop in range(tt):
n,m,k = map(int,input().split())
under = []
over = []
for i in range(m):
x,y,s = map(int,input().split())
x -= 1
y -= 1
if s <= k:
under.append( (s,x,y) )
else:
over.append( (s,x,y) )
under.sort()
over.sort()
ans = float("inf")
cnt = 0
p = [i for i in range(n)]
rank = [0] * n
for c,x,y in under:
if not uf_union(x,y,p,rank):
cnt += 1
if cnt == n-1 and len(under) > 0:
ans = min(ans,k-under[-1][0])
if cnt != n-1:
tmpsum = 0
for c,x,y in over:
if not uf_union(x,y,p,rank):
cnt += 1
tmpsum += c-k
if cnt == n-1:
ans = min(ans , tmpsum)
elif len(over) > 0: ans = min(ans,over[0][0]-k)
print (ans)
``` | output | 1 | 62,500 | 1 | 125,001 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements. | instruction | 0 | 62,501 | 1 | 125,002 |
Tags: dsu, graphs, greedy
Correct Solution:
```
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
import sys
from collections import defaultdict
def merge(a,b):
par[a]=b
def find(a):
if par[a]==-1:
return a
stack=[]
while par[a]!=-1:
stack.append(a)
a=par[a]
while stack:
par[stack.pop()]=a
return a
def dfs(node):
vis[node]=1
stack=[node]
ans=0
while stack:
cur=stack.pop()
ans+=1
for j in edge2[cur]:
if vis[j[0]]==0:
vis[j[0]]=1
stack.append(j[0])
return ans
t=int(input())
for _ in range(t):
n,m,k=list(map(int,input().split()))
lis=[]
edge2=defaultdict(list)
arr=[]
for i in range(m):
u,v,x=list(map(int,input().split()))
arr.append([u,v,x])
if x<=k:
edge2[u].append([v,x])
edge2[v].append([u,x])
lis.append(x)
vis=[0]*(n+1)
a=dfs(1)
if a==n:
ans=sys.maxsize
for i in range(m):
ans=min(ans,abs(k-arr[i][2]))
print(ans)
else:
y=0
z=0
par=[-1]*(n+1)
arr.sort(key=lambda x:x[2],reverse=False)
ans=0
for i in range(m):
a=find(arr[i][0])
b=find(arr[i][1])
if a!=b:
ans+=arr[i][2]
merge(a,b)
if arr[i][2]>k:
z+=1
else:
y+=arr[i][2]
print(ans-y-(z*k))
``` | output | 1 | 62,501 | 1 | 125,003 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements. | instruction | 0 | 62,502 | 1 | 125,004 |
Tags: dsu, graphs, greedy
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Wed Jan 13 16:13:20 2021
@author: kissz
"""
import sys
def generate_testcase():
import random
with open('in.txt','w') as f:
print(1,file=f)
print(200000,200000,500000,file=f)
data=[(i,i+1,random.randint(1, 1000000)) for i in range(1,200000)]+\
[(96012,176243,random.randint(1, 1000000))]
random.shuffle(data)
for row in data: print(*row,file=f)
#@profile
def main(input_fcn=sys.stdin.readline):
for _ in range(int(input_fcn())):
#eprint('new test')
n,m,k=map(int,input_fcn().split())
#eprint(n,m,k)
roads0=[(0,0)]*m
m0=0
roads1=[(0,0,0)]*m
m1=0
for _ in range(m):
s,d,lim=map(int,input_fcn().split())
if lim>k:
roads1[m1]=(lim-k,s,d)
m1+=1
else:
roads0[m0]=(k-lim,s,d)
m0+=1
roads1=sorted(roads1[:m1])
#eprint(roads0)
#eprint(roads1)
res=0
parent=[i for i in range(n+1)]
for i in range(m0):
_,s,d=roads0[i]
ps,pd=s,d
while parent[ps]!=ps:
ps=parent[ps]
while parent[pd]!=pd:
pd=parent[pd]
if ps!=pd:
parent[s]=ps
parent[d]=ps
parent[pd]=ps
else:
parent[s]=ps
parent[d]=ps
for i in range(m1):
mod,s,d = roads1[i]
ps,pd=s,d
while parent[ps]!=ps:
ps=parent[ps]
while parent[pd]!=pd:
pd=parent[pd]
if ps!=pd:
res+=mod
parent[s]=ps
parent[d]=ps
parent[pd]=ps
else:
parent[s]=ps
parent[d]=ps
#eprint(parent)
#eprint(res)
if not res:
if roads0: corr=min(roads0[i][0] for i in range(m0))
else: corr=1e30
#eprint('corr',corr)
if roads1: corr=min(corr,roads1[0][0])
#eprint('corr',corr)
res+= int(corr)
print(res)
if __name__=='__main__':
main()
else:
def eprint(*args):
print(*args,file=sys.stderr)
``` | output | 1 | 62,502 | 1 | 125,005 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements.
Submitted Solution:
```
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))
def find(self, a): #return parent of a. a and b are in same set if they have same parent
acopy = a
while a != self.parent[a]:
a = self.parent[a]
while acopy != a: #path compression
self.parent[acopy], acopy = a, self.parent[acopy]
return a
def union(self, a, b): #union a and b
self.parent[self.find(b)] = self.find(a)
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
allAns=[]
t=int(input())
for _ in range(t):
n,m,k=[int(x) for x in input().split()]
uvw=[]
for __ in range(m):
uvw.append([int(x) for x in input().split()])
uvw.sort(key=lambda x:x[2]) #sort by weight asc
uf=UnionFind(n+1)
weights=[]
for u,v,w in uvw:
if uf.find(u)!=uf.find(v):
weights.append(w)
uf.union(u,v)
ans=0
for w in weights:
ans+=max(0,w-k)
if ans==0: #all smaller. find the edge closest to k.
minDelta=float('inf')
for u,v,w in uvw:
minDelta=min(minDelta,abs(w-k))
ans=minDelta
allAns.append(ans);
multiLineArrayPrint(allAns)
``` | instruction | 0 | 62,503 | 1 | 125,006 |
Yes | output | 1 | 62,503 | 1 | 125,007 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
from collections import defaultdict
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def find(u):
if parent[u]==u:
return u
parent[u]=find(parent[u])
return parent[u]
def union(a,b):
u=parent[a]
v=parent[b]
if size[u]>size[v]:
parent[v]=u
size[u]+=size[v]
else:
parent[u] = v
size[v] += size[u]
for _ in range(int(input())):
n,m,k=map(int,input().split())
edges=[]
for j in range(m):
u,v,s=map(int,input().split())
edges.append([s,u,v])
edges.sort()
ind1=-1
ind2=-1
for j in range(m):
if edges[j][0]>=k:
ind1=j
break
else:
ind2=j
ans=float("inf")
if ind1!=-1:
parent=[i for i in range(n+1)]
size = [1 for i in range(n + 1)]
req=abs(edges[ind1][0]-k)
u,v=edges[ind1][1],edges[ind1][2]
union(u,v)
cnt=1
for e in range(m):
if e!=ind1:
j=edges[e]
if cnt==n-1:
break
val,u, v = j[0],j[1],j[2]
if find(u)!=find(v):
union(u,v)
cnt+=1
if val>k:
req+=(val-k)
ans=req
ind1=ind2
if ind1 != -1:
parent = [i for i in range(n + 1)]
size = [1 for i in range(n + 1)]
req = abs(k-edges[ind1][0])
u, v = edges[ind1][1], edges[ind1][2]
if find(u) != find(v):
union(u, v)
cnt = 1
for e in range(m):
if e!=(ind1):
j=edges[e]
if cnt == n - 1:
break
val, u, v = j[0], j[1], j[2]
if find(u) != find(v):
union(u, v)
cnt += 1
if val > k:
req += (val - k)
ans = min(ans,req)
parent = [i for i in range(n + 1)]
size = [1 for i in range(n + 1)]
edges1 = []
cnt = 0
req=0
m=0
for j in edges:
if cnt == n - 1:
break
val, u, v = j[0], j[1], j[2]
m=max(m,val)
if find(u) != find(v):
union(u, v)
cnt += 1
if val > k:
req += (val - k)
if m<k:
req+=abs(k-m)
ans=min(ans,req)
print(ans)
``` | instruction | 0 | 62,504 | 1 | 125,008 |
Yes | output | 1 | 62,504 | 1 | 125,009 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements.
Submitted Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
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")
# ------------------- fast io --------------------
#union find
def find(node):
comp=[]
while group[node]!=node:
comp.append(node)
node=group[node]
for i in comp:
group[i]=node
return group[node]
for j in range(int(input())):
n,m,k=map(int,input().split())
#cities, roads and speed limit
group=[s for s in range(n)]
info=[];nearest=10**10
for s in range(m):
x,y,s1=map(int,input().split())
x-=1;y-=1
if abs(k-s1)<abs(k-nearest):
nearest=s1
if s1<=k:
info.append((x,y,0))
else:
info.append((x,y,s1-k))
info.sort(key=lambda x: x[2])
#minimum spanning tree
ans=0
for s in range(m):
edge=(info[s][0],info[s][1]);cost=info[s][2]
#check if theyre unified
g1=find(edge[0]);g2=find(edge[1])
if g1!=g2:
#connect them
group[g2]=g1
ans+=cost
if ans!=0:
print(ans)
else:
print(abs(k-nearest))
``` | instruction | 0 | 62,505 | 1 | 125,010 |
Yes | output | 1 | 62,505 | 1 | 125,011 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements.
Submitted Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
def find(parent,x):
if x == parent[x]:
return x
parent[x] = find(parent,parent[x])
return parent[x]
def union(parent,a,b,rank):
a,b = find(parent,a),find(parent,b)
if a != b:
if rank[a] < rank[b]:
a,b = b,a
parent[b] = a
if rank[a] == rank[b]:
rank[a] += 1
return 1
return 0
def main():
for x in range(int(input())):
n,m,k = map(int,input().split())
ed = [tuple(map(int,input().split())) for _ in range(m)]
ed1 = sorted(filter(lambda xx:xx[2] <= k,ed),key=lambda xx:xx[2],reverse=1)
ed = sorted(filter(lambda xx:xx[2] > k,ed),key=lambda xx:xx[2])
parent = list(range(n))
rank = [0]*n
conn = n
ans = 0
for i in ed1:
a,b = i[0]-1,i[1]-1
if union(parent,a,b,rank):
conn -= 1
if conn == 1:
break
if conn != 1:
for i in ed:
a,b = i[0]-1,i[1]-1
if union(parent,a,b,rank):
conn -= 1
ans += i[2]-k
if conn == 1:
break
else:
if not len(ed1):
ans = abs(ed[0][2]-k)
elif not len(ed):
ans = abs(ed1[0][2]-k)
else:
ans = min(abs(ed1[0][2]-k),abs(ed[0][2]-k))
print(ans)
# 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()
``` | instruction | 0 | 62,506 | 1 | 125,012 |
Yes | output | 1 | 62,506 | 1 | 125,013 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements.
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
#import threading
from collections import defaultdict
#threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
#sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=300006, func=lambda a, b: min(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b:a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
class TrieNode:
def __init__(self):
self.children = [None] * 26
self.isEndOfWord = False
class Trie:
def __init__(self):
self.root = self.getNode()
def getNode(self):
return TrieNode()
def _charToIndex(self, ch):
return ord(ch) - ord('a')
def insert(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
pCrawl.children[index] = self.getNode()
pCrawl = pCrawl.children[index]
pCrawl.isEndOfWord = True
def search(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
return False
pCrawl = pCrawl.children[index]
return pCrawl != None and pCrawl.isEndOfWord
#-----------------------------------------trie---------------------------------
class Node:
def __init__(self, data):
self.data = data
self.height=0
self.left = None # left node for 0
self.right = None # right node for 1
class BinaryTrie:
def __init__(self):
self.root = Node(0)
def insert(self, pre_xor):
self.temp = self.root
for i in range(31, -1, -1):
val = pre_xor & (1 << i)
if val==0:
if not self.temp.right:
self.temp.right = Node(0)
self.temp = self.temp.right
elif val>=1:
if not self.temp.left:
self.temp.left = Node(0)
self.temp = self.temp.left
def do(self,temp):
if not temp:
return 0
ter=temp
temp.height=self.do(ter.left)+self.do(ter.right)
if temp.height==0:
temp.height+=1
return temp.height
def query(self, xor):
self.temp = self.root
cur=0
i=31
while(i>-1):
val = xor & (1 << i)
if not self.temp:
return cur
if val>=1:
self.opp = self.temp.right
if self.temp.left:
self.temp = self.temp.left
else:
return cur
else:
self.opp=self.temp.left
if self.temp.right:
self.temp = self.temp.right
else:
return cur
if self.temp.height==pow(2,i):
cur+=1<<(i)
self.temp=self.opp
i-=1
return cur
#-------------------------bin trie-------------------------------------------
for ik in range(int(input())):
n,m,k=map(int,input().split())
ans=10**10
for i in range(m):
a,b,c=map(int,input().split())
ans=min(ans,abs(k-c))
print(ans)
``` | instruction | 0 | 62,507 | 1 | 125,014 |
No | output | 1 | 62,507 | 1 | 125,015 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements.
Submitted Solution:
```
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop
import math
from collections import *
from itertools import accumulate
from functools import reduce,cmp_to_key,lru_cache
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
import sys
# input = sys.stdin.readline
M = mod = 10**9 + 7
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip().split()]
def st():return str(input().rstrip())[2:-1]
def val():return int(input().rstrip())
def li2():return [str(i)[2:-1] for i in input().rstrip().split()]
def li3():return [int(i) for i in st()]
parents = 0
def giveparent(i):
global parents
l1 = []
while parents[i] != i:
l1.append(i)
i = parents[i]
for j in l1:parents[j] = i
return i
for _ in range(val()):
n, m, k = li()
l = []
ans = float('inf')
taken = None
for i in range(m):
a, b, c = li()
l.append([a, b, c])
if abs(c - k) < ans:
taken = i
ans = abs(c - k)
a, b, c = l[taken]
l = l[:taken] + l[taken + 1:]
# print(l)
l.sort(key = lambda x : x[-1])
# print(l)
visited = set()
parents = [i for i in range(n + 5)]
parents[a] = parents[b]
visited.add(a)
visited.add(b)
for a, b, c in l:
p1 = parents[a]
p2 = parents[b]
if p1 == p2:continue
parents[p1] = parents[p2]
visited.add(a)
visited.add(b)
if c > k:ans += c - k
if len(visited) == n:break
print(ans)
``` | instruction | 0 | 62,508 | 1 | 125,016 |
No | output | 1 | 62,508 | 1 | 125,017 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements.
Submitted Solution:
```
class PrioQueue:
def __init__(self, elist=None):
if elist is None:
elist = []
self._elems = list(elist)
if elist:
self.buildheap()
def is_empty(self):
return not self._elems
def peek(self):
if self.is_empty():
raise ValueError("in peek")
return self._elems[0]
def enqueue(self, e):
self._elems.append(e)
self.siftup(e, len(self._elems) - 1)
def siftup(self, e, last):
elem, i, j = self._elems, last, (last - 1) // 2
while j >= 0 and elem[i] < elem[j]:
elem[i], elem[j] = elem[j], elem[i]
i, j = j, (j - 1) // 2
def dequeue(self):
if self.is_empty():
raise ValueError("in dequeue")
e0 = self._elems[0]
e = self._elems.pop()
if len(self._elems) > 0:
self.siftdown(e, len(self._elems) - 1)
return e0
def siftdown(self, e, end):
elem, i, j = self._elems, 0, 1
while j <= end:
if j + 1 <= end and elem[j + 1] < elem[j]:
j += 1
if e <= elem[j]:
break
elem[i] = elem[j]
i, j = j, j * 2 + 1
elem[i] = e
def buildheap(self):
end = len(self._elems)
for i in range(end // 2, -1, -1):
self.siftdown(self._elems[i], -1)
def sol(lst, n, k):
min = lst[0]
count = 2
ans = 0
mlst = [0] * (n + 1)
dic = {lst[0][1]: [(lst[0][2], lst[0][0])], lst[0][2]: [(lst[0][1], lst[0][0])]}
for i in range(1, len(lst)):
r = lst[i]
if abs(r[0] - k) < abs(min[0] - k):
min = r
try:
dic[r[1]].append((r[2], r[0]))
except:
dic[r[1]] = [(r[2], r[0])]
try:
dic[r[2]].append((r[1], r[0]))
except:
dic[r[2]] = [(r[1], r[0])]
pq = PrioQueue()
for y, wn in dic[min[1]]:
if y != min[2]:
pq.enqueue((wn, min[1], y))
for y, wn in dic[min[2]]:
if y != min[1]:
pq.enqueue((wn, min[2], y))
mlst[min[1]] = mlst[min[2]] = 1
while count < n:
w, x1, x2 = pq.dequeue()
if mlst[x2]:
continue
count += 1
mlst[x2] = 1
if w > k:
ans += (w-k)
cb = dic[x2]
for y, wn in cb:
if not mlst[y]:
pq.enqueue((wn, x2, y))
if ans > 0 and min[0] <= k:
print(ans)
else:
print(ans + abs(min[0] - k))
t = int(input())
for qwq in range(t):
abk = input().split()
lst = []
for qw in range(int(abk[1])):
rt = input().split()
r = [int(rt[i]) for i in range(2, -1, -1)]
lst.append(r)
sol(lst, int(abk[0]), int(abk[2]))
``` | instruction | 0 | 62,509 | 1 | 125,018 |
No | output | 1 | 62,509 | 1 | 125,019 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m bidirectional roads in Berland. The i-th road connects the cities x_i and y_i, and has the speed limit s_i. The road network allows everyone to get from any city to any other city.
The Berland Transport Ministry is planning a road reform.
First of all, maintaining all m roads is too costly, so m - (n - 1) roads will be demolished in such a way that the remaining (n - 1) roads still allow to get to any city from any other city. Formally, the remaining roads should represent an undirected tree.
Secondly, the speed limits on the remaining roads might be changed. The changes will be done sequentially, each change is either increasing the speed limit on some road by 1, or decreasing it by 1. Since changing the speed limit requires a lot of work, the Ministry wants to minimize the number of changes.
The goal of the Ministry is to have a road network of (n - 1) roads with the maximum speed limit over all roads equal to exactly k. They assigned you the task of calculating the minimum number of speed limit changes they have to perform so the road network meets their requirements.
For example, suppose the initial map of Berland looks like that, and k = 7:
<image>
Then one of the optimal courses of action is to demolish the roads 1β4 and 3β4, and then decrease the speed limit on the road 2β3 by 1, so the resulting road network looks like that:
<image>
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains three integers n, m and k (2 β€ n β€ 2 β
10^5; n - 1 β€ m β€ min(2 β
10^5, (n(n-1))/(2)); 1 β€ k β€ 10^9) β the number of cities, the number of roads and the required maximum speed limit, respectively.
Then m lines follow. The i-th line contains three integers x_i, y_i and s_i (1 β€ x_i, y_i β€ n; x_i β y_i; 1 β€ s_i β€ 10^9) β the cities connected by the i-th road and the speed limit on it, respectively. All roads are bidirectional.
The road network in each test case is connected (that is, it is possible to reach any city from any other city by traveling along the road), and each pair of cities is connected by at most one road.
The sum of n over all test cases does not exceed 2 β
10^5. Similarly, the sum of m over all test cases does not exceed 2 β
10^5.
Output
For each test case, print one integer β the minimum number of changes the Ministry has to perform so that the maximum speed limit among the remaining (n - 1) roads is exactly k.
Example
Input
4
4 5 7
4 1 3
1 2 5
2 3 8
2 4 1
3 4 4
4 6 5
1 2 1
1 3 1
1 4 2
2 4 1
4 3 1
3 2 1
3 2 10
1 2 8
1 3 10
5 5 15
1 2 17
3 1 15
2 3 10
1 4 14
2 5 8
Output
1
3
0
0
Note
The explanation for the example test:
The first test case is described in the problem statement.
In the second test case, the road network initially looks like that:
<image>
The Ministry can demolish the roads 1β2, 3β2 and 3β4, and then increase the speed limit on the road 1β4 three times.
In the third test case, the road network already meets all the requirements.
In the fourth test case, it is enough to demolish the road 1β2 so the resulting road network meets the requirements.
Submitted Solution:
```
# https://codeforces.com/problemset/problem/1108/F
# AC
class Union:
def __init__(self, n):
self.p = [i for i in range(n+1)]
self.rank = [0] * (n+1)
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
self.p[x] = y
self.rank[y] += self.rank[x]
else:
self.p[y] = x
self.rank[x] += self.rank[y]
for _ in range(int(input())):
n, m, k = map(int, input().split())
edge = [list(map(int, input().split())) for _ in range(m)]
edge = sorted(edge,key=lambda x: x[2])
U = Union(n)
choose, diff = None, float('inf')
total = 0
for i in range(m):
if abs(edge[i][2] - k) < diff:
diff = abs(edge[i][2] - k)
choose = i
total += abs(edge[choose][2] - k)
u, v = edge[choose][:2]
U.union(u, v)
for i in range(m):
if i == choose: continue
u, v, w = edge[i]
if U.find(u) == U.find(v):
continue
U.union(u, v)
if w > k:
total += abs(w - k)
print(total)
``` | instruction | 0 | 62,510 | 1 | 125,020 |
No | output | 1 | 62,510 | 1 | 125,021 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track. | instruction | 0 | 62,531 | 1 | 125,062 |
Tags: combinatorics, greedy, math
Correct Solution:
```
import math
n=int(input())
while(n!=0):
n-=1
t=int(input())
a=list(map(int,input().split()))
new=0
for i in range(len(a)):
new+=a[i]
k=new%t
ans=k*(t-k)
print(ans)
``` | output | 1 | 62,531 | 1 | 125,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track. | instruction | 0 | 62,532 | 1 | 125,064 |
Tags: combinatorics, greedy, math
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
s = sum(a)
c2 = s % n
c1 = n - c2
print(c1 * c2)
``` | output | 1 | 62,532 | 1 | 125,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track. | instruction | 0 | 62,533 | 1 | 125,066 |
Tags: combinatorics, greedy, math
Correct Solution:
```
for _ in range(int(input())):
l = int(input())
nums = list(map(int, input().split()))
s = sum(nums)%l
print(s*(l-s))
``` | output | 1 | 62,533 | 1 | 125,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track. | instruction | 0 | 62,534 | 1 | 125,068 |
Tags: combinatorics, greedy, math
Correct Solution:
```
###### ### ####### ####### ## # ##### ### #####
# # # # # # # # # # # # # ###
# # # # # # # # # # # # # ###
###### ######### # # # # # # ######### #
###### ######### # # # # # # ######### #
# # # # # # # # # # #### # # #
# # # # # # # ## # # # # #
###### # # ####### ####### # # ##### # # # #
from __future__ import print_function # for PyPy2
# from itertools import permutations
# from functools import cmp_to_key # for adding custom comparator
# from fractions import Fraction
# from collections import *
from sys import stdin
# from bisect import *
from heapq import *
from math import log2, ceil, sqrt, gcd, log
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
rr = lambda x : reversed(range(x))
mod = int(1e9)+7
inf = float("inf")
# range = xrange
t, = gil()
for _ in range(t):
n, = gil()
a = gil()
md = sum(a)%n
print(md*(n-md))
``` | output | 1 | 62,534 | 1 | 125,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track. | instruction | 0 | 62,535 | 1 | 125,070 |
Tags: combinatorics, greedy, math
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
l = list(map(int, input().split()))
sum = 0
for i in l:
sum = sum + i
k = sum % n
print(k*(n-k))
``` | output | 1 | 62,535 | 1 | 125,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track. | instruction | 0 | 62,536 | 1 | 125,072 |
Tags: combinatorics, greedy, math
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
suma = 0
for x in a:
suma += x
diff = suma // n
larger = suma - diff * n
less = n - larger
print(less * larger)
``` | output | 1 | 62,536 | 1 | 125,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track. | instruction | 0 | 62,537 | 1 | 125,074 |
Tags: combinatorics, greedy, math
Correct Solution:
```
import collections
t = int(input())
for i in range(0,t):
n = int(input())
cars = list(map(int, input().split()))
cars = sorted(cars)
while (cars[n-1] - cars[0] > 1):
x = 0
y = n-1
while x<=y:
total = cars[x]+cars[y]
cars[x] = total//2
cars[y] = total - cars[x]
x += 1
y -= 1
cars = sorted(cars)
carval = []
for key in collections.Counter(cars).keys():
carval.append(key)
carnum = []
for val in collections.Counter(cars).values():
carnum.append(val)
incon = 0
for x in range(0, len(carval)):
for y in range(x+1, len(carval)):
temp = (carval[x]-carval[y])*(carnum[x]*carnum[y])
if temp<0:
temp *= -1
incon += temp
print(incon)
``` | output | 1 | 62,537 | 1 | 125,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track. | instruction | 0 | 62,538 | 1 | 125,076 |
Tags: combinatorics, greedy, math
Correct Solution:
```
import math
t=int(input())
for _ in range (t):
n=int(input())
l=list(map(int, input().split()))
total=sum(l)
avg=total/n
avgr=total//n
if avg==avgr:
print (0)
else:
c=round(((avg-avgr)*n))
ans=(c*(n-c))
print (int(ans))
``` | output | 1 | 62,538 | 1 | 125,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track.
Submitted Solution:
```
"""
Author : Preet Modh
"""
import sys,os
from difflib import SequenceMatcher
from collections import Counter
from bisect import bisect_left as bl,bisect_right as br
from io import BytesIO, IOBase
from itertools import accumulate
import math
"""
**All function calls:**
LCSubstr(a,b): for Longest Common Substring
gcd(x, y): greatest common divisor of x and y
prime_factors(n): Number of prime factor of n
distinct_factors(n): list of distinct factors of n
all_factors(n): list of all factors of n
is_prime(n): checks if n is prime
prime_list(n): all primes less than number of
modinv(a, m): modular inverse of a w.r.t. to m, works when a and m are coprime
make_nCr_mod()(n,r) value of ncr%mod
binarySearch(arr, l, r, x): binary search
PrefixSum(arr): prefix sum array
memodict(f): Memoization decorator for a function taking a single argument
memoize(f): Memoization decorator for a function taking one or more arguments
"""
# 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")
def memodict(f):
""" Memoization decorator for a function taking a single argument. """
class memodict(dict):
def __missing__(self, key):
ret = self[key] = f(key)
return ret
return memodict().__getitem__
def memoize(f):
""" Memoization decorator for a function taking one or more arguments. """
class memodict(dict):
def __getitem__(self, *key):
return dict.__getitem__(self, key)
def __missing__(self, key):
ret = self[key] = f(*key)
return ret
return memodict().__getitem__
LCSubstr = lambda a, b:SequenceMatcher(None, a, b).find_longest_match(0, len(a), 0, len(b))
""" THIS IS FOR for Longest Common Substring """
def gcd(x, y):
"""greatest common divisor of x and y"""
while y:
x, y = y, x % y
return x
def pollard_rho(n):
"""returns a random factor of n"""
if n & 1 == 0:
return 2
if n % 3 == 0:
return 3
s = ((n - 1) & (1 - n)).bit_length() - 1
d = n >> s
for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
p = pow(a, d, n)
if p == 1 or p == n - 1 or a % n == 0:
continue
for _ in range(s):
prev = p
p = (p * p) % n
if p == 1:
return gcd(prev - 1, n)
if p == n - 1:
break
else:
for i in range(2, n):
x, y = i, (i * i + 1) % n
f = gcd(abs(x - y), n)
while f == 1:
x, y = (x * x + 1) % n, (y * y + 1) % n
y = (y * y + 1) % n
f = gcd(abs(x - y), n)
if f != n:
return f
return n
@memodict
def prime_factors(n):
"""returns a Counter of the prime factorization of n"""
if n <= 1:
return Counter()
f = pollard_rho(n)
return Counter([n]) if f == n else prime_factors(f) + prime_factors(n // f)
def distinct_factors(n):
"""returns a list of all distinct factors of n"""
factors = [1]
for p, exp in prime_factors(n).items():
factors += [p**i * factor for factor in factors for i in range(1, exp + 1)]
return factors
def all_factors(n):
"""returns a sorted list of all distinct factors of n"""
small, large = [], []
for i in range(1, int(n**0.5) + 1, 2 if n & 1 else 1):
if not n % i:
small.append(i)
large.append(n // i)
if small[-1] == large[-1]:
large.pop()
large.reverse()
small.extend(large)
return small
def is_prime(n):
"""returns True if n is prime else False"""
if n < 5 or n & 1 == 0 or n % 3 == 0:
return 2 <= n <= 3
s = ((n - 1) & (1 - n)).bit_length() - 1
d = n >> s
for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
p = pow(a, d, n)
if p == 1 or p == n - 1 or a % n == 0:
continue
for _ in range(s):
p = (p * p) % n
if p == n - 1:
break
else:
return False
return True
def prime_sieve(n):
"""returns a sieve of primes >= 5 and < n"""
flag = n % 6 == 2
sieve = bytearray((n // 3 + flag >> 3) + 1)
for i in range(1, int(n**0.5) // 3 + 1):
if not (sieve[i >> 3] >> (i & 7)) & 1:
k = (3 * i + 1) | 1
for j in range(k * k // 3, n // 3 + flag, 2 * k):
sieve[j >> 3] |= 1 << (j & 7)
for j in range(k * (k - 2 * (i & 1) + 4) // 3, n // 3 + flag, 2 * k):
sieve[j >> 3] |= 1 << (j & 7)
return sieve
def prime_list(n):
"""returns a list of primes <= n"""
res = []
if n > 1:
res.append(2)
if n > 2:
res.append(3)
if n > 4:
sieve = prime_sieve(n + 1)
res.extend(3 * i + 1 | 1 for i in range(1, (n + 1) // 3 + (n % 6 == 1)) if not (sieve[i >> 3] >> (i & 7)) & 1)
return res
def extended_gcd(a, b):
"""returns gcd(a, b), s, r s.t. a * s + b * r == gcd(a, b)"""
s, old_s = 0, 1
r, old_r = b, a
while r:
q = old_r // r
old_r, r = r, old_r - q * r
old_s, s = s, old_s - q * s
return old_r, old_s, (old_r - old_s * a) // b if b else 0
def modinv(a, m):
"""returns the modular inverse of a w.r.t. to m, works when a and m are coprime"""
g, x, _ = extended_gcd(a % m, m)
return x % m if g == 1 else None
def make_nCr_mod(max_n=2 * 10**5, mod=10**9 + 7):
max_n = min(max_n, mod - 1)
fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)
fact[0] = 1
for i in range(max_n):
fact[i + 1] = fact[i] * (i + 1) % mod
inv_fact[-1] = pow(fact[-1], mod - 2, mod)
for i in reversed(range(max_n)):
inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod
def nCr_mod(n, r):
res = 1
while n or r:
a, b = n % mod, r % mod
if a < b:
return 0
res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod
n //= mod
r //= mod
return res
return nCr_mod
"""
To use:
x=make_nCr_mod()
print(x(n,r))
"""
def binarySearch(arr, l, r, x):
while l <= r:
mid = l + (r - l) // 2
if arr[mid] == x:
return mid
elif arr[mid] < x:
l = mid + 1
r = mid - 1
return -1
def PrefixSum(arr):
return list(accumulate(arr))
class inputs:
#To handle different inputs
def single(self):
return int(input())
def mul(self):
return map(int,input().split())
def list(self):
return list(map(int,input().split()))
inp=inputs()
########################################################
def main():
for i in range(inp.single()):
n=inp.single()
a=inp.list()
s=sum(a)
s1=(s//n)*n
d=s-s1
print(d*(n-d))
if __name__ == "__main__":
main()
``` | instruction | 0 | 62,539 | 1 | 125,078 |
Yes | output | 1 | 62,539 | 1 | 125,079 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track.
Submitted Solution:
```
t = int(input())
for x in range(t) :
n = int(input())
liczby = list(map(int, input().split()))
suma = sum(liczby)
reszta = suma % n
srednia = suma // n
if suma % n == 0:
wynik = 0
if suma < n:
wynik = suma * (n - suma)
else:
wynik = (n - reszta) * reszta
print(wynik)
``` | instruction | 0 | 62,540 | 1 | 125,080 |
Yes | output | 1 | 62,540 | 1 | 125,081 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track.
Submitted Solution:
```
t = int(input())
for i in range(0, t):
n = int(input())
arr = list(map(int, input().split()))
x = sum(arr)
y = (n - x)
if (x % n == 0):
cnt = 0
elif (x < n):
cnt = (x * y)
else:
a = (x // n)
b = (x - a * n)
cnt = ((n - b) * b)
print(cnt)
``` | instruction | 0 | 62,541 | 1 | 125,082 |
Yes | output | 1 | 62,541 | 1 | 125,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track.
Submitted Solution:
```
def calc():
n = int(input())
l = list(map(int, input().split(' ')))
ss = sum(l)
ans = (ss % n) * (n - (ss % n))
print(ans)
t = int(input())
for _i in range(t):
calc()
``` | instruction | 0 | 62,542 | 1 | 125,084 |
Yes | output | 1 | 62,542 | 1 | 125,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track.
Submitted Solution:
```
from math import floor,ceil
for _ in range(int(input())):
n = int(input())
lanes = list(map(int,input().split()))
s = sum(lanes)
avg = s/n
if avg<1:
print((n-s)*2)
continue
l,h = floor(avg), ceil(avg)
#lx + hy = s
i = 0
while s>=l*i:
inter = s-l*i
if inter%h==0:
break
i+=1
x = i
y = n-i
print(x*y)
``` | instruction | 0 | 62,543 | 1 | 125,086 |
No | output | 1 | 62,543 | 1 | 125,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track.
Submitted Solution:
```
for i in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
a.sort()
res = 0
for i in range(n-1):
res += abs(a[i]-a[i+1])
print(res)
``` | instruction | 0 | 62,544 | 1 | 125,088 |
No | output | 1 | 62,544 | 1 | 125,089 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track.
Submitted Solution:
```
def pro(arr):
n=len(arr)
if(n==1):
print(arr[0])
return
k=sum(arr)
rem=k%n
print(rem*(n-rem))
t=int(input())
for i in range(t):
n=int(input())
arr=list(map(int,input().split()))
pro(arr)
``` | instruction | 0 | 62,545 | 1 | 125,090 |
No | output | 1 | 62,545 | 1 | 125,091 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as β_{i=1}^{n} β_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x.
You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.
Find the minimum inconvenience you can achieve.
Input
The first line of input contains a single integer t (1β€ tβ€ 10 000) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 2β
10^5).
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0β€ a_iβ€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times.
Example
Input
3
3
1 2 3
4
0 1 1 0
10
8 3 6 11 5 2 1 7 10 4
Output
0
4
21
Note
For the first test case, you can move a car from the 3-rd sub-track to the 1-st sub-track to obtain 0 inconvenience.
For the second test case, moving any car won't decrease the inconvenience of the track.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
s=sum(l)
print(s, s%n)
a=s%n
b=n-a
print(a*b)
``` | instruction | 0 | 62,546 | 1 | 125,092 |
No | output | 1 | 62,546 | 1 | 125,093 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ruritania is a country with a very badly maintained road network, which is not exactly good news for lorry drivers that constantly have to do deliveries. In fact, when roads are maintained, they become one-way. It turns out that it is sometimes impossible to get from one town to another in a legal way β however, we know that all towns are reachable, though illegally!
Fortunately for us, the police tend to be very corrupt and they will allow a lorry driver to break the rules and drive in the wrong direction provided they receive βa small giftβ. There is one patrol car for every road and they will request 1000 Ruritanian dinars when a driver drives in the wrong direction. However, being greedy, every time a patrol car notices the same driver breaking the rule, they will charge double the amount of money they requested the previous time on that particular road.
Borna is a lorry driver that managed to figure out this bribing pattern. As part of his job, he has to make K stops in some towns all over Ruritania and he has to make these stops in a certain order. There are N towns (enumerated from 1 to N) in Ruritania and Bornaβs initial location is the capital city i.e. town 1. He happens to know which ones out of the N - 1 roads in Ruritania are currently unidirectional, but he is unable to compute the least amount of money he needs to prepare for bribing the police. Help Borna by providing him with an answer and you will be richly rewarded.
Input
The first line contains N, the number of towns in Ruritania. The following N - 1 lines contain information regarding individual roads between towns. A road is represented by a tuple of integers (a,b,x), which are separated with a single whitespace character. The numbers a and b represent the cities connected by this particular road, and x is either 0 or 1: 0 means that the road is bidirectional, 1 means that only the a β b direction is legal. The next line contains K, the number of stops Borna has to make. The final line of input contains K positive integers s1, β¦, sK: the towns Borna has to visit.
* 1 β€ N β€ 105
* 1 β€ K β€ 106
* 1 β€ a, b β€ N for all roads
* <image> for all roads
* 1 β€ si β€ N for all 1 β€ i β€ K
Output
The output should contain a single number: the least amount of thousands of Ruritanian dinars Borna should allocate for bribes, modulo 109 + 7.
Examples
Input
5
1 2 0
2 3 0
5 1 1
3 4 1
5
5 4 5 2 2
Output
4
Note
Borna first takes the route 1 β 5 and has to pay 1000 dinars. After that, he takes the route 5 β 1 β 2 β 3 β 4 and pays nothing this time. However, when he has to return via 4 β 3 β 2 β 1 β 5, he needs to prepare 3000 (1000+2000) dinars. Afterwards, getting to 2 via 5 β 1 β 2 will cost him nothing. Finally, he doesn't even have to leave town 2 to get to 2, so there is no need to prepare any additional bribe money. Hence he has to prepare 4000 dinars in total.
Submitted Solution:
```
def extract_min(dist, used):
v_min = None
for i in range(n):
if not used[i] and dist[i] != None and (v_min == None or dist[i] < dist[v_min]):
v_min = i
return v_min
def relax(matrix, v, dist, prev):
for i, cost in matrix[v]:
if (dist[i] == None or dist[i] > dist[v] + cost):
dist[i] = dist[v] + cost
prev[i] = v
def deikstr(used, dist, prev, st, fin):
g = fin
ans = []
dist[st] = 0
while True:
v = extract_min(dist, used)
if v is None:
break
used[v] = True
relax(matrix, v, dist, prev)
if dist[fin] != None:
while fin is not None:
ans.append(fin)
fin = prev[fin]
return ans, dist[g]
n = int(input())
ans = 0
matrix = [[] for i in range(n)]
for i in range(n - 1):
a, b, c = map(int, input().split())
if c == 0:
matrix[a - 1].append([b - 1, 0])
matrix[b - 1].append([a - 1, 0])
else:
matrix[a - 1].append([b - 1, 0])
matrix[b - 1].append([a - 1, 1])
m = int(input())
lst = list(map(int, input().split()))
st = 0
for i in lst:
fin = i - 1
mas, ans_plus = deikstr([False] * n, [None] * n, [None] * n, st, fin)
ans += ans_plus
mas.reverse()
for i in range(len(mas) - 1):
for j in range(len(matrix[i])):
if matrix[i][j][0] == mas[i + 1]:
matrix[i][j][1] *= 2
st = fin
``` | instruction | 0 | 62,732 | 1 | 125,464 |
No | output | 1 | 62,732 | 1 | 125,465 |
Provide a correct Python 3 solution for this coding contest problem.
problem
In the area where Kazakhstan is now located, there used to be a trade route called the "Silk Road".
There are N + 1 cities on the Silk Road, numbered from west as city 0, city 1, ..., city N. The distance between city i -1 and city i (1 β€ i β€ N) is Di.
JOI, a trader, decided to start from city 0, go through the cities in order, and carry silk to city N. Must travel from city 0 to city N within M days. JOI chooses one of the following two actions for each day.
* Move: Move from the current city to the city one east in one day. If you are currently in city i -1 (1 β€ i β€ N), move to city i.
* Wait: Do not move and wait for one day in your current city.
It is difficult to move, and the degree of fatigue accumulates each time you move. The weather on the Silk Road fluctuates from day to day, and the worse the weather, the harder it is to move.
It is known that the bad weather on the jth day (1 β€ j β€ M) of the M days that JOI can use to carry silk is Cj. When moving from city i -1 to city i (1 β€ i β€ N) to day j (1 β€ j β€ M), the degree of fatigue accumulates by Di Γ Cj. Fatigue does not accumulate on days when you are waiting without moving.
JOI wants to move with as little fatigue as possible by choosing the behavior of each day. Find the minimum total fatigue that JOI will accumulate from the start to the end of the move to city N within M days.
input
The input consists of 1 + N + M lines.
On the first line, two integers N and M (1 β€ N β€ M β€ 1000) are written separated by a blank. This means that the Silk Road consists of N + 1 cities and JOI must carry the silk from city 0 to city N within M days.
The integer Di (1 β€ Di β€ 1000) is written on the i-th line (1 β€ i β€ N) of the following N lines. This means that the distance between city i -1 and city i is Di.
The integer Cj (1 β€ Cj β€ 1000) is written on the jth line (1 β€ j β€ M) of the following M lines. This means that the bad weather on day j is Cj.
output
Output the minimum value of the total fatigue level accumulated from the start to the end of the movement when JOI moves to the city N within M days in one line.
Example
Input
3 5
10
25
15
50
30
15
40
30
Output
1125 | instruction | 0 | 63,065 | 1 | 126,130 |
"Correct Solution:
```
#Dει‘
N,M = map(int,input().split())
D = [int(input()) for i in range(N)]
C = [int(input()) for j in range(M)]
inf = float("inf")
dp = [[inf for i in range(N+1)] for j in range(M+1)]
dp[0][0] = 0
for j in range(M):
dp[j+1] = dp[j][0:N+1]
for i in range(N):
if dp[j][i] != inf:
dp[j+1][i+1] = min(dp[j+1][i+1],dp[j][i]+D[i]*C[j])
#print(dp)
print(dp[M][N])
``` | output | 1 | 63,065 | 1 | 126,131 |
Provide a correct Python 3 solution for this coding contest problem.
problem
In the area where Kazakhstan is now located, there used to be a trade route called the "Silk Road".
There are N + 1 cities on the Silk Road, numbered from west as city 0, city 1, ..., city N. The distance between city i -1 and city i (1 β€ i β€ N) is Di.
JOI, a trader, decided to start from city 0, go through the cities in order, and carry silk to city N. Must travel from city 0 to city N within M days. JOI chooses one of the following two actions for each day.
* Move: Move from the current city to the city one east in one day. If you are currently in city i -1 (1 β€ i β€ N), move to city i.
* Wait: Do not move and wait for one day in your current city.
It is difficult to move, and the degree of fatigue accumulates each time you move. The weather on the Silk Road fluctuates from day to day, and the worse the weather, the harder it is to move.
It is known that the bad weather on the jth day (1 β€ j β€ M) of the M days that JOI can use to carry silk is Cj. When moving from city i -1 to city i (1 β€ i β€ N) to day j (1 β€ j β€ M), the degree of fatigue accumulates by Di Γ Cj. Fatigue does not accumulate on days when you are waiting without moving.
JOI wants to move with as little fatigue as possible by choosing the behavior of each day. Find the minimum total fatigue that JOI will accumulate from the start to the end of the move to city N within M days.
input
The input consists of 1 + N + M lines.
On the first line, two integers N and M (1 β€ N β€ M β€ 1000) are written separated by a blank. This means that the Silk Road consists of N + 1 cities and JOI must carry the silk from city 0 to city N within M days.
The integer Di (1 β€ Di β€ 1000) is written on the i-th line (1 β€ i β€ N) of the following N lines. This means that the distance between city i -1 and city i is Di.
The integer Cj (1 β€ Cj β€ 1000) is written on the jth line (1 β€ j β€ M) of the following M lines. This means that the bad weather on day j is Cj.
output
Output the minimum value of the total fatigue level accumulated from the start to the end of the movement when JOI moves to the city N within M days in one line.
Example
Input
3 5
10
25
15
50
30
15
40
30
Output
1125 | instruction | 0 | 63,066 | 1 | 126,132 |
"Correct Solution:
```
# AOJ 0611: Silk Road
# Python3 2018.7.4 bal4u
import sys
from sys import stdin
input = stdin.readline
INF = 0x7fffffff
n, m = map(int, input().split())
d = [int(input()) for i in range(n)]
c = [0] + [int(input()) for i in range(m)]
dp = [[INF for j in range(n+1)] for i in range(2)]
dp[0][0] = 0
for i in range(1, m+1):
for j in range(n+1): dp[i&1][j] = INF
for j in range(n+1): dp[i&1][j] = dp[1-(i&1)][j]
for j in range(n):
if dp[1-(i&1)][j] != INF:
dp[i&1][j+1] = min(dp[i&1][j+1], dp[1-(i&1)][j]+c[i]*d[j])
print(dp[i&1][n])
``` | output | 1 | 63,066 | 1 | 126,133 |
Provide a correct Python 3 solution for this coding contest problem.
problem
In the area where Kazakhstan is now located, there used to be a trade route called the "Silk Road".
There are N + 1 cities on the Silk Road, numbered from west as city 0, city 1, ..., city N. The distance between city i -1 and city i (1 β€ i β€ N) is Di.
JOI, a trader, decided to start from city 0, go through the cities in order, and carry silk to city N. Must travel from city 0 to city N within M days. JOI chooses one of the following two actions for each day.
* Move: Move from the current city to the city one east in one day. If you are currently in city i -1 (1 β€ i β€ N), move to city i.
* Wait: Do not move and wait for one day in your current city.
It is difficult to move, and the degree of fatigue accumulates each time you move. The weather on the Silk Road fluctuates from day to day, and the worse the weather, the harder it is to move.
It is known that the bad weather on the jth day (1 β€ j β€ M) of the M days that JOI can use to carry silk is Cj. When moving from city i -1 to city i (1 β€ i β€ N) to day j (1 β€ j β€ M), the degree of fatigue accumulates by Di Γ Cj. Fatigue does not accumulate on days when you are waiting without moving.
JOI wants to move with as little fatigue as possible by choosing the behavior of each day. Find the minimum total fatigue that JOI will accumulate from the start to the end of the move to city N within M days.
input
The input consists of 1 + N + M lines.
On the first line, two integers N and M (1 β€ N β€ M β€ 1000) are written separated by a blank. This means that the Silk Road consists of N + 1 cities and JOI must carry the silk from city 0 to city N within M days.
The integer Di (1 β€ Di β€ 1000) is written on the i-th line (1 β€ i β€ N) of the following N lines. This means that the distance between city i -1 and city i is Di.
The integer Cj (1 β€ Cj β€ 1000) is written on the jth line (1 β€ j β€ M) of the following M lines. This means that the bad weather on day j is Cj.
output
Output the minimum value of the total fatigue level accumulated from the start to the end of the movement when JOI moves to the city N within M days in one line.
Example
Input
3 5
10
25
15
50
30
15
40
30
Output
1125 | instruction | 0 | 63,067 | 1 | 126,134 |
"Correct Solution:
```
# AOJ 0611: Silk Road
# Python3 2018.7.4 bal4u
import sys
from sys import stdin
input = stdin.readline
INF = 0x7fffffff
n, m = map(int, input().split())
d = [int(input()) for i in range(n)]
c = [int(input()) for i in range(m)]
dp = [[INF for j in range(n+1)] for i in range(m+1)]
dp[0][0] = 0
for i in range(m):
for j in range(n+1): dp[i+1][j] = dp[i][j]
for j in range(n):
if dp[i][j] != INF:
dp[i+1][j+1] = min(dp[i+1][j+1], dp[i][j]+c[i]*d[j])
print(dp[m][n])
``` | output | 1 | 63,067 | 1 | 126,135 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.