message stringlengths 2 22.8k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 16 109k | cluster float64 1 1 | __index_level_0__ int64 32 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Buses run between the cities A and B, the first one is at 05:00 AM and the last one departs not later than at 11:59 PM. A bus from the city A departs every a minutes and arrives to the city B in a ta minutes, and a bus from the city B departs every b minutes and arrives to the city A in a tb minutes.
The driver Simion wants to make his job diverse, so he counts the buses going towards him. Simion doesn't count the buses he meet at the start and finish.
You know the time when Simion departed from the city A to the city B. Calculate the number of buses Simion will meet to be sure in his counting.
Input
The first line contains two integers a, ta (1 β€ a, ta β€ 120) β the frequency of the buses from the city A to the city B and the travel time. Both values are given in minutes.
The second line contains two integers b, tb (1 β€ b, tb β€ 120) β the frequency of the buses from the city B to the city A and the travel time. Both values are given in minutes.
The last line contains the departure time of Simion from the city A in the format hh:mm. It is guaranteed that there are a bus from the city A at that time. Note that the hours and the minutes are given with exactly two digits.
Output
Print the only integer z β the number of buses Simion will meet on the way. Note that you should not count the encounters in cities A and B.
Examples
Input
10 30
10 35
05:20
Output
5
Input
60 120
24 100
13:00
Output
9
Note
In the first example Simion departs form the city A at 05:20 AM and arrives to the city B at 05:50 AM. He will meet the first 5 buses from the city B that departed in the period [05:00 AM - 05:40 AM]. Also Simion will meet a bus in the city B at 05:50 AM, but he will not count it.
Also note that the first encounter will be between 05:26 AM and 05:27 AM (if we suggest that the buses are go with the sustained speed).
Submitted Solution:
```
#!/usr/bin/env python
a, t_a = map(int, input().split())
b, t_b = map(int, input().split())
hh, mm = map(int, input().split(sep = ':'))
start_time = (hh - 5) * 60 + mm
buses = []
for time in range((24 - 5) * 60):
if time < start_time:
buses = [item - 1 for item in buses if item != 0]
if time % b == 0:
buses.append(t_b)
elif time == start_time:
z = len(buses)
if time >= start_time and time < start_time + t_a:
if time % b == 0:
z += 1
print(z)
``` | instruction | 0 | 28,706 | 1 | 57,412 |
No | output | 1 | 28,706 | 1 | 57,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Buses run between the cities A and B, the first one is at 05:00 AM and the last one departs not later than at 11:59 PM. A bus from the city A departs every a minutes and arrives to the city B in a ta minutes, and a bus from the city B departs every b minutes and arrives to the city A in a tb minutes.
The driver Simion wants to make his job diverse, so he counts the buses going towards him. Simion doesn't count the buses he meet at the start and finish.
You know the time when Simion departed from the city A to the city B. Calculate the number of buses Simion will meet to be sure in his counting.
Input
The first line contains two integers a, ta (1 β€ a, ta β€ 120) β the frequency of the buses from the city A to the city B and the travel time. Both values are given in minutes.
The second line contains two integers b, tb (1 β€ b, tb β€ 120) β the frequency of the buses from the city B to the city A and the travel time. Both values are given in minutes.
The last line contains the departure time of Simion from the city A in the format hh:mm. It is guaranteed that there are a bus from the city A at that time. Note that the hours and the minutes are given with exactly two digits.
Output
Print the only integer z β the number of buses Simion will meet on the way. Note that you should not count the encounters in cities A and B.
Examples
Input
10 30
10 35
05:20
Output
5
Input
60 120
24 100
13:00
Output
9
Note
In the first example Simion departs form the city A at 05:20 AM and arrives to the city B at 05:50 AM. He will meet the first 5 buses from the city B that departed in the period [05:00 AM - 05:40 AM]. Also Simion will meet a bus in the city B at 05:50 AM, but he will not count it.
Also note that the first encounter will be between 05:26 AM and 05:27 AM (if we suggest that the buses are go with the sustained speed).
Submitted Solution:
```
f = lambda k: map(int, input().split(k))
a, u = f(' ')
b, v = f(' ')
h, m = f(':')
t = h * 60 + m - 300
x, y = max(t - v, 0), min(t + u, 1139)
print(y // b - x // b)
``` | instruction | 0 | 28,707 | 1 | 57,414 |
No | output | 1 | 28,707 | 1 | 57,415 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0 | instruction | 0 | 28,876 | 1 | 57,752 |
"Correct Solution:
```
import sys
input=sys.stdin.readline
inf=10**9+7
n,m,l=map(int,input().split())
D=[[inf]*(n+1) for _ in range(n+1)]
for _ in range(m):
a,b,c=map(int,input().split())
D[a][b]=c
D[b][a]=c
for k in range(1,n+1):
for i in range(1,n+1):
for j in range(1,n+1):
D[i][j]=min(D[i][j],D[i][k]+D[k][j])
DD=[[inf]*(n+1) for _ in range(n+1)]
for x in range(1,n+1):
for y in range(1,n+1):
if D[x][y]<=l:
DD[x][y]=1
for k in range(1,n+1):
for i in range(1,n+1):
for j in range(1,n+1):
DD[i][j]=min(DD[i][j],DD[i][k]+DD[k][j])
q=int(input())
for _ in range(q):
s,t=map(int,input().split())
if DD[s][t]==inf:
print(-1)
else:
print(DD[s][t]-1)
``` | output | 1 | 28,876 | 1 | 57,753 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0 | instruction | 0 | 28,877 | 1 | 57,754 |
"Correct Solution:
```
inf = 10 ** 13
n, m, l = map(int, input().split())
d = [[inf] * n for _ in range(n)]
for _ in range(m):
a, b, c = map(int, input().split())
d[a - 1][b - 1] = d[b - 1][a - 1] = c
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
e = [[1 if d[i][j] <= l else inf for j in range(n)] for i in range(n)]
for k in range(n):
for i in range(n):
for j in range(n):
e[i][j] = min(e[i][j], e[i][k] + e[k][j])
q = int(input())
for _ in range(q):
s, t = map(int, input().split())
a = e[s - 1][t - 1]
print(a - 1 if a < inf else -1)
``` | output | 1 | 28,877 | 1 | 57,755 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0 | instruction | 0 | 28,878 | 1 | 57,756 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
N, M, L = map(int, input().split())
d = [[10 ** 16 * (i != j) for j in range(N + 1)] for i in range(N + 1)]
for _ in range(M):
x, y, c = map(int, input().split())
d[x][y] = c
d[y][x] = c
for k in range(N + 1):
for i in range(N + 1):
for j in range(N + 1): d[i][j] = min(d[i][j], d[i][k] + d[k][j])
dd = [[(d[i][j] <= L) + (d[i][j] > L) * 10 ** 16 for j in range(N + 1)] for i in range(N + 1)]
for k in range(N + 1):
for i in range(N + 1):
for j in range(N + 1): dd[i][j] = min(dd[i][j], dd[i][k] + dd[k][j])
for _ in range(int(input())):
s, t = map(int, input().split())
if dd[s][t] != 10 ** 16: print(dd[s][t] - 1)
else: print(-1)
``` | output | 1 | 28,878 | 1 | 57,757 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0 | instruction | 0 | 28,879 | 1 | 57,758 |
"Correct Solution:
```
def warshall_floid(d):
for k in range(1,n+1):
for i in range(1,n+1):
for j in range(1,n+1):
d[i][j] = min(d[i][j],d[i][k]+d[k][j])
return d
n,m,l = map(int,input().split())
d = [[10**13]*(n+1) for i in range(n+1)]
for i in range(m):
a,b,c = map(int,input().split())
d[a][b] = c
d[b][a] = c
for i in range(1,n+1):
d[i][i] = 0
d = warshall_floid(d)
for i in range(1,n+1):
for j in range(1,n+1):
if d[i][j] <= l:
d[i][j] = 1
else:
d[i][j] = 10**13
d = warshall_floid(d)
q = int(input())
for i in range(q):
s,t = map(int,input().split())
if d[s][t] >= 10**13:
print(-1)
else:
print(d[s][t]-1)
``` | output | 1 | 28,879 | 1 | 57,759 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0 | instruction | 0 | 28,880 | 1 | 57,760 |
"Correct Solution:
```
def warshall_floyd(d):
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j]=min(d[i][j],d[i][k]+d[k][j])
return d
n,m,l=map(int,input().split())
d=[[10**10 for _ in range(n)]for _ in range(n)]
for i in range(n):
d[i][i]=0
for i in range(m):
a,b,c=map(int,input().split())
d[a-1][b-1]=c
d[b-1][a-1]=c
p=[[10**5 for _ in range(n)]for _ in range(n)]
d=warshall_floyd(d)
for i in range(n):
for j in range(n):
if d[i][j]<=l:
p[i][j]=1
p=warshall_floyd(p)
q=int(input())
for i in range(q):
s,t=map(int,input().split())
if p[s-1][t-1]==10**5:
print(-1)
continue
print(p[s-1][t-1]-1)
``` | output | 1 | 28,880 | 1 | 57,761 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0 | instruction | 0 | 28,881 | 1 | 57,762 |
"Correct Solution:
```
def warshall_floyd(G):
import copy
ret = copy.deepcopy(G)
for k in range(N):
for i in range(N):
for j in range(N):
ret[i][j] = min(ret[i][j], ret[i][k] + ret[k][j])
return ret
INF = 10 ** 10
N, M, L = map(int, input().split())
G = [[INF] * N for _ in range(N)]
for i in range(M):
A, B, C = map(int, input().split())
G[A - 1][B - 1], G[B - 1][A - 1] = C, C
MinG = warshall_floyd(G)
GL = [[1 if MinG[i][j] <= L else INF for j in range(N)] for i in range(N)]
MinGL = warshall_floyd(GL)
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
print(-1 if MinGL[s - 1][t - 1] == INF else MinGL[s - 1][t - 1] - 1)
``` | output | 1 | 28,881 | 1 | 57,763 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0 | instruction | 0 | 28,882 | 1 | 57,764 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
N,M,L=map(int,input().split())
def war(d):
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j]=min(d[i][j],d[i][k]+d[k][j])
return d
INF=(L+1)*N
d=[[INF]*N for _ in range(N)]
d2=[[INF]*N for _ in range(N)]
for _ in range(M):
A,B,C=map(int,input().split())
if C>L:
continue
d[A-1][B-1]=C
d[B-1][A-1]=C
for i in range(N):
d[i][i]=0
d=war(d)
for i in range(N):
for j in range(N):
if d[i][j]<=L:
d2[i][j]=1
for i in range(N):
d2[i][i]=0
d2=war(d2)
#print(d)
#print(d2)
Q=int(input())
for i in range(Q):
s,t=map(int,input().split())
print(d2[s-1][t-1] %INF -1)
``` | output | 1 | 28,882 | 1 | 57,765 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0 | instruction | 0 | 28,883 | 1 | 57,766 |
"Correct Solution:
```
n,m,l=map(int,input().split())
d=[[10**18]*n for i in range(n)]
for _ in range(m):
a,b,c=map(int,input().split())
if c<=l:
d[a-1][b-1]=c
d[b-1][a-1]=c
for i in range(n):
d[i][i]=0
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j]=min(d[i][j],d[i][k]+d[k][j])
for i in range(n):
for j in range(n):
if d[i][j]<=l:
d[i][j]=1
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j]=min(d[i][j],d[i][k]+d[k][j])
q=int(input())
for i in range(q):
s,t=map(int,input().split())
s-=1
t-=1
print(d[s][t]-1 if d[s][t]-1<999999999999999999 else -1)
``` | output | 1 | 28,883 | 1 | 57,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0
Submitted Solution:
```
n, m, l = map(int, input().split())
def warshall_floyd(d, v):
for k in range(v):
for i in range(v):
for j in range(v):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
inf = 10 ** 15
d = [[inf] * n for _ in range(n)]
for _ in range(m):
a, b, c = map(int, input().split())
d[a-1][b-1] = min(d[a-1][b-1], c)
d[b-1][a-1] = min(d[b-1][a-1], c)
warshall_floyd(d, n)
e = [[inf] * n for _ in range(n)]
for i in range(n):
for j in range(i+1, n):
if d[i][j] <= l:
e[i][j] = min(e[i][j], 1)
e[j][i] = min(e[j][i], 1)
warshall_floyd(e, n)
q = int(input())
for _ in range(q):
s, t = map(int, input().split())
print(e[s-1][t-1] - 1 if e[s-1][t-1] < inf else -1)
``` | instruction | 0 | 28,884 | 1 | 57,768 |
Yes | output | 1 | 28,884 | 1 | 57,769 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0
Submitted Solution:
```
n,m,l = map(int,input().split())
g = [[float('inf')]*n for _ in range(n)]
for _ in range(m):
a,b,c = map(int,input().split())
a-=1
b-=1
g[a][b] = c
g[b][a] = c
for k in range(n):
for i in range(n):
for j in range(n):
g[i][j] = min(g[i][j],g[i][k] + g[k][j])
h = [[float('inf')]*n for _ in range(n)]
for i in range(n):
for j in range(n):
if g[i][j]<=l:
h[i][j] = 1
for k in range(n):
for i in range(n):
for j in range(n):
h[i][j] = min(h[i][j],h[i][k] + h[k][j])
Q = int(input())
for _ in range(Q):
s,t = map(int,input().split())
s -=1
t-=1
if h[s][t] ==float('inf'):
print(-1)
else:
print(h[s][t]-1)
``` | instruction | 0 | 28,885 | 1 | 57,770 |
Yes | output | 1 | 28,885 | 1 | 57,771 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0
Submitted Solution:
```
def warshall_floyd(edge):
e=edge
for k in range(len(e)):
for i in range(len(e)):
for j in range(len(e)):
e[i][j]=min(e[i][j],e[i][k]+e[k][j])
return e
n,m,l=map(int,input().split())
edge=[n*[10**18]for _ in range(n)]
for i in range(n):
edge[i][i]=0
for i in range(m):
a,b,c=map(int,input().split())
a-=1
b-=1
edge[a][b]=edge[b][a]=c
edge=warshall_floyd(edge)
edge2=[n*[10**18]for _ in range(n)]
for i in range(n):
edge2[i][i]=0
for j in range(n):
if edge[i][j]<=l:
edge2[i][j]=1
edge2=warshall_floyd(edge2)
q=int(input())
for i in range(q):
s,t=map(int,input().split())
s-=1
t-=1
ans=edge2[s][t]
if ans==10**18:
print(-1)
else:
print(ans-1)
``` | instruction | 0 | 28,886 | 1 | 57,772 |
Yes | output | 1 | 28,886 | 1 | 57,773 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0
Submitted Solution:
```
n,m,l = map(int,input().split())
g = [[1<<30]*n for _ in range(n)]
for _ in range(m):
a,b,c = map(int,input().split())
g[a-1][b-1] = c
g[b-1][a-1] = c
for i in range(n):
g[i][i] = 0
def bell(g,n):
for k in range(n):
for i in range(n-1):
for j in range(i+1,n):
if g[i][j] > g[i][k] + g[k][j]:
g[i][j] = g[i][k] + g[k][j]
g[j][i] = g[i][j]
return g
g = bell(g,n)
for i in range(n):
for j in range(n):
if i == j:
g[i][j] = 0
elif g[i][j] <= l:
g[i][j] = 1
else:
g[i][j] = 1<<30
g = bell(g,n)
q = int(input())
for _ in range(q):
s,t = map(int,input().split())
if g[s-1][t-1]>>30:
print(-1)
else:
print(g[s-1][t-1]-1)
``` | instruction | 0 | 28,887 | 1 | 57,774 |
Yes | output | 1 | 28,887 | 1 | 57,775 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0
Submitted Solution:
```
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
"""
"""
def warshall_floyd(d):
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
n,m,l = LI()
dist = [[inf]*n for _ in range(n)]
dist2 = [[inf]*n for _ in range(n)]
for i in range(n):
dist[i][i] = 0
dist2[i][i] = 0
for _ in range(m):
a,b,c = LI()
dist[a-1][b-1] = c
dist[b-1][a-1] = c
dist = warshall_floyd(dist)
print(dist)
for i in range(n):
for j in range(n):
if dist[i][j] > l:
dist2[i][j] = inf
else:
dist2[i][j] = 1
dist2 = warshall_floyd(dist2)
q = I()
ans = []
for _ in range(q):
s,t = LI()
if dist2[s-1][t-1] == inf:
ans.append(-1)
else:
ans.append(dist2[s-1][t-1]-1)
print(*ans)
``` | instruction | 0 | 28,888 | 1 | 57,776 |
No | output | 1 | 28,888 | 1 | 57,777 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0
Submitted Solution:
```
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
n,m,l=map(int,input().split())
ll=[]
for i in range(m):
a,b,c=[int(j) for j in input().split()]
if c<=l:
ll.append((a,b,c))
if ll==[]:
print(-1)
exit()
edge=np.array(ll,dtype=np.int64).T
graph=csr_matrix(((edge[2],edge[:2]-1)),(n,n))
#False->η‘εγ°γ©γ True->ζεΉγ°γ©γ
ans=floyd_warshall(graph,directed=False)
v=[]
for i in range(n):
for j in range(n):
if ans[i][j]<=l:
v.append((i+1,j+1,1))
edge=np.array(v,dtype=np.int64).T
graph=csr_matrix(((edge[2],edge[:2]-1)),(n,n))
ans2=floyd_warshall(graph,directed=False)
q=int(input())
st=[]
for i in range(q):
st.append([int(j)-1 for j in input().split()])
for i,j in st:
if int(ans2[i][j])==float("inf"):
print(-1)
else:
print(int(ans2[i][j])-1)
``` | instruction | 0 | 28,889 | 1 | 57,778 |
No | output | 1 | 28,889 | 1 | 57,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0
Submitted Solution:
```
import sys
input=sys.stdin.readline
n,m,l=map(int,input().split())
INF=10**10
graph=[[INF for i in range(n)] for j in range(n)]
fuel=[[INF for i in range(n)] for j in range(n)]
for i in range(n):
graph[i][i]=0
for i in range(m):
a,b,c=map(int,input().split())
a-=1;b-=1
if c>l:continue
graph[a][b],graph[b][a]=c,c
for i in range(n):
for j in range(n):
for k in range(n):
graph[j][k]=min(graph[j][k],graph[j][i]+graph[i][k])
for i in range(n):
for j in range(n):
if graph[i][j]<=l:
fuel[i][j]=1
for i in range(n):
for j in range(n):
for k in range(n):
fuel[j][k]=min(fuel[j][k],fuel[j][i]+fuel[i][k])
q=int(input())
for i in range(q):
s,t=map(int,input().split())
s-=1;t-=1
if fuel[s][t]==INF:print(-1)
else:print(fuel[s][t]-1)
``` | instruction | 0 | 28,890 | 1 | 57,780 |
No | output | 1 | 28,890 | 1 | 57,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns numbered 1 to N and M roads. The i-th road connects Town A_i and Town B_i bidirectionally and has a length of C_i.
Takahashi will travel between these towns by car, passing through these roads. The fuel tank of his car can contain at most L liters of fuel, and one liter of fuel is consumed for each unit distance traveled. When visiting a town while traveling, he can full the tank (or choose not to do so). Travel that results in the tank becoming empty halfway on the road cannot be done.
Process the following Q queries:
* The tank is now full. Find the minimum number of times he needs to full his tank while traveling from Town s_i to Town t_i. If Town t_i is unreachable, print -1.
Constraints
* All values in input are integers.
* 2 \leq N \leq 300
* 0 \leq M \leq \frac{N(N-1)}{2}
* 1 \leq L \leq 10^9
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* \left(A_i, B_i\right) \neq \left(A_j, B_j\right) (if i \neq j)
* \left(A_i, B_i\right) \neq \left(B_j, A_j\right) (if i \neq j)
* 1 \leq C_i \leq 10^9
* 1 \leq Q \leq N\left(N-1\right)
* 1 \leq s_i, t_i \leq N
* s_i \neq t_i
* \left(s_i, t_i\right) \neq \left(s_j, t_j\right) (if i \neq j)
Input
Input is given from Standard Input in the following format:
N M L
A_1 B_1 C_1
:
A_M B_M C_M
Q
s_1 t_1
:
s_Q t_Q
Output
Print Q lines.
The i-th line should contain the minimum number of times the tank needs to be fulled while traveling from Town s_i to Town t_i. If Town t_i is unreachable, the line should contain -1 instead.
Examples
Input
3 2 5
1 2 3
2 3 3
2
3 2
1 3
Output
0
1
Input
4 0 1
1
2 1
Output
-1
Input
5 4 4
1 2 2
2 3 2
3 4 3
4 5 2
20
2 1
3 1
4 1
5 1
1 2
3 2
4 2
5 2
1 3
2 3
4 3
5 3
1 4
2 4
3 4
5 4
1 5
2 5
3 5
4 5
Output
0
0
1
2
0
0
1
2
0
0
0
1
1
1
0
0
2
2
1
0
Submitted Solution:
```
import sys
from scipy.sparse.csgraph import csgraph_from_dense
from scipy.sparse.csgraph import floyd_warshall
input = sys.stdin.readline
n, m, energy = map(int, input().split())
edges = [[float('INF')]*n for _ in range(n)]
for i in range(m):
a, b, c = map(int, input().split())
edges[a-1][b-1] = c
edges[b-1][a-1] = c
G = csgraph_from_dense(edges, null_value=float('INF'))
dist = floyd_warshall(G)
L_edges = [[float('INF')]*n for _ in range(n)]
for i in range(n-1):
for j in range(i, n):
if dist[i][j] <= energy:
L_edges[i][j] = 1
L_edges[j][i] = 1
G = csgraph_from_dense(L_edges, null_value=0)
answers = floyd_warshall(G)
Q = int(input())
for i in range(Q):
s, t = map(int, input().split())
ans = answers[s-1][t-1] - 1
print(int(ans))
``` | instruction | 0 | 28,891 | 1 | 57,782 |
No | output | 1 | 28,891 | 1 | 57,783 |
Provide a correct Python 3 solution for this coding contest problem.
Create a program that calculates and outputs the surface distance by inputting the north latitude and east longitude of two cities on the earth. However, the earth is a sphere with a radius of 6,378.1 km, and the surface distance between two points is the shortest distance along this sphere. Also, in the southern hemisphere, we will use 0 to -90 degrees north latitude without using south latitude, and 180 to 360 degrees east longitude without using west longitude even to the west of the Greenwich meridional line. Calculate the ground surface distance in km, round off to the nearest whole number, and output as an integer value.
Below are examples of north latitude and east longitude of major cities.
Place name | North latitude (degree) | East longitude (degree)
--- | --- | ---
Tokyo | 35.68 | 139.77
Singapore | 1.37 | 103.92
Sydney | -33.95 | 151.18
Chicago | 41.78 | 272.25
Buenos Aires | -34.58 | 301.52
London | 51.15 | 359.82
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by -1 four lines. Each dataset is given in the following format:
a b c d
The first city's north latitude a, the first city's east longitude b, the second city's north latitude c, and the second city's east longitude d are given on one line, separated by blanks. All inputs are given in real numbers.
The number of datasets does not exceed 30.
Output
Outputs the surface distances of two cities on one line for each dataset.
Example
Input
35.68 139.77 51.15 359.82
1.37 103.92 41.78 272.25
51.15 359.82 -34.58 301.52
-1 -1 -1 -1
Output
9609
15092
11112 | instruction | 0 | 28,999 | 1 | 57,998 |
"Correct Solution:
```
import math
def l2(x,y,z):
return math.sqrt(x*x+y*y+z*z)
while True:
s = input()
if s == '-1 -1 -1 -1':
break
a,b,c,d = map(float, s.split())
a = (a / 360) * 2 * math.pi
b = (b / 360) * 2 * math.pi
c = (c / 360) * 2 * math.pi
d = (d / 360) * 2 * math.pi
x1 = math.cos(b)*math.cos(a)
y1 = math.sin(b)*math.cos(a)
z1 = math.sin(a)
x2 = math.cos(d)*math.cos(c)
y2 = math.sin(d)*math.cos(c)
z2 = math.sin(c)
theta = math.acos(x1*x2 + y1*y2 + z1*z2)
print(round(6378.1*theta))
``` | output | 1 | 28,999 | 1 | 57,999 |
Provide a correct Python 3 solution for this coding contest problem.
Create a program that calculates and outputs the surface distance by inputting the north latitude and east longitude of two cities on the earth. However, the earth is a sphere with a radius of 6,378.1 km, and the surface distance between two points is the shortest distance along this sphere. Also, in the southern hemisphere, we will use 0 to -90 degrees north latitude without using south latitude, and 180 to 360 degrees east longitude without using west longitude even to the west of the Greenwich meridional line. Calculate the ground surface distance in km, round off to the nearest whole number, and output as an integer value.
Below are examples of north latitude and east longitude of major cities.
Place name | North latitude (degree) | East longitude (degree)
--- | --- | ---
Tokyo | 35.68 | 139.77
Singapore | 1.37 | 103.92
Sydney | -33.95 | 151.18
Chicago | 41.78 | 272.25
Buenos Aires | -34.58 | 301.52
London | 51.15 | 359.82
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by -1 four lines. Each dataset is given in the following format:
a b c d
The first city's north latitude a, the first city's east longitude b, the second city's north latitude c, and the second city's east longitude d are given on one line, separated by blanks. All inputs are given in real numbers.
The number of datasets does not exceed 30.
Output
Outputs the surface distances of two cities on one line for each dataset.
Example
Input
35.68 139.77 51.15 359.82
1.37 103.92 41.78 272.25
51.15 359.82 -34.58 301.52
-1 -1 -1 -1
Output
9609
15092
11112 | instruction | 0 | 29,002 | 1 | 58,004 |
"Correct Solution:
```
# AOJ 0177 Distance Between Two Cities
# Python3 2018.6.19 bal4u
PI = 3.1415926535897932384626433832795
M = (PI/180.0)
import math
while True:
y1, x1, y2, x2 = list(map(float, input().split()))
if x1 == -1 and y1 == -1 and x2 == -1 and y2 == -1: break
a = math.cos(y1*M)*math.cos(y2*M)*math.cos((x1-x2)*M) + math.sin(y1*M)*math.sin(y2*M)
print(int(6378.1*math.acos(a) + 0.5))
``` | output | 1 | 29,002 | 1 | 58,005 |
Provide a correct Python 3 solution for this coding contest problem.
Create a program that calculates and outputs the surface distance by inputting the north latitude and east longitude of two cities on the earth. However, the earth is a sphere with a radius of 6,378.1 km, and the surface distance between two points is the shortest distance along this sphere. Also, in the southern hemisphere, we will use 0 to -90 degrees north latitude without using south latitude, and 180 to 360 degrees east longitude without using west longitude even to the west of the Greenwich meridional line. Calculate the ground surface distance in km, round off to the nearest whole number, and output as an integer value.
Below are examples of north latitude and east longitude of major cities.
Place name | North latitude (degree) | East longitude (degree)
--- | --- | ---
Tokyo | 35.68 | 139.77
Singapore | 1.37 | 103.92
Sydney | -33.95 | 151.18
Chicago | 41.78 | 272.25
Buenos Aires | -34.58 | 301.52
London | 51.15 | 359.82
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by -1 four lines. Each dataset is given in the following format:
a b c d
The first city's north latitude a, the first city's east longitude b, the second city's north latitude c, and the second city's east longitude d are given on one line, separated by blanks. All inputs are given in real numbers.
The number of datasets does not exceed 30.
Output
Outputs the surface distances of two cities on one line for each dataset.
Example
Input
35.68 139.77 51.15 359.82
1.37 103.92 41.78 272.25
51.15 359.82 -34.58 301.52
-1 -1 -1 -1
Output
9609
15092
11112 | instruction | 0 | 29,003 | 1 | 58,006 |
"Correct Solution:
```
# Aizu Problem 0177: Distance Between Two Cities
#
import sys, math, os, bisect
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
R = 6378.1
while True:
inp = input().split()
if inp == ['-1'] * 4:
break
lat1, long1, lat2, long2 = [float(_) * math.pi / 180. for _ in inp]
dist = round(R * math.acos(math.sin(lat1)*math.sin(lat2) + \
math.cos(lat1)*math.cos(lat2)*math.cos(long2-long1)), 0)
print(int(dist))
``` | output | 1 | 29,003 | 1 | 58,007 |
Provide a correct Python 3 solution for this coding contest problem.
King Mercer is the king of ACM kingdom. There are one capital and some cities in his kingdom. Amazingly, there are no roads in the kingdom now. Recently, he planned to construct roads between the capital and the cities, but it turned out that the construction cost of his plan is much higher than expected.
In order to reduce the cost, he has decided to create a new construction plan by removing some roads from the original plan. However, he believes that a new plan should satisfy the following conditions:
* For every pair of cities, there is a route (a set of roads) connecting them.
* The minimum distance between the capital and each city does not change from his original plan.
Many plans may meet the conditions above, but King Mercer wants to know the plan with minimum cost. Your task is to write a program which reads his original plan and calculates the cost of a new plan with the minimum cost.
Input
The input consists of several datasets. Each dataset is formatted as follows.
N M
u1 v1 d1 c1
.
.
.
uM vM dM cM
The first line of each dataset begins with two integers, N and M (1 β€ N β€ 10000, 0 β€ M β€ 20000). N and M indicate the number of cities and the number of roads in the original plan, respectively.
The following M lines describe the road information in the original plan. The i-th line contains four integers, ui, vi, di and ci (1 β€ ui, vi β€ N , ui β vi , 1 β€ di β€ 1000, 1 β€ ci β€ 1000). ui , vi, di and ci indicate that there is a road which connects ui-th city and vi-th city, whose length is di and whose cost needed for construction is ci.
Each road is bidirectional. No two roads connect the same pair of cities. The 1-st city is the capital in the kingdom.
The end of the input is indicated by a line containing two zeros separated by a space. You should not process the line as a dataset.
Output
For each dataset, print the minimum cost of a plan which satisfies the conditions in a line.
Example
Input
3 3
1 2 1 2
2 3 2 1
3 1 3 2
5 5
1 2 2 2
2 3 1 1
1 4 1 1
4 5 1 1
5 3 1 1
5 10
1 2 32 10
1 3 43 43
1 4 12 52
1 5 84 23
2 3 58 42
2 4 86 99
2 5 57 83
3 4 11 32
3 5 75 21
4 5 23 43
5 10
1 2 1 53
1 3 1 65
1 4 1 24
1 5 1 76
2 3 1 19
2 4 1 46
2 5 1 25
3 4 1 13
3 5 1 65
4 5 1 34
0 0
Output
3
5
137
218 | instruction | 0 | 29,056 | 1 | 58,112 |
"Correct Solution:
```
import heapq
class Edge:
def __init__(self, dst, weight, cost):
self.dst, self.weight, self.cost = dst, weight, cost
def __lt__(self, e):
return self.weight > e.weight
class Graph:
def __init__(self, V):
self.V = V
self.E = [[] for _ in range(V)]
def add_edge(self, src, dst, weight, cost):
self.E[src].append(Edge(dst, weight, cost))
class ShortestPath:
"""Dijkstra's algorithm : find the shortest path from a vertex
Complexity: O(E + log(V))
used in GRL1A(AOJ)
"""
def __init__(self, G, INF=10**9):
""" V: the number of vertexes
E: adjacency list (all edge in E must be 0 or positive)
start: start vertex
INF: Infinity distance
"""
self.G, self.INF = G, INF
class Node:
def __init__(self, v, cost):
self.v, self.cost = v, cost
def __lt__(self, n):
return self.cost < n.cost
def dijkstra(self, start, goal=None):
que = list()
self.dist = [self.INF] * self.G.V # distance from start
self.prev = [-1] * self.G.V # prev vertex of shortest path
self.dist[start] = 0
heapq.heappush(que, self.Node(start, 0))
while len(que) > 0:
n = heapq.heappop(que)
if self.dist[n.v] < n.cost:
continue
if goal is not None and n.v == goal:
return
for e in self.G.E[n.v]:
if self.dist[n.v] + e.weight < self.dist[e.dst]:
self.dist[e.dst] = self.dist[n.v] + e.weight
heapq.heappush(que, self.Node(e.dst, self.dist[e.dst]))
self.prev[e.dst] = n.v
def getPath(self, end):
path = [end]
while self.prev[end] != -1:
end = self.prev[end]
return path[::-1]
while True:
N, M = map(int, input().split())
if not (N | M):
break
g = Graph(N)
for _ in range(M):
u, v, d, c = map(int, input().split())
g.add_edge(u - 1, v - 1, d, c)
g.add_edge(v - 1, u - 1, d, c)
sp = ShortestPath(g)
sp.dijkstra(0)
print(sum(min(e.cost for e in g.E[i] if sp.dist[e.dst] + e.weight == sp.dist[i]) for i in range(1, N)))
``` | output | 1 | 29,056 | 1 | 58,113 |
Provide a correct Python 3 solution for this coding contest problem.
King Mercer is the king of ACM kingdom. There are one capital and some cities in his kingdom. Amazingly, there are no roads in the kingdom now. Recently, he planned to construct roads between the capital and the cities, but it turned out that the construction cost of his plan is much higher than expected.
In order to reduce the cost, he has decided to create a new construction plan by removing some roads from the original plan. However, he believes that a new plan should satisfy the following conditions:
* For every pair of cities, there is a route (a set of roads) connecting them.
* The minimum distance between the capital and each city does not change from his original plan.
Many plans may meet the conditions above, but King Mercer wants to know the plan with minimum cost. Your task is to write a program which reads his original plan and calculates the cost of a new plan with the minimum cost.
Input
The input consists of several datasets. Each dataset is formatted as follows.
N M
u1 v1 d1 c1
.
.
.
uM vM dM cM
The first line of each dataset begins with two integers, N and M (1 β€ N β€ 10000, 0 β€ M β€ 20000). N and M indicate the number of cities and the number of roads in the original plan, respectively.
The following M lines describe the road information in the original plan. The i-th line contains four integers, ui, vi, di and ci (1 β€ ui, vi β€ N , ui β vi , 1 β€ di β€ 1000, 1 β€ ci β€ 1000). ui , vi, di and ci indicate that there is a road which connects ui-th city and vi-th city, whose length is di and whose cost needed for construction is ci.
Each road is bidirectional. No two roads connect the same pair of cities. The 1-st city is the capital in the kingdom.
The end of the input is indicated by a line containing two zeros separated by a space. You should not process the line as a dataset.
Output
For each dataset, print the minimum cost of a plan which satisfies the conditions in a line.
Example
Input
3 3
1 2 1 2
2 3 2 1
3 1 3 2
5 5
1 2 2 2
2 3 1 1
1 4 1 1
4 5 1 1
5 3 1 1
5 10
1 2 32 10
1 3 43 43
1 4 12 52
1 5 84 23
2 3 58 42
2 4 86 99
2 5 57 83
3 4 11 32
3 5 75 21
4 5 23 43
5 10
1 2 1 53
1 3 1 65
1 4 1 24
1 5 1 76
2 3 1 19
2 4 1 46
2 5 1 25
3 4 1 13
3 5 1 65
4 5 1 34
0 0
Output
3
5
137
218 | instruction | 0 | 29,057 | 1 | 58,114 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f(n,m):
e = collections.defaultdict(list)
for _ in range(m):
u,v,d,c = LI()
e[u].append((v,d,c))
e[v].append((u,d,c))
def search(s):
d = collections.defaultdict(lambda: inf)
d[s] = 0
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
for uv, ud, _ in e[u]:
if v[uv]:
continue
vd = k + ud
if d[uv] > vd:
d[uv] = vd
heapq.heappush(q, (vd, uv))
return d
d = search(1)
r = 0
for i in range(2,n+1):
t = inf
for j,dd,c in e[i]:
if d[i] - dd == d[j] and t > c:
t = c
r += t
return r
while 1:
n,m = LI()
if n == 0 and m == 0:
break
rr.append(f(n,m))
# print('rr', rr[-1])
return '\n'.join(map(str,rr))
print(main())
``` | output | 1 | 29,057 | 1 | 58,115 |
Provide a correct Python 3 solution for this coding contest problem.
King Mercer is the king of ACM kingdom. There are one capital and some cities in his kingdom. Amazingly, there are no roads in the kingdom now. Recently, he planned to construct roads between the capital and the cities, but it turned out that the construction cost of his plan is much higher than expected.
In order to reduce the cost, he has decided to create a new construction plan by removing some roads from the original plan. However, he believes that a new plan should satisfy the following conditions:
* For every pair of cities, there is a route (a set of roads) connecting them.
* The minimum distance between the capital and each city does not change from his original plan.
Many plans may meet the conditions above, but King Mercer wants to know the plan with minimum cost. Your task is to write a program which reads his original plan and calculates the cost of a new plan with the minimum cost.
Input
The input consists of several datasets. Each dataset is formatted as follows.
N M
u1 v1 d1 c1
.
.
.
uM vM dM cM
The first line of each dataset begins with two integers, N and M (1 β€ N β€ 10000, 0 β€ M β€ 20000). N and M indicate the number of cities and the number of roads in the original plan, respectively.
The following M lines describe the road information in the original plan. The i-th line contains four integers, ui, vi, di and ci (1 β€ ui, vi β€ N , ui β vi , 1 β€ di β€ 1000, 1 β€ ci β€ 1000). ui , vi, di and ci indicate that there is a road which connects ui-th city and vi-th city, whose length is di and whose cost needed for construction is ci.
Each road is bidirectional. No two roads connect the same pair of cities. The 1-st city is the capital in the kingdom.
The end of the input is indicated by a line containing two zeros separated by a space. You should not process the line as a dataset.
Output
For each dataset, print the minimum cost of a plan which satisfies the conditions in a line.
Example
Input
3 3
1 2 1 2
2 3 2 1
3 1 3 2
5 5
1 2 2 2
2 3 1 1
1 4 1 1
4 5 1 1
5 3 1 1
5 10
1 2 32 10
1 3 43 43
1 4 12 52
1 5 84 23
2 3 58 42
2 4 86 99
2 5 57 83
3 4 11 32
3 5 75 21
4 5 23 43
5 10
1 2 1 53
1 3 1 65
1 4 1 24
1 5 1 76
2 3 1 19
2 4 1 46
2 5 1 25
3 4 1 13
3 5 1 65
4 5 1 34
0 0
Output
3
5
137
218 | instruction | 0 | 29,058 | 1 | 58,116 |
"Correct Solution:
```
from heapq import heappush, heappop
def dijkstra(edges, size, source):
distance = [float('inf')] * size
distance[source] = 0
visited = [False] * size
pq = []
heappush(pq, (0, source))
while pq:
dist_u, u = heappop(pq)
visited[u] = True
for v, weight, _ in edges[u]:
if not visited[v]:
new_dist = dist_u + weight
if distance[v] > new_dist:
distance[v] = new_dist
heappush(pq, (new_dist, v))
return distance
while True:
N, M = map(int, input().split())
if N == M == 0:
break
edges = [[] for i in range(N)]
for i in range(M):
u, v, d, c = map(int, input().split())
u -= 1
v -= 1
edges[u].append((v, d, c))
edges[v].append((u, d, c))
dist = dijkstra(edges, N, 0)
ans = 0
for u in range(1, N):
cost = 1000
for v, d, c in edges[u]:
if dist[u] == dist[v] + d:
cost = min(cost, c)
ans += cost
print(ans)
``` | output | 1 | 29,058 | 1 | 58,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 β€ n β€ 105, 1 β€ a, d β€ 106) β the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 β€ t1 < t2... < tn - 1 < tn β€ 106, 1 β€ vi β€ 106) β the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds. | instruction | 0 | 29,381 | 1 | 58,762 |
Tags: implementation
Correct Solution:
```
# written with help of passed solutions
from math import sqrt
n, a, d = map(int, input().split())
a = float(a)
ans = [0] * n
tm = 0
for i in range(n):
t, v = map(int, input().split())
acc_t = v / a
add_t = 0
if acc_t ** 2 * a > 2 * d:
add_t = sqrt(2 * d / a)
else:
add_t = acc_t + (d - acc_t ** 2 * a / 2) / v
tm = max(tm, t + add_t)
ans[i] = tm
print('\n'.join(map(str, ans)))
# Made By Mostafa_Khaled
``` | output | 1 | 29,381 | 1 | 58,763 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 β€ n β€ 105, 1 β€ a, d β€ 106) β the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 β€ t1 < t2... < tn - 1 < tn β€ 106, 1 β€ vi β€ 106) β the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds. | instruction | 0 | 29,382 | 1 | 58,764 |
Tags: implementation
Correct Solution:
```
from math import sqrt
n,a,d=map(int,input().split())
old,ans=0,[0]*n
for i in range(n):
t,v=map(int,input().split())
x=(v**2)/2/a
if d<=x: # Π²ΡΠ΅ Π²ΡΠ΅ΠΌΡ ΡΠ°Π·Π³ΠΎΠ½
t1=t+sqrt(2*d/a)
else:
t1=t+v/a+(d-x)/v
old=max(t1,old)
ans[i]=old
print('\n'.join(map(str, ans)))
``` | output | 1 | 29,382 | 1 | 58,765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 β€ n β€ 105, 1 β€ a, d β€ 106) β the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 β€ t1 < t2... < tn - 1 < tn β€ 106, 1 β€ vi β€ 106) β the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds. | instruction | 0 | 29,383 | 1 | 58,766 |
Tags: implementation
Correct Solution:
```
from sys import stdin
import math
n,a,d=map(int,stdin.readline().split())
old=0
for z in stdin.readlines():
t,v=map(int,z.split())
x=(v**2)/2/a
if d<=x: # Π²ΡΠ΅ Π²ΡΠ΅ΠΌΡ ΡΠ°Π·Π³ΠΎΠ½
t1=t+math.sqrt(2*d/a)
else:
t1=t+v/a+(d-x)/v
old=max(t1,old)
print(old)
``` | output | 1 | 29,383 | 1 | 58,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 β€ n β€ 105, 1 β€ a, d β€ 106) β the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 β€ t1 < t2... < tn - 1 < tn β€ 106, 1 β€ vi β€ 106) β the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds. | instruction | 0 | 29,384 | 1 | 58,768 |
Tags: implementation
Correct Solution:
```
from sys import stdin, stdout
input = stdin.readline
n, a, d = map(int, input().split())
arr = [tuple(map(int, input().split())) for _ in range(n)]
res = [0] * n
for i in range(n):
t, v = arr[i]
x = v / a
y = (2 * d / a) ** 0.5
res[i] = (t + y if y < x else t + d/v + x/2)
res[i] = max(res[i-1], res[i])
print('\n'.join(map(str, res)))
``` | output | 1 | 29,384 | 1 | 58,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 β€ n β€ 105, 1 β€ a, d β€ 106) β the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 β€ t1 < t2... < tn - 1 < tn β€ 106, 1 β€ vi β€ 106) β the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds. | instruction | 0 | 29,385 | 1 | 58,770 |
Tags: implementation
Correct Solution:
```
'''input
1 2 26
28 29
'''
import math
def get_time(t, v):
total = t
t1 = math.sqrt((2 * d)/ a)
if a* t1 < v:
total += t1
else:
t2 = v/a
total += t2
r_d = d - 0.5 *(a * t2 * t2)
total += r_d/v
return total
from sys import stdin, stdout
# main starts
n,a , d = list(map(int, stdin.readline().split()))
time = []
for i in range(n):
t, v = list(map(int, stdin.readline().split()))
time.append(get_time(t, v))
ans = []
ans.append(time[0])
prev = time[0]
for i in range(1, n):
if time[i] <= prev:
ans.append(prev)
else:
prev = time[i]
ans.append(time[i])
for i in ans:
print(i)
``` | output | 1 | 29,385 | 1 | 58,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 β€ n β€ 105, 1 β€ a, d β€ 106) β the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 β€ t1 < t2... < tn - 1 < tn β€ 106, 1 β€ vi β€ 106) β the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds. | instruction | 0 | 29,386 | 1 | 58,772 |
Tags: implementation
Correct Solution:
```
from sys import stdin, stdout
n, a, s = map(int, stdin.readline().split())
last = 0
for i in range(n):
t, v = map(int, stdin.readline().split())
if not i:
if (2 * s / a) ** 0.5 <= v / a:
time = (2 * s / a) ** 0.5
else:
d = s - (v * v) / (a * 2)
time = v / a + d / v
last = time + t
else:
if (2 * s / a) ** 0.5 <= v / a:
time = (2 * s / a) ** 0.5
else:
d = s - (v * v) / (a * 2)
time = v / a + d / v
last = max(time + t, last)
stdout.write(str(last) + '\n')
``` | output | 1 | 29,386 | 1 | 58,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 β€ n β€ 105, 1 β€ a, d β€ 106) β the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 β€ t1 < t2... < tn - 1 < tn β€ 106, 1 β€ vi β€ 106) β the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds. | instruction | 0 | 29,387 | 1 | 58,774 |
Tags: implementation
Correct Solution:
```
from sys import stdin
from math import sqrt
n, a, d = map(int, stdin.readline().split())
test = stdin.readlines()
prev = 0
for line in test:
t, v = map(int, line.split())
x = v * v / 2 / a
if d <= x:
ans = sqrt(2 * d / a) + t
else:
ans = v / a + (d - x) / v + t
ans = max(ans, prev)
prev = ans
print(ans)
``` | output | 1 | 29,387 | 1 | 58,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 β€ n β€ 105, 1 β€ a, d β€ 106) β the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 β€ t1 < t2... < tn - 1 < tn β€ 106, 1 β€ vi β€ 106) β the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds. | instruction | 0 | 29,388 | 1 | 58,776 |
Tags: implementation
Correct Solution:
```
# written with help of passed solutions
from math import sqrt
n, a, d = map(int, input().split())
a = float(a)
ans = [0] * n
tm = 0
for i in range(n):
t, v = map(int, input().split())
acc_t = v / a
add_t = 0
if acc_t ** 2 * a > 2 * d:
add_t = sqrt(2 * d / a)
else:
add_t = acc_t + (d - acc_t ** 2 * a / 2) / v
tm = max(tm, t + add_t)
ans[i] = tm
print('\n'.join(map(str, ans)))
``` | output | 1 | 29,388 | 1 | 58,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys. | instruction | 0 | 29,442 | 1 | 58,884 |
Tags: greedy, implementation
Correct Solution:
```
c1,c2,c3,c4=map(int,input().split())
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
ans=0
for i in range(0,len(a)):
ans+=min(c2,a[i]*c1)
ans=min(ans,c3)
ans1=0
for i in range(0,len(b)):
ans1+=min(c2,b[i]*c1)
ans1=min(c3,ans1)
print(min(c4,ans1+ans))
``` | output | 1 | 29,442 | 1 | 58,885 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys. | instruction | 0 | 29,443 | 1 | 58,886 |
Tags: greedy, implementation
Correct Solution:
```
def main():
c1, c2, c3, c4 = map(int, input().split())
input()
aa = list(map(int, input().split()))
bb = list(map(int, input().split()))
t = c2 // c1
c5, c6 = (sum(c1 * x if x <= t else c2 for x in l) for l in (aa, bb))
print(min(c3 * 2, c3 + c5, c3 + c6, c5 + c6, c4))
if __name__ == '__main__':
main()
``` | output | 1 | 29,443 | 1 | 58,887 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys. | instruction | 0 | 29,444 | 1 | 58,888 |
Tags: greedy, implementation
Correct Solution:
```
# t = int(input())
# l = set([])
# for i in range(t):
# strs = input().split(" ")
# for i in range(int(strs[0]), int(strs[1])+1,1):
# l.add(i)
# print(len(l))
c = list(map(int, input().split(' ')))
c1 = c [0]
c2 = c [1]
c3 = c [2]
c4 = c [3]
input()
busRides = list(map(int, input().split(' ')))
troRides = list(map(int, input().split(' ')))
busSum = 0
for rides in busRides:
busSum += min(c2,rides*c1)
busMin = min(c3,busSum)
troSum = 0
for rides in troRides:
troSum += min(c2,rides*c1)
troMin = min(c3,troSum)
print(min(c4,troMin+busMin))
``` | output | 1 | 29,444 | 1 | 58,889 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys. | instruction | 0 | 29,445 | 1 | 58,890 |
Tags: greedy, implementation
Correct Solution:
```
c1,c2,c3,c4=map(int,input().split())
n,m=map(int,input().split())
n1=list(map(int,input().split()))
m1=list(map(int,input().split()))
s1=0
r=[]
for i in range(n):
if((n1[i]*c1)>(c2)):
s1=s1+c2
else:
s1=s1+n1[i]*c1
r.append(s1+c3)
s2=0
for i in range(m):
if((m1[i]*c1)>(c2)):
s2=s2+c2
else:
s2=s2+m1[i]*c1
r.append(s2+c3)
r.append(s1+s2)
r.append(2*c3)
r.append(c4)
print(min(r))
``` | output | 1 | 29,445 | 1 | 58,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys. | instruction | 0 | 29,446 | 1 | 58,892 |
Tags: greedy, implementation
Correct Solution:
```
c = list(map(int, input().split()))
n, m = map(int, input().split())
p, q = list(map(int, input().split())), list(map(int, input().split()))
print(min(c[3], min(c[2], sum(min(c[0] * i, c[1]) for i in p)) + min(c[2], sum(min(c[0] * i, c[1]) for i in q))))
``` | output | 1 | 29,446 | 1 | 58,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys. | instruction | 0 | 29,447 | 1 | 58,894 |
Tags: greedy, implementation
Correct Solution:
```
c1,c2,c3,c4=map(int,input().split())
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
s=[]
s0=0
for i in range(n):
s.append(min(a[i]*c1,c2))
s0+=s[i]
s1=[]
s10=0
for i in range(m):
s1.append(min(b[i]*c1,c2))
s10+=s1[i]
print(min((min(s0,c3)+min(s10,c3)),c4))
``` | output | 1 | 29,447 | 1 | 58,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys. | instruction | 0 | 29,448 | 1 | 58,896 |
Tags: greedy, implementation
Correct Solution:
```
a,b,c,d = input().split()
a,b,c,d = int(a), int(b), int(c), int(d)
n,m = input().split()
n,m = int(n), int(m)
nums1 = list(map(int, input().split()))
nums2 = list(map(int, input().split()))
nums1.sort(reverse=True)
nums2.sort(reverse=True)
m1 = 0
for i in nums1:
if i*a < b:
m1+=i*a
else:
m1+=b
m2 = b*len(nums1)
m3 = c
l1 = [m1,m2,m3]
m5 = 0
for i in nums2:
if i*a < b:
m5+=i*a
else:
m5+=b
m6 = b*len(nums2)
m7 = c
l2 = [m5,m6,m7]
res = float('inf')
for i in l1:
for j in l2:
res = min(res, i+j)
res = min(res, d)
print(res)
``` | output | 1 | 29,448 | 1 | 58,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys. | instruction | 0 | 29,449 | 1 | 58,898 |
Tags: greedy, implementation
Correct Solution:
```
a,b,c,d = map(int, input().split())
n, m = map(int, input().split())
t = list(map(int, input().split()))
h = list(map(int, input().split()))
v = []
w = []
for i in t:
v.append(min(a*i, b))
for i in h:
w.append(min(a*i,b))
t = min(c,sum(v))
h = min(c,sum(w))
print(min(d,t+h))
``` | output | 1 | 29,449 | 1 | 58,899 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys.
Submitted Solution:
```
a,b,c,d = map(int,input().split())
bu,tr = map(int,input().split())
bl = list(map(int,input().split()))
tl = list(map(int,input().split()))
t = 0
to = 0
for x in bl:
if a*x > b: to += b
else: to += a*x
if to >= c: to = c
p1 = to
to = 0
for x in tl:
if a*x > b: to += b
else: to += a*x
if to >= c: to = c
to += p1
if to > d:
to = d
print(to)
``` | instruction | 0 | 29,450 | 1 | 58,900 |
Yes | output | 1 | 29,450 | 1 | 58,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys.
Submitted Solution:
```
c = list(map(int, input().split()))
n, m = map(int, input().split())
p, q = list(map(int, input().split())), list(map(int, input().split()))
print(min(c[3], min(c[2], sum(min(c[0] * i, c[1]) for i in p)) + min(c[2], sum(min(c[0] * i, c[1]) for i in q))))
# Made By Mostafa_Khaled
``` | instruction | 0 | 29,451 | 1 | 58,902 |
Yes | output | 1 | 29,451 | 1 | 58,903 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys.
Submitted Solution:
```
c1,c2,c3,c4=list(map(int,input().split()))
n,m=list(map(int,input().split()))
bus=list(map(int,input().split()))
tro=list(map(int,input().split()))
x1,x2,x3=0,0,0
for item in bus:
if item*c1>c2:
x1+=c2
else:
x1+=item*c1
for item in tro:
if item*c1>c2:
x2+=c2
else:
x2+=item*c1
x3=min(x1,c3)+min(x2,c3)
if c4<x3:
print(c4)
else:
print(x3)
``` | instruction | 0 | 29,452 | 1 | 58,904 |
Yes | output | 1 | 29,452 | 1 | 58,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys.
Submitted Solution:
```
a,b,c,d=map(int,input().split())
n,m=map(int,input().split())
s,ans=0,0
bus=list(map(int,input().split()))
tr=list(map(int,input().split()))
for i in bus:
s=s+min(b,a*i)
for i in tr:
ans=ans+min(b,a*i)
print(min(d,min(s,c)+min(ans,c)))
``` | instruction | 0 | 29,453 | 1 | 58,906 |
Yes | output | 1 | 29,453 | 1 | 58,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys.
Submitted Solution:
```
s=input().split();c1,c2,c3,c4=int(s[0]),int(s[1]),int(s[2]),int(s[3])
s=input().split();n,m=int(s[0]),int(s[1]);a,b,c,d=0,0,0,0
x=input().split();y=input().split();xx=[];yy=[]
a=c1*(n+m);b=c2*(n+m);c=c3*2;d=c4
print(min(a,b,c,d))
``` | instruction | 0 | 29,454 | 1 | 58,908 |
No | output | 1 | 29,454 | 1 | 58,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys.
Submitted Solution:
```
if __name__ == '__main__':
c1,c2,c3,c4 = map(int, input().split())
n,m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = min(c1,c2,c3,c4)
l = []
if s == c4:
print(c4)
else:
required = 0
for i in range (n):
required = required+min(c2,c1*a[i])
ans = min(c3,required)
required = 0
for i in range (m):
required = required + min(c2,c1*b[i])
ans = ans + min(c3,required)
print(min(ans,c4))
``` | instruction | 0 | 29,455 | 1 | 58,910 |
No | output | 1 | 29,455 | 1 | 58,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys.
Submitted Solution:
```
if __name__ == '__main__':
c1,c2,c3,c4 = map(int, input().split())
n,m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = min(c1,c2,c3,c4)
l = []
if s == c4:
print(c4)
else:
required = 0
for i in range (n):
required = required+min(c2,c1*a[i])
ans = min(c3,required)
required = 0
for i in range (m):
required = required + min(c2,c1*b[i])
ans = ans + min(c3,required)
print(ans)
``` | instruction | 0 | 29,456 | 1 | 58,912 |
No | output | 1 | 29,456 | 1 | 58,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 β€ c1, c2, c3, c4 β€ 1000) β the costs of the tickets.
The second line contains two integers n and m (1 β€ n, m β€ 1000) β the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 β€ ai β€ 1000) β the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 β€ bi β€ 1000) β the number of times Vasya is going to use the trolley number i.
Output
Print a single number β the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2Β·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys.
Submitted Solution:
```
if __name__=='__main__':
arr = input().split(' ')
c = []
for a in arr:
c.append(int(a))
ans = min(c[3],2*c[2])
arr = input().split(' ')
n = int(arr[0])
m = int(arr[1])
an = []
am = []
arr = input().split(' ')
for a in arr:
an.append(int(a))
arr = input().split(' ')
for a in arr:
am.append(int(a))
ca = 0
for a in an:
if a*c[0]<c[1]:
ca+=a*c[0]
else:
ca+=c[1]
ca=min(ca,c[2])
cb = 0
for a in am:
if a*c[0]<c[1]:
cb+=a*c[0]
else:
cb+=c[1]
cb = min(cb,c[2])
ans = min(ans,ca+cb)
``` | instruction | 0 | 29,457 | 1 | 58,914 |
No | output | 1 | 29,457 | 1 | 58,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Musicians of a popular band "Flayer" have announced that they are going to "make their exit" with a world tour. Of course, they will visit Berland as well.
There are n cities in Berland. People can travel between cities using two-directional train routes; there are exactly m routes, i-th route can be used to go from city vi to city ui (and from ui to vi), and it costs wi coins to use this route.
Each city will be visited by "Flayer", and the cost of the concert ticket in i-th city is ai coins.
You have friends in every city of Berland, and they, knowing about your programming skills, asked you to calculate the minimum possible number of coins they have to pay to visit the concert. For every city i you have to compute the minimum number of coins a person from city i has to spend to travel to some city j (or possibly stay in city i), attend a concert there, and return to city i (if j β i).
Formally, for every <image> you have to calculate <image>, where d(i, j) is the minimum number of coins you have to spend to travel from city i to city j. If there is no way to reach city j from city i, then we consider d(i, j) to be infinitely large.
Input
The first line contains two integers n and m (2 β€ n β€ 2Β·105, 1 β€ m β€ 2Β·105).
Then m lines follow, i-th contains three integers vi, ui and wi (1 β€ vi, ui β€ n, vi β ui, 1 β€ wi β€ 1012) denoting i-th train route. There are no multiple train routes connecting the same pair of cities, that is, for each (v, u) neither extra (v, u) nor (u, v) present in input.
The next line contains n integers a1, a2, ... ak (1 β€ ai β€ 1012) β price to attend the concert in i-th city.
Output
Print n integers. i-th of them must be equal to the minimum number of coins a person from city i has to spend to travel to some city j (or possibly stay in city i), attend a concert there, and return to city i (if j β i).
Examples
Input
4 2
1 2 4
2 3 7
6 20 1 25
Output
6 14 1 25
Input
3 3
1 2 1
2 3 1
1 3 1
30 10 20
Output
12 10 12 | instruction | 0 | 29,711 | 1 | 59,422 |
Tags: data structures, graphs, shortest paths
Correct Solution:
```
from __future__ import division, print_function
py2 = round(0.5)
# Should take 900 ms something
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import BytesIO, IOBase
# FastIO for PyPy2 and PyPy3 by Pajenegod,
class FastI(object):
def __init__(self, fd=0, buffersize=2**14):
self.stream = stream = BytesIO(); self.bufendl = 0
def read2buffer():
curpos = stream.tell(); s = os.read(fd, buffersize + os.fstat(fd).st_size)
stream.seek(0,2); stream.write(s); stream.seek(curpos); return s
self.read2buffer = read2buffer
def read(self):
while self.read2buffer(): pass
return self.stream.read() if self.stream.tell() else self.stream.getvalue()
def readline(self):
while self.bufendl == 0: s = self.read2buffer(); self.bufendl += s.count(b'\n') + (not s)
self.bufendl -= 1; return self.stream.readline()
def input(self): return self.readline().rstrip(b'\r\n')
# Reads n integers (n=-1 is until end of input), use zero to change type
def readnumbers(self, n=-1, zero=0):
conv = ord if py2 else lambda x:x
# Figure out curpos and buffer size
curpos = self.stream.tell()
self.stream.seek(0,2)
buffsize = self.stream.tell()
self.stream.seek(curpos)
A = []; numb = zero; sign = 1
while n==-1 or len(A)<n:
# If at end of current buffer
if curpos >= buffsize:
s = self.read2buffer()
buffsize += len(s)
self.bufendl += s.count(b'\n') + (not s)
if curpos==buffsize: break
for i,c in enumerate(self.stream.read(min(32,buffsize-curpos))):
if c >= b'0'[0]: numb = 10 * numb + (conv(c) - 48)
elif c == b'-'[0]: sign = -1
elif c != b'\r'[0]: # whitespace
if c == b'\n'[0]: self.bufendl -= 1
A.append(sign*numb)
if n!=-1 and len(A)==n: break
numb = zero; sign = 1
curpos += i + 1
# If no trailing whitespace
if curpos == buffsize and not self.stream.seek(-1,2) and self.stream.read(1)[0] >= b'0'[0]:
self.bufendl -= 1
A.append(sign*numb)
assert(n==-1 or len(A)==n)
self.stream.seek(curpos)
return A
class FastO(IOBase):
def __init__(self, fd=1):
stream = BytesIO()
self.flush = lambda: os.write(1, stream.getvalue()) and not stream.truncate(0) and stream.seek(0)
self.write = stream.write if py2 else lambda s: stream.write(s.encode())
sys.stdin, sys.stdout = FastI(), FastO()
input = sys.stdin.readline
big = 3E12
class segheap:
def __init__(self,data):
n = len(data)
m = 1
while m<n:m*=2
self.n = n
self.m = m
self.data = [big]*(2*m)
for i in range(n):
self.data[i+m] = data[i]
for i in reversed(range(m)):
self.data[i] = min(self.data[2*i],self.data[2*i+1])
def mini(self):
i = 1
while i<self.m:
if self.data[i]==self.data[2*i]:
i = 2*i
else:
i = 2*i+1
i -= self.m
self.setter(i,big)
return i
def setter(self,ind,val):
ind += self.m
if val<self.data[ind]:
while ind>0 and self.data[ind]>val:
self.data[ind] = val
ind //= 2
elif val>self.data[ind]:
old_val = self.data[ind]
self.data[ind] = val
ind //= 2
while ind>0 and self.data[ind]==old_val:
self.data[ind] = min(self.data[2*ind],self.data[2*ind+1])
ind //= 2
n, m = [int(x) for x in sys.stdin.readline().split()]
inp = sys.stdin.readnumbers(-1, 0.0)
coupl = [[] for _ in range(n)]
cost = [[] for _ in range(n)]
for _ in range(m):
v = int(inp[_*3+0])-1
u = int(inp[_*3+1])-1
w = inp[_*3+2]
coupl[v].append(u)
coupl[u].append(v)
cost[u].append(w)
cost[v].append(w)
best = [inp[3*m + i] for i in range(n)]
Q = segheap(best)
while Q.data[1]!=big:
c = Q.data[1]
node = Q.mini()
if best[node]!=c:
continue
for j in range(len(coupl[node])):
nei = coupl[node][j]
C = c+2*cost[node][j]
if C<best[nei]:
best[nei] = C
Q.setter(nei,C)
for x in best:
sys.stdout.write(str(int(x)))
sys.stdout.write(' ')
``` | output | 1 | 29,711 | 1 | 59,423 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Musicians of a popular band "Flayer" have announced that they are going to "make their exit" with a world tour. Of course, they will visit Berland as well.
There are n cities in Berland. People can travel between cities using two-directional train routes; there are exactly m routes, i-th route can be used to go from city vi to city ui (and from ui to vi), and it costs wi coins to use this route.
Each city will be visited by "Flayer", and the cost of the concert ticket in i-th city is ai coins.
You have friends in every city of Berland, and they, knowing about your programming skills, asked you to calculate the minimum possible number of coins they have to pay to visit the concert. For every city i you have to compute the minimum number of coins a person from city i has to spend to travel to some city j (or possibly stay in city i), attend a concert there, and return to city i (if j β i).
Formally, for every <image> you have to calculate <image>, where d(i, j) is the minimum number of coins you have to spend to travel from city i to city j. If there is no way to reach city j from city i, then we consider d(i, j) to be infinitely large.
Input
The first line contains two integers n and m (2 β€ n β€ 2Β·105, 1 β€ m β€ 2Β·105).
Then m lines follow, i-th contains three integers vi, ui and wi (1 β€ vi, ui β€ n, vi β ui, 1 β€ wi β€ 1012) denoting i-th train route. There are no multiple train routes connecting the same pair of cities, that is, for each (v, u) neither extra (v, u) nor (u, v) present in input.
The next line contains n integers a1, a2, ... ak (1 β€ ai β€ 1012) β price to attend the concert in i-th city.
Output
Print n integers. i-th of them must be equal to the minimum number of coins a person from city i has to spend to travel to some city j (or possibly stay in city i), attend a concert there, and return to city i (if j β i).
Examples
Input
4 2
1 2 4
2 3 7
6 20 1 25
Output
6 14 1 25
Input
3 3
1 2 1
2 3 1
1 3 1
30 10 20
Output
12 10 12 | instruction | 0 | 29,712 | 1 | 59,424 |
Tags: data structures, graphs, shortest paths
Correct Solution:
```
from __future__ import division, print_function
import os
import sys
import io
class FastI():
""" FastIO for PyPy3 by Pajenegod """
stream = io.BytesIO()
newlines = 0
def read1(self):
b, ptr = os.read(0, (1 << 13) + os.fstat(0).st_size), self.stream.tell()
self.stream.seek(0, 2)
self.stream.write(b)
self.stream.seek(ptr)
return b
def read(self):
while self.read1():
pass
return self.stream.read() if self.stream.tell() else self.stream.getvalue()
def readline(self):
while self.newlines == 0:
b = self.read1()
self.newlines += b.count(b'\n') + (not b)
self.newlines -= 1
return self.stream.readline()
def readnumber(self, var=int):
""" Read numbers till EOF. Use var to change type. """
b = self.read()
num, sign = var(0), 1
for char in b:
if char >= b'0' [0]:
num = 10 * num + char - 48
elif char == b'-' [0]:
sign = -1
elif char != b'\r' [0]:
yield sign * num
num, sign = var(0), 1
if b and b[-1] >= b'0' [0]:
yield sign * num
sys.stdin = FastI()
input = sys.stdin.readline
sys.stdout, stream = io.IOBase(), io.BytesIO()
sys.stdout.flush = lambda: os.write(1, stream.getvalue()) and not stream.truncate(0) and stream.seek(0)
sys.stdout.write = lambda s: stream.write(s.encode())
sys.stdin = FastI()
input = sys.stdin.readline
big = 3E12
class segheap:
def __init__(self, data):
n = len(data)
m = 1
while m < n:
m *= 2
self.n = n
self.m = m
self.data = [big] * (2 * m)
for i in range(n):
self.data[i + m] = data[i]
for i in reversed(range(m)):
self.data[i] = min(self.data[2 * i], self.data[2 * i + 1])
def mini(self):
i = 1
while i < self.m:
if self.data[i] == self.data[2 * i]:
i = 2 * i
else:
i = 2 * i + 1
i -= self.m
self.setter(i, big)
return i
def setter(self, ind, val):
ind += self.m
if val < self.data[ind]:
while ind > 0 and self.data[ind] > val:
self.data[ind] = val
ind //= 2
elif val > self.data[ind]:
old_val = self.data[ind]
self.data[ind] = val
ind //= 2
while ind > 0 and self.data[ind] == old_val:
self.data[ind] = min(self.data[2 * ind], self.data[2 * ind + 1])
ind //= 2
inp = sys.stdin.readnumber(float)
n, m = int(next(inp)), int(next(inp))
coupl = [[] for _ in range(n)]
cost = [[] for _ in range(n)]
for _ in range(m):
v = int(next(inp) - 1)
u = int(next(inp) - 1)
w = next(inp)
coupl[v].append(u)
coupl[u].append(v)
cost[u].append(w)
cost[v].append(w)
best = [next(inp) for i in range(n)]
Q = segheap(best)
while Q.data[1] != big:
c = Q.data[1]
node = Q.mini()
if best[node] != c:
continue
for j in range(len(coupl[node])):
nei = coupl[node][j]
C = c + 2 * cost[node][j]
if C < best[nei]:
best[nei] = C
Q.setter(nei, C)
for x in best:
sys.stdout.write(str(int(x)))
sys.stdout.write(' ')
``` | output | 1 | 29,712 | 1 | 59,425 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.