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.
Every day, N passengers arrive at Takahashi Airport. The i-th passenger arrives at time T_i.
Every passenger arrived at Takahashi airport travels to the city by bus. Each bus can accommodate up to C passengers. Naturally, a passenger cannot take a bus that departs earlier than the airplane arrives at the airport. Also, a passenger will get angry if he/she is still unable to take a bus K units of time after the arrival of the airplane. For that reason, it is necessary to arrange buses so that the i-th passenger can take a bus departing at time between T_i and T_i + K (inclusive).
When setting the departure times for buses under this condition, find the minimum required number of buses. Here, the departure time for each bus does not need to be an integer, and there may be multiple buses that depart at the same time.
Constraints
* 2 \leq N \leq 100000
* 1 \leq C \leq 10^9
* 1 \leq K \leq 10^9
* 1 \leq T_i \leq 10^9
* C, K and T_i are integers.
Input
The input is given from Standard Input in the following format:
N C K
T_1
T_2
:
T_N
Output
Print the minimum required number of buses.
Examples
Input
5 3 5
1
2
3
6
12
Output
3
Input
6 3 3
7
6
2
8
10
6
Output
3
Submitted Solution:
```
N,C,K = map(int,input().split())
T = [int(input()) for i in range(N)]
T.sort()
ans = 1
bus = [T[0]]
l = 1
for i in range(1,N):
if T[i]-bus[0] <= K and l <= C-1:
l += 1
else:
bus = [T[i]]
l = 1
ans += 1
print(ans)
``` | instruction | 0 | 41,951 | 1 | 83,902 |
Yes | output | 1 | 41,951 | 1 | 83,903 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Every day, N passengers arrive at Takahashi Airport. The i-th passenger arrives at time T_i.
Every passenger arrived at Takahashi airport travels to the city by bus. Each bus can accommodate up to C passengers. Naturally, a passenger cannot take a bus that departs earlier than the airplane arrives at the airport. Also, a passenger will get angry if he/she is still unable to take a bus K units of time after the arrival of the airplane. For that reason, it is necessary to arrange buses so that the i-th passenger can take a bus departing at time between T_i and T_i + K (inclusive).
When setting the departure times for buses under this condition, find the minimum required number of buses. Here, the departure time for each bus does not need to be an integer, and there may be multiple buses that depart at the same time.
Constraints
* 2 \leq N \leq 100000
* 1 \leq C \leq 10^9
* 1 \leq K \leq 10^9
* 1 \leq T_i \leq 10^9
* C, K and T_i are integers.
Input
The input is given from Standard Input in the following format:
N C K
T_1
T_2
:
T_N
Output
Print the minimum required number of buses.
Examples
Input
5 3 5
1
2
3
6
12
Output
3
Input
6 3 3
7
6
2
8
10
6
Output
3
Submitted Solution:
```
n, c, k = map(int, input().split())
T = sorted([int(input()) for _ in range(n)])
out = T.pop(0) + k
peo = 1
bus = 1
for t in T:
if t <= out and peo < c:
peo += 1
else:
out = t + k
peo = 1
bus += 1
print(bus)
``` | instruction | 0 | 41,952 | 1 | 83,904 |
Yes | output | 1 | 41,952 | 1 | 83,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Every day, N passengers arrive at Takahashi Airport. The i-th passenger arrives at time T_i.
Every passenger arrived at Takahashi airport travels to the city by bus. Each bus can accommodate up to C passengers. Naturally, a passenger cannot take a bus that departs earlier than the airplane arrives at the airport. Also, a passenger will get angry if he/she is still unable to take a bus K units of time after the arrival of the airplane. For that reason, it is necessary to arrange buses so that the i-th passenger can take a bus departing at time between T_i and T_i + K (inclusive).
When setting the departure times for buses under this condition, find the minimum required number of buses. Here, the departure time for each bus does not need to be an integer, and there may be multiple buses that depart at the same time.
Constraints
* 2 \leq N \leq 100000
* 1 \leq C \leq 10^9
* 1 \leq K \leq 10^9
* 1 \leq T_i \leq 10^9
* C, K and T_i are integers.
Input
The input is given from Standard Input in the following format:
N C K
T_1
T_2
:
T_N
Output
Print the minimum required number of buses.
Examples
Input
5 3 5
1
2
3
6
12
Output
3
Input
6 3 3
7
6
2
8
10
6
Output
3
Submitted Solution:
```
#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))
N,C,K = map(int,input().split())
T = [int(input()) for _ in range(N)]
T.sort()
T.append(T[-1])
fst = T[0]
cnt = 1
ans = 0
flg = 0
for i in range(1,N):
cnt += 1
flg = 0
if T[i]-fst > K:
fst = T[i]
cnt = 1
ans += 1
elif cnt == C:
fst = T[i+1]
cnt = 0
ans += 1
flg = 1
# print(i,T[i],flg,fst,ans,cnt)
if not(flg):
ans += 1
print(ans+1)
``` | instruction | 0 | 41,953 | 1 | 83,906 |
No | output | 1 | 41,953 | 1 | 83,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Every day, N passengers arrive at Takahashi Airport. The i-th passenger arrives at time T_i.
Every passenger arrived at Takahashi airport travels to the city by bus. Each bus can accommodate up to C passengers. Naturally, a passenger cannot take a bus that departs earlier than the airplane arrives at the airport. Also, a passenger will get angry if he/she is still unable to take a bus K units of time after the arrival of the airplane. For that reason, it is necessary to arrange buses so that the i-th passenger can take a bus departing at time between T_i and T_i + K (inclusive).
When setting the departure times for buses under this condition, find the minimum required number of buses. Here, the departure time for each bus does not need to be an integer, and there may be multiple buses that depart at the same time.
Constraints
* 2 \leq N \leq 100000
* 1 \leq C \leq 10^9
* 1 \leq K \leq 10^9
* 1 \leq T_i \leq 10^9
* C, K and T_i are integers.
Input
The input is given from Standard Input in the following format:
N C K
T_1
T_2
:
T_N
Output
Print the minimum required number of buses.
Examples
Input
5 3 5
1
2
3
6
12
Output
3
Input
6 3 3
7
6
2
8
10
6
Output
3
Submitted Solution:
```
def main():
N, C, K = list(map(int, input().split()))
T = [int(input()) for _ in range(N)]
# 到着時刻が遅い人から貪欲に拾っていく
T.sort(reverse=True)
arrival_time_from = T[0] - K
cnt_bus, cnt_passenger = 1, 0
for t in T:
if t >= arrival_time_from:
if cnt_passenger == C:
cnt_passenger = 1
cnt_bus += 1
else:
cnt_passenger += 1
else:
arrival_time_from = t - K
cnt_passenger = 1
cnt_bus += 1
print(cnt_bus)
if __name__ == '__main__':
main()
``` | instruction | 0 | 41,954 | 1 | 83,908 |
No | output | 1 | 41,954 | 1 | 83,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Every day, N passengers arrive at Takahashi Airport. The i-th passenger arrives at time T_i.
Every passenger arrived at Takahashi airport travels to the city by bus. Each bus can accommodate up to C passengers. Naturally, a passenger cannot take a bus that departs earlier than the airplane arrives at the airport. Also, a passenger will get angry if he/she is still unable to take a bus K units of time after the arrival of the airplane. For that reason, it is necessary to arrange buses so that the i-th passenger can take a bus departing at time between T_i and T_i + K (inclusive).
When setting the departure times for buses under this condition, find the minimum required number of buses. Here, the departure time for each bus does not need to be an integer, and there may be multiple buses that depart at the same time.
Constraints
* 2 \leq N \leq 100000
* 1 \leq C \leq 10^9
* 1 \leq K \leq 10^9
* 1 \leq T_i \leq 10^9
* C, K and T_i are integers.
Input
The input is given from Standard Input in the following format:
N C K
T_1
T_2
:
T_N
Output
Print the minimum required number of buses.
Examples
Input
5 3 5
1
2
3
6
12
Output
3
Input
6 3 3
7
6
2
8
10
6
Output
3
Submitted Solution:
```
# -*- coding: utf-8 -*-
def main():
n, c, k = list(map(int, input().split()))
t = [0] * n
for i in range(n):
ti = int(input())
t[i] = (ti, ti + k)
sorted_t = sorted(t, key=lambda x: x[1])
current_pos = sorted_t[0][1]
remain = c
bus_count = 1
for i in range(1, n):
if remain >= 1 and sorted_t[i][0] < current_pos <= sorted_t[i][1]:
remain -= 1
else:
bus_count += 1
current_pos = sorted_t[i][1]
remain = c
print(bus_count)
if __name__ == '__main__':
main()
``` | instruction | 0 | 41,955 | 1 | 83,910 |
No | output | 1 | 41,955 | 1 | 83,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Every day, N passengers arrive at Takahashi Airport. The i-th passenger arrives at time T_i.
Every passenger arrived at Takahashi airport travels to the city by bus. Each bus can accommodate up to C passengers. Naturally, a passenger cannot take a bus that departs earlier than the airplane arrives at the airport. Also, a passenger will get angry if he/she is still unable to take a bus K units of time after the arrival of the airplane. For that reason, it is necessary to arrange buses so that the i-th passenger can take a bus departing at time between T_i and T_i + K (inclusive).
When setting the departure times for buses under this condition, find the minimum required number of buses. Here, the departure time for each bus does not need to be an integer, and there may be multiple buses that depart at the same time.
Constraints
* 2 \leq N \leq 100000
* 1 \leq C \leq 10^9
* 1 \leq K \leq 10^9
* 1 \leq T_i \leq 10^9
* C, K and T_i are integers.
Input
The input is given from Standard Input in the following format:
N C K
T_1
T_2
:
T_N
Output
Print the minimum required number of buses.
Examples
Input
5 3 5
1
2
3
6
12
Output
3
Input
6 3 3
7
6
2
8
10
6
Output
3
Submitted Solution:
```
N, C, K = map(int, input().split(" "))
T = sorted([int(input()) for _ in range(N)])
bus = 1
key = T[0]
pas = 0
for i in range(N):
if T[i] - key > K:
bus += 1
key = T[i]
pas = 0
else:
pas += 1
if pas == C:
bus += 1
key = T[i+1]
pas = 0
print(bus)
``` | instruction | 0 | 41,956 | 1 | 83,912 |
No | output | 1 | 41,956 | 1 | 83,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
JOI, who came to Australia for a trip, enjoyed sightseeing in various places and finally returned to Japan. Now, JOI is in the town with the international airport where the return flight departs. The town is divided into north, south, east and west, and each section has roads, souvenir shops, houses, and an international airport. JOI starts from the northwestern section and heads for the international airport in the southeastern section.
JOI can move from the current parcel to an adjacent parcel, but cannot enter a parcel with a house. Also, move only to the east or south section of the current section in order to make it in time for the flight. However, there is some time to spare, so you can move to the north or west section of the section you are up to K times.
When JOI enters the area where the souvenir shop is located, he buys souvenirs for his Japanese friends. JOI did a lot of research on the souvenir shops, so he knows which souvenir shop to buy and how many souvenirs to buy. Create a program to find the maximum number of souvenirs you can buy.
However, the time to buy souvenirs can be ignored, and if you visit the same souvenir shop more than once, you will only buy souvenirs the first time you visit.
Example
Input
5 4 2
...#
.#.#
.#73
8##.
....
Output
11
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0581
"""
import sys
from sys import stdin
from collections import deque
from copy import copy
input = stdin.readline
def solve(field, K):
"""
:param field:
:return:
"""
# ????????????????§????????????´????????§?¨?????????????
dy = [-1, 1, 0, 0]
dx = [0, 0, -1, 1]
# ??°???????????????(?§????????????£????????????????????????????????§??????????????¨)
Y = len(field)
X = len(field[0])
d = [[float('inf')] * X for _ in range(Y)] # ??????????????°?????????????????¢???INF??§?????????
yorimichi = K
purchased = set()
max_gift = 0
# ???????????????????????????????????°???????????´????????°????????§????????¢????±???????
Q = deque()
Q.append((0, 0, copy(purchased), yorimichi))
while Q:
cx, cy, purchased, yorimichi= Q.popleft() # ?????¨??°?????§?¨?
if not '0' <= field[cy][cx] <= '9':
field[cy][cx] = '@'
for i in range(4):
nx = cx + dx[i]
ny = cy + dy[i]
# ?§?????????? ??°????????????????????????????????? and ?£?????????£???????????? and ??¢?????¢?´¢?????§?????? ??´???
if (not 0 <= nx < X) or (not 0 <= ny < Y):
continue
elif field[ny][nx] != '#':
if '0' <= field[ny][nx] <= '9':
purchased.add((nx, ny))
gift = 0
for gx, gy in purchased:
gift += int(field[gy][gx])
if gift > max_gift:
max_gift = gift
if yorimichi > 1:
if dy[i] == -1 or dx[i] == -1:
Q.append((nx, ny, copy(purchased), yorimichi-1))
else:
Q.append((nx, ny, copy(purchased), yorimichi))
return max_gift
def main(args):
H, W, K = map(int, input().split())
data = [input().strip('\n') for _ in range(H)]
field = [list(x) for x in data] # data????????????????????????????????????????????????
result = solve(field, K)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 42,011 | 1 | 84,022 |
No | output | 1 | 42,011 | 1 | 84,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
JOI, who came to Australia for a trip, enjoyed sightseeing in various places and finally returned to Japan. Now, JOI is in the town with the international airport where the return flight departs. The town is divided into north, south, east and west, and each section has roads, souvenir shops, houses, and an international airport. JOI starts from the northwestern section and heads for the international airport in the southeastern section.
JOI can move from the current parcel to an adjacent parcel, but cannot enter a parcel with a house. Also, move only to the east or south section of the current section in order to make it in time for the flight. However, there is some time to spare, so you can move to the north or west section of the section you are up to K times.
When JOI enters the area where the souvenir shop is located, he buys souvenirs for his Japanese friends. JOI did a lot of research on the souvenir shops, so he knows which souvenir shop to buy and how many souvenirs to buy. Create a program to find the maximum number of souvenirs you can buy.
However, the time to buy souvenirs can be ignored, and if you visit the same souvenir shop more than once, you will only buy souvenirs the first time you visit.
Example
Input
5 4 2
...#
.#.#
.#73
8##.
....
Output
11
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0581
"""
import sys
from sys import stdin
from collections import deque
from copy import copy
from collections import defaultdict
input = stdin.readline
def solve(field, K):
# ????????????????§????????????´????????§?¨?????????????
dy = [-1, 1, 0, 0]
dx = [0, 0, -1, 1]
# ??°???????????????(?§????????????£????????????????????????????????§??????????????¨)
Y = len(field)
X = len(field[0])
# d = [[float('inf')] * X for _ in range(Y)] # ??????????????°?????????????????¢???INF??§?????????
yorimichi = K
purchased = set()
visited = defaultdict(int)
max_gift = 0
goal = False
Q = deque()
Q.append((0, 0, copy(purchased), copy(visited), yorimichi, goal))
while Q:
cx, cy, purchased, visited, yorimichi, goal= Q.popleft() # ?????¨??°?????§?¨?
key = '-'.join(map(str, (cx, cy)))
visited[key] += 1
if goal == True:
gift = 0
for gx, gy in purchased:
gift += int(field[gy][gx])
if gift > max_gift:
max_gift = gift
if not '0' <= field[cy][cx] <= '9':
field[cy][cx] = '@'
for i in range(4):
nx = cx + dx[i]
ny = cy + dy[i]
if nx == X-1 and ny == Y-1:
goal = True
# ?§?????????? ??°????????????????????????????????? and ?£?????????£???????????? and ??¢?????¢?´¢?????§?????? ??´???
if (not 0 <= nx < X) or (not 0 <= ny < Y) or field[ny][nx] == '#':
continue
key = '-'.join(map(str, (cx, cy)))
if visited[key] > 2:
continue
if dy[i] == -1 or dx[i] == -1:
if yorimichi > 0:
temp = copy(purchased)
if '0' <= field[ny][nx] <= '9':
temp.add((nx, ny))
Q.append((nx, ny, copy(temp), copy(visited), yorimichi-1, goal))
else:
temp = copy(purchased)
if '0' <= field[ny][nx] <= '9':
temp.add((nx, ny))
Q.append((nx, ny, copy(temp), copy(visited), yorimichi, goal))
return max_gift
def main(args):
# data = []
# data.append('...#')
# data.append('.#.#')
# data.append('.#73')
# data.append('8##.')
# data.append('....')
# K = 2
# field = [list(x) for x in data] # data????????????????????????????????????????????????
# result = solve(field, K)
# print(result)
# data = []
# data.append('.##9###.')
# data.append('.#6.9..3')
# data.append('.#378.#2')
# data.append('....#9..')
# data.append('##4..6.#')
# data.append('4...5###')
# data.append('4##.#..1')
# data.append('5..2..#.')
K = 3
# field = [list(x) for x in data] # data????????????????????????????????????????????????
# result = solve(field, K)
# print(result)
H, W, K = map(int, input().split())
data = [input().strip('\n') for _ in range(H)]
field = [list(x) for x in data] # data????????????????????????????????????????????????
result = solve(field, K)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 42,012 | 1 | 84,024 |
No | output | 1 | 42,012 | 1 | 84,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
JOI, who came to Australia for a trip, enjoyed sightseeing in various places and finally returned to Japan. Now, JOI is in the town with the international airport where the return flight departs. The town is divided into north, south, east and west, and each section has roads, souvenir shops, houses, and an international airport. JOI starts from the northwestern section and heads for the international airport in the southeastern section.
JOI can move from the current parcel to an adjacent parcel, but cannot enter a parcel with a house. Also, move only to the east or south section of the current section in order to make it in time for the flight. However, there is some time to spare, so you can move to the north or west section of the section you are up to K times.
When JOI enters the area where the souvenir shop is located, he buys souvenirs for his Japanese friends. JOI did a lot of research on the souvenir shops, so he knows which souvenir shop to buy and how many souvenirs to buy. Create a program to find the maximum number of souvenirs you can buy.
However, the time to buy souvenirs can be ignored, and if you visit the same souvenir shop more than once, you will only buy souvenirs the first time you visit.
Example
Input
5 4 2
...#
.#.#
.#73
8##.
....
Output
11
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0581
"""
import sys
from sys import stdin
from collections import deque
from copy import copy
input = stdin.readline
def solve(field, K):
# ????????????????§????????????´????????§?¨?????????????
dy = [-1, 1, 0, 0]
dx = [0, 0, -1, 1]
# ??°???????????????(?§????????????£????????????????????????????????§??????????????¨)
Y = len(field)
X = len(field[0])
# d = [[float('inf')] * X for _ in range(Y)] # ??????????????°?????????????????¢???INF??§?????????
yorimichi = K
purchased = set()
max_gift = 0
Q = deque()
Q.append((0, 0, copy(purchased), yorimichi))
while Q:
cx, cy, purchased, yorimichi= Q.popleft() # ?????¨??°?????§?¨?
if not '0' <= field[cy][cx] <= '9':
field[cy][cx] = '@'
if cx == X-1 and cy == Y-1:
gift = 0
for gx, gy in purchased:
gift += int(field[gy][gx])
if gift > max_gift:
max_gift = gift
for i in range(4):
nx = cx + dx[i]
ny = cy + dy[i]
# ?§?????????? ??°????????????????????????????????? and ?£?????????£???????????? and ??¢?????¢?´¢?????§?????? ??´???
if (not 0 <= nx < X) or (not 0 <= ny < Y) or field[ny][nx] == '#':
continue
if dy[i] == -1 or dx[i] == -1:
if yorimichi > 0:
temp = copy(purchased)
if '0' <= field[ny][nx] <= '9':
temp.add((nx, ny))
Q.append((nx, ny, copy(temp), yorimichi-1))
else:
temp = copy(purchased)
if '0' <= field[ny][nx] <= '9':
temp.add((nx, ny))
Q.append((nx, ny, copy(temp), yorimichi))
return max_gift
def main(args):
# data = []
# data.append('...#')
# data.append('.#.#')
# data.append('.#73')
# data.append('8##.')
# data.append('....')
# K = 2
# field = [list(x) for x in data] # data????????????????????????????????????????????????
# result = solve(field, K)
# print(result)
#
# data = []
# data.append('.##9###.')
# data.append('.#6.9..3')
# data.append('.#378.#2')
# data.append('....#9..')
# data.append('##4..6.#')
# data.append('4...5###')
# data.append('4##.#..1')
# data.append('5..2..#.')
# K = 3
# field = [list(x) for x in data] # data????????????????????????????????????????????????
# result = solve(field, K)
# print(result)
H, W, K = map(int, input().split())
data = [input().strip('\n') for _ in range(H)]
field = [list(x) for x in data] # data????????????????????????????????????????????????
result = solve(field, K)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 42,013 | 1 | 84,026 |
No | output | 1 | 42,013 | 1 | 84,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
JOI, who came to Australia for a trip, enjoyed sightseeing in various places and finally returned to Japan. Now, JOI is in the town with the international airport where the return flight departs. The town is divided into north, south, east and west, and each section has roads, souvenir shops, houses, and an international airport. JOI starts from the northwestern section and heads for the international airport in the southeastern section.
JOI can move from the current parcel to an adjacent parcel, but cannot enter a parcel with a house. Also, move only to the east or south section of the current section in order to make it in time for the flight. However, there is some time to spare, so you can move to the north or west section of the section you are up to K times.
When JOI enters the area where the souvenir shop is located, he buys souvenirs for his Japanese friends. JOI did a lot of research on the souvenir shops, so he knows which souvenir shop to buy and how many souvenirs to buy. Create a program to find the maximum number of souvenirs you can buy.
However, the time to buy souvenirs can be ignored, and if you visit the same souvenir shop more than once, you will only buy souvenirs the first time you visit.
Example
Input
5 4 2
...#
.#.#
.#73
8##.
....
Output
11
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0581
"""
import sys
from sys import stdin
from collections import deque
from copy import copy
from collections import defaultdict
input = stdin.readline
def solve(field, K):
# ????????????????§????????????´????????§?¨?????????????
dy = [-1, 1, 0, 0]
dx = [0, 0, -1, 1]
# ??°???????????????(?§????????????£????????????????????????????????§??????????????¨)
Y = len(field)
X = len(field[0])
# d = [[float('inf')] * X for _ in range(Y)] # ??????????????°?????????????????¢???INF??§?????????
yorimichi = K
purchased = set()
visited = defaultdict(int)
max_gift = 0
goal = False
Q = deque()
Q.append((0, 0, copy(purchased), copy(visited), yorimichi, goal))
while Q:
cx, cy, purchased, visited, yorimichi, goal= Q.popleft() # ?????¨??°?????§?¨?
key = '-'.join(map(str, (cx, cy)))
visited[key] += 1
if goal == True:
gift = 0
for gx, gy in purchased:
gift += int(field[gy][gx])
if gift > max_gift:
max_gift = gift
if not '0' <= field[cy][cx] <= '9':
field[cy][cx] = '@'
for i in range(4):
nx = cx + dx[i]
ny = cy + dy[i]
if nx == X-1 and ny == Y-1:
goal = True
# ?§?????????? ??°????????????????????????????????? and ?£?????????£???????????? and ??¢?????¢?´¢?????§?????? ??´???
if (not 0 <= nx < X) or (not 0 <= ny < Y) or field[ny][nx] == '#':
continue
key = '-'.join(map(str, (cx, cy)))
if visited[key] > 2:
continue
if dy[i] == -1 or dx[i] == -1:
if yorimichi > 0:
temp = copy(purchased)
if '0' <= field[ny][nx] <= '9':
temp.add((nx, ny))
Q.append((nx, ny, copy(temp), copy(visited), yorimichi-1, goal))
else:
temp = copy(purchased)
if '0' <= field[ny][nx] <= '9':
temp.add((nx, ny))
Q.append((nx, ny, copy(temp), copy(visited), yorimichi, goal))
return max_gift
def main(args):
# data = []
# data.append('...#')
# data.append('.#.#')
# data.append('.#73')
# data.append('8##.')
# data.append('....')
# K = 2
# field = [list(x) for x in data] # data????????????????????????????????????????????????
# result = solve(field, K)
# print(result)
# data = []
# data.append('.##9###.')
# data.append('.#6.9..3')
# data.append('.#378.#2')
# data.append('....#9..')
# data.append('##4..6.#')
# data.append('4...5###')
# data.append('4##.#..1')
# data.append('5..2..#.')
K = 3
# field = [list(x) for x in data] # data????????????????????????????????????????????????
# result = solve(field, K)
# print(result)
# H, W, K = map(int, input().split())
# data = [input().strip('\n') for _ in range(H)]
# field = [list(x) for x in data] # data????????????????????????????????????????????????
# result = solve(field, K)
# print(result)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 42,014 | 1 | 84,028 |
No | output | 1 | 42,014 | 1 | 84,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
At one point, there was a president who traveled around Japan to do business. One day he got a mysterious ticket. If you use the ticket, the train fare will be free regardless of the distance to the destination. However, when moving from the current station to the adjacent station is counted as one step, if the number of steps to move is not exactly equal to the number written on the ticket, an additional fee will be charged. It is forbidden to move around a section immediately, but it is permissible to go through a station or section that you have already visited multiple times. For example, you cannot move to station 1, station 2, or station 1, but there is no problem with moving to station 1, station 2, station 3, station 1, or station 2. Also, if you finally arrive at your destination, you may go through the starting point and destination as many times as you like.
The president immediately decided to use this ticket to go to his next destination. However, since the route map is complicated, the route cannot be easily determined. Your job is to write a program on behalf of the president to determine if you can reach your destination for free.
Stations are numbered from 1 to N, with the departure station being 1 and the destination station being N. The route map is given by the row of sections connecting the two stations. The section can pass in either direction. It is guaranteed that there is no section connecting the same stations and that there is at most one section connecting a pair of stations.
Input
The input consists of multiple datasets.
Each dataset is given in the following format.
N M Z
s1 d1
s2 d2
...
sM dM
N is the total number of stations, M is the total number of sections, and Z is the number of steps written on the ticket. si and di (1 ≤ i ≤ M) are integers representing station numbers, indicating that there is an interval between station si and station di, respectively.
N, M, Z are positive integers and satisfy the following conditions: 2 ≤ N ≤ 50, 1 ≤ M ≤ 50, 0 <Z <231.
After the last dataset, there is a line that says "` 0 0 0 `".
The number of datasets does not exceed 30.
Output
For each dataset, output a one-line string containing only "` yes` "if the destination can be reached with just the number of steps written on the ticket, or" `no`" if not. ..
Example
Input
2 1 1
1 2
2 1 2
1 2
3 1 2
1 2
8 8 5778
1 2
2 3
2 4
3 5
5 6
6 7
7 8
4 8
8 8 5777
1 2
2 3
2 4
3 5
5 6
6 7
7 8
4 8
0 0 0
Output
yes
no
no
yes
no
Submitted Solution:
```
def dfs(s, t, z, links):
stack = [(1, node, s) for node in links[s]]
while stack:
hop, node, ancestor = stack.pop()
if hop > z:
continue
if node == t and hop == z:
return True
stack.extend((hop + 1, node2, node) for node2 in links[node] if node2 != ancestor)
return False
while True:
n, m, z = map(int, input().split())
if not n:
break
links = [set() for _ in range(n)]
for _ in range(m):
s, d = map(int, input().split())
links[s - 1].add(d - 1)
links[d - 1].add(s - 1)
print('yes' if dfs(0, n - 1, z, links) else 'no')
``` | instruction | 0 | 42,034 | 1 | 84,068 |
No | output | 1 | 42,034 | 1 | 84,069 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
There are $ N $ streetlights on a two-dimensional square of $ W \ times H $.
Gaccho wants to start with $ (1,1) $ and go to $ (W, H) $.
Gaccho is afraid of dark places, so he only wants to walk in the squares that are brightened by the streetlights.
Initially, all streetlights only brighten the squares with the streetlights.
So, Gaccho decided to set the cost $ r_i $ for his favorite streetlight $ i $. There may be street lights for which no cost is set.
By consuming the cost $ r_i $, the streetlight $ i $ can brighten the range within $ r_i $ in Manhattan distance around the streetlight. However, the cost is a positive integer.
Gaccho can move to the adjacent square in either the up, down, left, or right direction.
Gaccho decided to set the total value of $ r_i $ to be the minimum. Find the total value at that time.
The Manhattan distance between two points $ (a, b) $ and $ (c, d) $ is represented by $ | a−c | $ + $ | b−d | $.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq W \ leq 500 $
* $ 1 \ leq H \ leq 500 $
* $ 1 \ leq N \ leq 100 $
* $ 1 \ leq N \ leq W \ times H $
* $ 1 \ leq $$ x_i $$ \ leq W $
* $ 1 \ leq $$ y_i $$ \ leq H $
* There are no multiple streetlights at the same coordinates
Input
The input is given in the following format.
$ W $ $ H $ $ N $
$ x_1 $ $ y_1 $
...
$ x_N $ $ y_N $
All inputs are given as integers.
$ W $, $ H $, and $ N $ are given on the first line, separated by blanks.
In the following $ N $ line, the coordinates $ ($$ x_i $, $ y_i $$) $ of the streetlight $ i $ are given, separated by blanks.
Output
Output the minimum value of the total value of $ r_i $ on one line.
Examples
Input
10 10 1
6 6
Output
10
Input
5 10 3
3 9
2 8
5 1
Output
8
Input
1 1 1
1 1
Output
0 | instruction | 0 | 42,073 | 1 | 84,146 |
"Correct Solution:
```
import heapq
class point:
def __init__(self, total, use, place):
self.total = total
self.use = use
self.place = place
def __lt__(self, other):
return self.total < other.total or (self.total == other.total and self.use > self.use)
w, h, n = map(int, input().split())
if w == h == 1:
print(0)
exit()
lights = [list(map(int, input().split())) for _ in range(n)]
que = []
mins = []
for i, j in enumerate(lights):
dis = j[0] + j[1] - 2
heapq.heappush(que, point(dis, dis, i))
mins.append(point(dis, dis, i))
ans = 100000
while que:
top = heapq.heappop(que)
ans = min(ans, top.total + max(0, abs(w - lights[top.place][0]) + abs(h - lights[top.place][1]) - top.use))
for i in range(len(lights)):
dis = abs(lights[top.place][0] - lights[i][0]) + abs(lights[top.place][1] - lights[i][1]) - 1
use = max(0, dis - top.use)
total = top.total + use
new = point(total, use, i)
if mins[i] > new:
mins[i] = new
heapq.heappush(que, new)
print(ans)
``` | output | 1 | 42,073 | 1 | 84,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem
There are $ N $ streetlights on a two-dimensional square of $ W \ times H $.
Gaccho wants to start with $ (1,1) $ and go to $ (W, H) $.
Gaccho is afraid of dark places, so he only wants to walk in the squares that are brightened by the streetlights.
Initially, all streetlights only brighten the squares with the streetlights.
So, Gaccho decided to set the cost $ r_i $ for his favorite streetlight $ i $. There may be street lights for which no cost is set.
By consuming the cost $ r_i $, the streetlight $ i $ can brighten the range within $ r_i $ in Manhattan distance around the streetlight. However, the cost is a positive integer.
Gaccho can move to the adjacent square in either the up, down, left, or right direction.
Gaccho decided to set the total value of $ r_i $ to be the minimum. Find the total value at that time.
The Manhattan distance between two points $ (a, b) $ and $ (c, d) $ is represented by $ | a−c | $ + $ | b−d | $.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq W \ leq 500 $
* $ 1 \ leq H \ leq 500 $
* $ 1 \ leq N \ leq 100 $
* $ 1 \ leq N \ leq W \ times H $
* $ 1 \ leq $$ x_i $$ \ leq W $
* $ 1 \ leq $$ y_i $$ \ leq H $
* There are no multiple streetlights at the same coordinates
Input
The input is given in the following format.
$ W $ $ H $ $ N $
$ x_1 $ $ y_1 $
...
$ x_N $ $ y_N $
All inputs are given as integers.
$ W $, $ H $, and $ N $ are given on the first line, separated by blanks.
In the following $ N $ line, the coordinates $ ($$ x_i $, $ y_i $$) $ of the streetlight $ i $ are given, separated by blanks.
Output
Output the minimum value of the total value of $ r_i $ on one line.
Examples
Input
10 10 1
6 6
Output
10
Input
5 10 3
3 9
2 8
5 1
Output
8
Input
1 1 1
1 1
Output
0
Submitted Solution:
```
import bisect
from collections import deque
W,H,N = map(int,input().split())
src = [tuple(map(lambda x:int(x)-1,input().split())) for i in range(N)]
exist = [[0 for j in range(W)] for i in range(H)]
pos = set()
for x,y in src:
exist[y][x] = 1
pos.add(y+x)
def bfs(sx,sy,gx,gy):
visited = [[0 for j in range(W)] for i in range(H)]
q = deque([(0,sx,sy)])
dxs = [1,0,-1,0]
dys = [0,1,0,-1]
ret = 0
while q:
d,x,y = q.popleft()
ret = max(ret, d)
if (x,y) == (gx,gy):
break
for dx,dy in zip(dxs,dys):
nx,ny = x+dx, y+dy
if not(0 <= nx < W) or not(0 <= ny < H): continue
if not exist[ny][nx] or visited[ny][nx]: continue
q.append((d+1,nx,ny))
visited[ny][nx] = 1
return ret
a = bfs(0,0,W-1,H-1)
b = H+W-2 - bfs(W-1,H-1,0,0)
if a >= b:
print(0)
exit()
if (b-a)%2 == 0:
m = (a+b)//2
if m in pos:
print(m-a)
exit()
m1 = m-1
m2 = m+1
else:
m1 = (a+b)//2
m2 = m1+1
ans = m2
while m1 >= a or m2 <= b:
if m1 in pos or m2 in pos:
break
m1 -= 1
m2 += 1
ans += 1
print(ans)
``` | instruction | 0 | 42,074 | 1 | 84,148 |
No | output | 1 | 42,074 | 1 | 84,149 |
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 | 42,357 | 1 | 84,714 |
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 | 42,357 | 1 | 84,715 |
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 | 42,358 | 1 | 84,716 |
Tags: implementation
Correct Solution:
```
n,a,d=map(int,input().split())
p=[0]*n
for i in range(n):
t,v=map(int,input().split())
x=v/a
y=(2*d/a) ** 0.5
p[i]=t+y if y<x else t+d/v+x/2
p[i]=max(p[i-1],p[i])
print('\n'.join(map(str,p)))
``` | output | 1 | 42,358 | 1 | 84,717 |
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 | 42,359 | 1 | 84,718 |
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 | 42,359 | 1 | 84,719 |
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 | 42,360 | 1 | 84,720 |
Tags: implementation
Correct Solution:
```
import collections
import functools
import math
import sys
def In():
return map(int, sys.stdin.readline().split())
input = sys.stdin.readline
import functools
import math
import sys
def In():
return map(int, sys.stdin.readline().split())
input = sys.stdin.readline
def wiztroll():
n, maxac, dest = In()
blockingtime = 0
for _ in range(n):
start, pera = In()
ans = 0
if dest > pera ** 2 / (2 * maxac):
ans += max(blockingtime, start + pera / maxac + ((dest - pera * pera / (2 * maxac))/pera))
blockingtime = ans
print(ans)
else:
ans += max(blockingtime, start + math.sqrt(2 * dest / maxac))
blockingtime = ans
print(ans)
wiztroll()
``` | output | 1 | 42,360 | 1 | 84,721 |
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 | 42,361 | 1 | 84,722 |
Tags: implementation
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
n, a, d = map(int, input().split())
p = [0] * n
for i in range(n):
t, v = map(int, input().split())
x = v / a
y = (2 * d / a) ** 0.5
p[i] = t + y if y < x else t + d / v + x / 2
p[i] = max(p[i - 1], p[i])
print('\n'.join(map(str, p)))
``` | output | 1 | 42,361 | 1 | 84,723 |
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 | 42,362 | 1 | 84,724 |
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 | 42,362 | 1 | 84,725 |
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 | 42,363 | 1 | 84,726 |
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 | 42,363 | 1 | 84,727 |
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 | 42,364 | 1 | 84,728 |
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 | 42,364 | 1 | 84,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted 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)
``` | instruction | 0 | 42,365 | 1 | 84,730 |
Yes | output | 1 | 42,365 | 1 | 84,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
n, a, d = map(int, input().split())
r = []
for i in range(0, n):
t, v = map(int, input().split())
v = min(v, a)
current = d / v + t
if i == 0:
r.append(current)
else:
last = r[i - 1]
if current < last:
r.append(last)
else:
r.append(current)
for x in r:
print(x)
``` | instruction | 0 | 42,366 | 1 | 84,732 |
No | output | 1 | 42,366 | 1 | 84,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
import collections
import functools
import math
import sys
def In():
return map(int, sys.stdin.readline().split())
input = sys.stdin.readline
import functools
import math
import sys
def In():
return map(int, sys.stdin.readline().split())
input = sys.stdin.readline
def wiztroll():
def calcnewd(old, plus):
return (old * 2 + plus) / 2
def calctime(d, old, new):
return d * 2 / (old*2 + new)
n, maxac, dest = In()
blockingtime = 0
for _ in range(n):
start, pera = In()
preacd = 0
nowspeeed = 0
time = start
while True:
if preacd + calcnewd(nowspeeed, min(maxac, pera - nowspeeed)) > dest:
left = dest - preacd
ans = time + calctime(left, nowspeeed, min(maxac, pera - nowspeeed))
blockingtime = max(ans, blockingtime)
print(ans)
break
if nowspeeed + maxac > pera:
preacd += calcnewd(nowspeeed, pera - nowspeeed)
left = dest - preacd
ans = max(left / pera + time+1, blockingtime)
blockingtime = max(ans, blockingtime)
print(ans)
break
preacd += calcnewd(nowspeeed, maxac)
nowspeeed += maxac
time += 1
wiztroll()
``` | instruction | 0 | 42,367 | 1 | 84,734 |
No | output | 1 | 42,367 | 1 | 84,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
n, a, d = map(int, input().split())
r = []
for i in range(0, n):
t, v = map(int, input().split())
current = d / v + t
if i == 0:
r.append(current)
else:
last = r[i - 1]
if current < last:
r.append(last)
for x in r:
print(x)
``` | instruction | 0 | 42,368 | 1 | 84,736 |
No | output | 1 | 42,368 | 1 | 84,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
input();a=sorted(map(int,input().split()));s=c=0
while s<=sum(a):s+=a.pop();c+=1
print(c)
``` | instruction | 0 | 42,369 | 1 | 84,738 |
No | output | 1 | 42,369 | 1 | 84,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city ui to vi (and vise versa) using the i-th road, the length of this road is xi. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city si (and vise versa), the length of this route is yi.
Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.
Input
The first line contains three integers n, m, k (2 ≤ n ≤ 105; 1 ≤ m ≤ 3·105; 1 ≤ k ≤ 105).
Each of the next m lines contains three integers ui, vi, xi (1 ≤ ui, vi ≤ n; ui ≠ vi; 1 ≤ xi ≤ 109).
Each of the next k lines contains two integers si and yi (2 ≤ si ≤ n; 1 ≤ yi ≤ 109).
It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.
Output
Output a single integer representing the maximum number of the train routes which can be closed.
Examples
Input
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
Output
2
Input
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
Output
2 | instruction | 0 | 42,446 | 1 | 84,892 |
Tags: graphs, greedy, shortest paths
Correct Solution:
```
import os, sys
from io import IOBase, BytesIO
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill():
pass
return super(FastIO, self).read()
def readline(self):
while self.newlines == 0:
s = self._fill()
self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# Cout implemented in Python
import sys
class ostream:
def __lshift__(self, a):
sys.stdout.write(str(a))
return self
cout = ostream()
endl = "\n"
import heapq
def solve():
"""
1. First we calculate shortest path using dijkstra. We
1.1) While comparison of distances, in case of equal shortest paths, -> Maybe we can keep (dist, num_trains_encountered, next_node) in heapq.
choose the one with more train network.
2. All train paths not on shortest path can be eliminated.
"""
n, m, k = map(int, input().split())
adj_list = {x: [] for x in range(n + 1)}
dist = [float("inf")] * (n + 1)
dist[1] = 0
hq = [(0, 1)]
for _ in range(m):
u, v, x = map(int, input().split())
adj_list[u].append((v, x, False))
adj_list[v].append((u, x, False))
for _ in range(k):
v, y = map(int, input().split())
adj_list[1].append((v, y, True))
adj_list[v].append((1, y, True))
visited = [False] * (n + 1)
prev = {}
train_used = [0] * (n + 1)
# Dist, Train found, Next Node.
while hq:
d, node = heapq.heappop(hq)
if visited[node]:
continue
visited[node] = True
for edge in adj_list[node]:
nxt, w, isTrain = edge
if not visited[nxt]:
if d + w < dist[nxt]:
dist[nxt] = d + w
if isTrain:
train_used[nxt] = 1
if d + w == dist[nxt] and train_used[nxt] == 1 and not isTrain:
train_used[nxt] = 0
heapq.heappush(hq, (d + w, nxt))
cout<<k - sum(train_used)<<"\n"
def main():
solve()
if __name__ == "__main__":
main()
``` | output | 1 | 42,446 | 1 | 84,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city ui to vi (and vise versa) using the i-th road, the length of this road is xi. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city si (and vise versa), the length of this route is yi.
Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.
Input
The first line contains three integers n, m, k (2 ≤ n ≤ 105; 1 ≤ m ≤ 3·105; 1 ≤ k ≤ 105).
Each of the next m lines contains three integers ui, vi, xi (1 ≤ ui, vi ≤ n; ui ≠ vi; 1 ≤ xi ≤ 109).
Each of the next k lines contains two integers si and yi (2 ≤ si ≤ n; 1 ≤ yi ≤ 109).
It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.
Output
Output a single integer representing the maximum number of the train routes which can be closed.
Examples
Input
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
Output
2
Input
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
Output
2 | instruction | 0 | 42,447 | 1 | 84,894 |
Tags: graphs, greedy, shortest paths
Correct Solution:
```
import sys
input = sys.stdin.readline
import heapq
n, m, k = map(int, input().split())
adj = [[] for _ in range(n+5)]
for _ in range(m):
u, v, w = map(int, input().split())
adj[u].append((v,w))
adj[v].append((u,w))
train = [-1 for _ in range(n+5)]
ans = 0
dist = [int(1e15) for _ in range(n+5)]
pq = []
for _ in range(k):
s, y = map(int, input().split())
if(train[s] != -1):
ans+=1
train[s] = min(train[s], y)
dist[s] = train[s]
continue
train[s] = y
dist[s] = y
for i in range(n+5):
if(dist[i] != -1):
heapq.heappush(pq, (dist[i],i))
heapq.heappush(pq, ((0,1)))
dist[1] = 0
cut = [0 for _ in range(n+5)]
vis = [0 for _ in range(n+5)]
while pq:
dummy, u = heapq.heappop(pq)
if(vis[u]):
continue
vis[u] = 1
for v, w in adj[u]:
if(dist[v] >= dist[u]+w):
if(dist[v] != dist[u]+w):
heapq.heappush(pq, ((dist[u]+w, v)))
dist[v] = dist[u]+w
if(train[v] != -1):
cut[v] = 1
for b in cut:
if(b==1):
ans+=1
print(ans)
``` | output | 1 | 42,447 | 1 | 84,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city ui to vi (and vise versa) using the i-th road, the length of this road is xi. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city si (and vise versa), the length of this route is yi.
Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.
Input
The first line contains three integers n, m, k (2 ≤ n ≤ 105; 1 ≤ m ≤ 3·105; 1 ≤ k ≤ 105).
Each of the next m lines contains three integers ui, vi, xi (1 ≤ ui, vi ≤ n; ui ≠ vi; 1 ≤ xi ≤ 109).
Each of the next k lines contains two integers si and yi (2 ≤ si ≤ n; 1 ≤ yi ≤ 109).
It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.
Output
Output a single integer representing the maximum number of the train routes which can be closed.
Examples
Input
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
Output
2
Input
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
Output
2 | instruction | 0 | 42,448 | 1 | 84,896 |
Tags: graphs, greedy, shortest paths
Correct Solution:
```
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for pp in range(t):
solve(pp)
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
def djkistra(g,st,dist,lol,vis): #g contains b,dist(a to b) and dist is initiaalised by 10**9 initiallly
pq = []
dist[st] = 0
heappush(pq,(0,st))
while(len(pq) != 0):
curr = heappop(pq)[1]
for i in range(0,len(g[curr])):
b = g[curr][i][0]
w = g[curr][i][1]
if(dist[b] > dist[curr] + w):
dist[b] = dist[curr]+w
heappush(pq,(dist[b],b))
def modif_djkistra(g,dist,usedtrains):
h = []
for i in range(len(g)):
if(dist[i] != inf):
heappush(h,(dist[i],i))
while(len(h) != 0):
d,curr = heappop(h)
if(d != dist[curr]): #dublicate train with larger length
continue
for to,newd in g[curr]:
if(newd+d<=dist[to]):
usedtrains[to] = False
if(dist[to] > newd+d):
heappush(h,(newd+d,to))
dist[to] = newd+d
def solve(case):
n,m,k = sep()
dist = [inf]*n;dist[0] = 0
g = [[] for i in range(n)]
for i in range(m):
a,b,c = sep()
a-=1
b-=1
g[a].append((b,c))
g[b].append((a,c))
have = []
usedtrain = [False]*n
for i in range(k):
a,b = sep()
a-=1
dist[a] = min(dist[a],b)
# g[0].append((a,b))
# g[a].append((0,b))
have.append(a)
usedtrain[a] = True
modif_djkistra(g,dist,usedtrain)
cnt = 0
have = list(set(have))
for i in range(n):
if(usedtrain[i]):
cnt+=1
# print(cnt)
print(k - cnt)
testcase(1)
# testcase(int(inp()))
``` | output | 1 | 42,448 | 1 | 84,897 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city ui to vi (and vise versa) using the i-th road, the length of this road is xi. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city si (and vise versa), the length of this route is yi.
Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.
Input
The first line contains three integers n, m, k (2 ≤ n ≤ 105; 1 ≤ m ≤ 3·105; 1 ≤ k ≤ 105).
Each of the next m lines contains three integers ui, vi, xi (1 ≤ ui, vi ≤ n; ui ≠ vi; 1 ≤ xi ≤ 109).
Each of the next k lines contains two integers si and yi (2 ≤ si ≤ n; 1 ≤ yi ≤ 109).
It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.
Output
Output a single integer representing the maximum number of the train routes which can be closed.
Examples
Input
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
Output
2
Input
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
Output
2
Submitted Solution:
```
from collections import defaultdict
import sys
import heapq
class Graph:
def __init__(self):
self.graph = defaultdict(list)
def add_edge(self, u, v, w):
self.graph[u].append((v, w))
self.graph[v].append((u, w))
def dijkstras(self, src, n):
dist = [sys.maxsize] * n
visited = [False] * n
dist[src] = 0
PQ = [(0, src)]
heapq.heapify(PQ)
while PQ:
node = heapq.heappop(PQ)[1]
if not visited[node]:
visited[node] = True
for v, w in self.graph[node]:
if not visited[v]:
if dist[v] > dist[node] + w:
dist[v] = dist[node] + w
heapq.heappush(PQ, (dist[v], v))
return dist
def main():
n, m, k = map(int, input().split())
graph = Graph()
presentdist = []
for _ in range(m):
u, v, x = map(int, input().split())
graph.add_edge(u - 1, v - 1, x)
for _ in range(k):
s, y = map(int, input().split())
presentdist.append((s - 1, y))
closeTrain = 0
capital = 0
leastdist = graph.dijkstras(capital, n)
print(leastdist, presentdist)
for city, dist in presentdist:
if dist != leastdist[city]:
closeTrain += 1
print(closeTrain)
main()
``` | instruction | 0 | 42,449 | 1 | 84,898 |
No | output | 1 | 42,449 | 1 | 84,899 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city ui to vi (and vise versa) using the i-th road, the length of this road is xi. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city si (and vise versa), the length of this route is yi.
Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.
Input
The first line contains three integers n, m, k (2 ≤ n ≤ 105; 1 ≤ m ≤ 3·105; 1 ≤ k ≤ 105).
Each of the next m lines contains three integers ui, vi, xi (1 ≤ ui, vi ≤ n; ui ≠ vi; 1 ≤ xi ≤ 109).
Each of the next k lines contains two integers si and yi (2 ≤ si ≤ n; 1 ≤ yi ≤ 109).
It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.
Output
Output a single integer representing the maximum number of the train routes which can be closed.
Examples
Input
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
Output
2
Input
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
Output
2
Submitted Solution:
```
import sys
from heapq import heappush, heappop
input=sys.stdin.readline
def main():
n,m,k = map(int,input().split())
g=[[] for _ in range(1+n)]
for _ in range(m):
u,v,x = map(int,input().split())
g[u].append((x,v,-1))
g[v].append((x,u,-1))
for _ in range(k):
s,y=map(int,input().split())
g[1].append((y,s,s))
def dijkstra():
inf=float('inf')
dis=[inf]*(n+1)
t=[-1]*(n+1)
vis=[False]*(n+1)
dis[1]=0
pq=[]
heappush(pq,(0,1,-1))
while pq:
d,v,b = heappop(pq)
if vis[v]:
continue
vis[v]=True
for x,u,bb in g[v]:
if x+d < dis[u]:
dis[u]=d + x
t[u]=max(t[v],bb)
heappush(pq,(dis[u],u,t[u]))
elif x+d==dis[u] :
if max(t[v],bb)==-1 : t[u]=-1
t=set(t)
return len(t)-1 if -1 in t else len(t)
print(k-dijkstra())
main()
``` | instruction | 0 | 42,450 | 1 | 84,900 |
No | output | 1 | 42,450 | 1 | 84,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city ui to vi (and vise versa) using the i-th road, the length of this road is xi. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city si (and vise versa), the length of this route is yi.
Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.
Input
The first line contains three integers n, m, k (2 ≤ n ≤ 105; 1 ≤ m ≤ 3·105; 1 ≤ k ≤ 105).
Each of the next m lines contains three integers ui, vi, xi (1 ≤ ui, vi ≤ n; ui ≠ vi; 1 ≤ xi ≤ 109).
Each of the next k lines contains two integers si and yi (2 ≤ si ≤ n; 1 ≤ yi ≤ 109).
It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.
Output
Output a single integer representing the maximum number of the train routes which can be closed.
Examples
Input
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
Output
2
Input
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
Output
2
Submitted Solution:
```
import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
#sys.setrecursionlimit(200000000)
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda: map(int,input().split())
alele = lambda: list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
G = defaultdict(list)
inf = 1e10
def addEdge(a,b,w):
G[a].append([b,w])
#G[b].append([a,w])
def difun(N,source):
dist = [inf] *(N+1)
pq = [[0,source]]
heapq.heapify(pq)
dist[source] = 0
while pq:
curr_d,curr = heapq.heappop(pq)
for i,j in G[curr]:
if curr_d + j < dist[i]:
dist[i] = curr_d + j
heapq.heappush(pq,[dist[i],i])
return dist
N,M,k = ilele()
for i in range(M):
a,b,c = ilele()
addEdge(a,b,c)
d = difun(N,1)
count = 0
for i in range(k):
a,b = ilele()
if d[a] <= b:
count += 1
print(count)
``` | instruction | 0 | 42,451 | 1 | 84,902 |
No | output | 1 | 42,451 | 1 | 84,903 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city ui to vi (and vise versa) using the i-th road, the length of this road is xi. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city si (and vise versa), the length of this route is yi.
Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.
Input
The first line contains three integers n, m, k (2 ≤ n ≤ 105; 1 ≤ m ≤ 3·105; 1 ≤ k ≤ 105).
Each of the next m lines contains three integers ui, vi, xi (1 ≤ ui, vi ≤ n; ui ≠ vi; 1 ≤ xi ≤ 109).
Each of the next k lines contains two integers si and yi (2 ≤ si ≤ n; 1 ≤ yi ≤ 109).
It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.
Output
Output a single integer representing the maximum number of the train routes which can be closed.
Examples
Input
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
Output
2
Input
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
Output
2
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
import heapq
input = sys.stdin.readline
# Function to call the actual solution
def solution(adj, n):
t = [0 for i in range(n)]
s1 = set([0]); s2 = set([i for i in range(1,n)])
q = []
for ad in adj[0]:
heapq.heappush(q, [ad[1], ad[2], 0, ad[0]])
c = 0
while s2 and q:
mini = heapq.heappop(q)
while mini[3] in s1 and q:
mini = heapq.heappop(q)
if mini[3] in s1:
break
# print(mini, s1, s2, q)
if mini[1] == 1:
c += 1
s1.add(mini[3])
s2.remove(mini[3])
t[mini[3]] = mini[0]
for ad in adj[mini[3]]:
if ad[2] in s2:
heapq.heappush(q, [mini[0]+ad[1], ad[2], mini[3], ad[0]])
return c
# Function to take input
def input_test():
n, m, k = map(int, input().strip().split(" "))
adj = [[] for i in range(n)]
for i in range(m):
u, v, x = map(int, input().strip().split(" "))
adj[u-1].append([v-1, x, 0])
adj[v-1].append([u-1, x, 0])
for i in range(k):
s, y = map(int, input().strip().split(" "))
adj[0].append([s-1, y, 1])
adj[s-1].append([0, y, 1])
print(k - solution(adj, n))
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
input_test()
``` | instruction | 0 | 42,452 | 1 | 84,904 |
No | output | 1 | 42,452 | 1 | 84,905 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city ui to vi (and vise versa) using the i-th road, the length of this road is xi. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city si (and vise versa), the length of this route is yi.
Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.
Input
The first line contains three integers n, m, k (2 ≤ n ≤ 105; 1 ≤ m ≤ 3·105; 1 ≤ k ≤ 105).
Each of the next m lines contains three integers ui, vi, xi (1 ≤ ui, vi ≤ n; ui ≠ vi; 1 ≤ xi ≤ 109).
Each of the next k lines contains two integers si and yi (2 ≤ si ≤ n; 1 ≤ yi ≤ 109).
It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.
Output
Output a single integer representing the maximum number of the train routes which can be closed.
Examples
Input
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
Output
2
Input
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
Output
2
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
import heapq
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
# main code
n,m,k=in_arr()
d=defaultdict(list)
for i in range(m):
u,v,x=in_arr()
d[u].append((v,x))
d[v].append((u,x))
dis=[n+1]*(n+1)
vis=[0]*(n+1)
q=[(0,1)]
while q:
ds,x=heapq.heappop(q)
if vis[x]:
continue
vis[x]=1
dis[x]=ds
for i,f in d[x]:
if not vis[i]:
heapq.heappush(q,(ds+f,i))
ans=0
for i in range(k):
s,d=in_arr()
if dis[s]<=d:
ans+=1
pr_num(ans)
``` | instruction | 0 | 42,453 | 1 | 84,906 |
No | output | 1 | 42,453 | 1 | 84,907 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3 | instruction | 0 | 42,752 | 1 | 85,504 |
"Correct Solution:
```
import sys, copy
from itertools import permutations
def wf(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,R = map(int,input().split())
Rs = list(map(int,input().split()))
d = [[float('inf') for i in range(N)] for i in range(N)]
for _ in range(M):
a,b,c = map(int,sys.stdin.readline().split())
d[a-1][b-1] = c
d[b-1][a-1] = c
for i in range(N):
d[i][i] = 0
wf(d)
ans = float('inf')
for prm in permutations(Rs, R):
ans = min(ans, sum([d[prm[i-1]-1][prm[i]-1] for i in range(1,R)]))
print(ans)
``` | output | 1 | 42,752 | 1 | 85,505 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3 | instruction | 0 | 42,753 | 1 | 85,506 |
"Correct Solution:
```
from itertools import permutations
n,m,r = map(int,input().split())
rl = list(map(int,input().split()))
d = [[10**8]*n for i in range(n)]
for i 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])
m = 10**9
for i in permutations(rl):
c = 0
for j in range(1,r):
c += d[i[j-1]-1][i[j]-1]
m = min(m,c)
print(m)
``` | output | 1 | 42,753 | 1 | 85,507 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3 | instruction | 0 | 42,754 | 1 | 85,508 |
"Correct Solution:
```
from itertools import permutations
def WarshallFloyd(M):
N = len(M)
for k in range(N):
for j in range(N):
for i in range(N):
M[i][j] = min(M[i][j], M[i][k] + M[k][j])
return M
INF = 1e10
N, M, K = map(int, input().split())
R = [int(i) - 1 for i in input().split()]
E = [[INF] * N for _ in range(N)]
for a, b, c in (map(int, input().split()) for _ in range(M)):
a -= 1; b -= 1
E[a][b] = E[b][a] = c
E = WarshallFloyd(E)
ans = min(sum(E[p[i]][p[i + 1]] for i in range(K - 1)) for p in permutations(R))
print(ans)
``` | output | 1 | 42,754 | 1 | 85,509 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3 | instruction | 0 | 42,755 | 1 | 85,510 |
"Correct Solution:
```
from itertools import*
n,m,R=map(int,input().split())
r=map(int,input().split())
d=[[10**18]*n for _ in range(n)]
for i in range(m):
a,b,c=map(int,input().split())
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])
m=10**18
for e in permutations(r):
t=0
for i,j in zip(e,e[1:]):
t+=d[i-1][j-1]
m=min(m,t)
print(m)
``` | output | 1 | 42,755 | 1 | 85,511 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3 | instruction | 0 | 42,756 | 1 | 85,512 |
"Correct Solution:
```
import itertools
N, M, R = map(int, input().split())
r = [int(x) - 1 for x in input().split()]
dist = [[float('inf')] * N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
dist[a][b] = dist[b][a] = c
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
ans = float('inf')
k = list(itertools.permutations(r))
for i in k:
sumDist = 0
for j in range(len(i) - 1):
sumDist += dist[i[j]][i[j+1]]
ans = min(ans, sumDist)
print(ans)
``` | output | 1 | 42,756 | 1 | 85,513 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3 | instruction | 0 | 42,757 | 1 | 85,514 |
"Correct Solution:
```
import itertools
N,M,R = map(int, input().split())
rlist = [int(r) for r in input().split()]
INF = 10**9
E = [[INF]*N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
E[a-1][b-1] = c
E[b-1][a-1] = c
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])
ans = 10**9
for i in range(R):
rlist[i] -= 1
for p in itertools.permutations(rlist):
d = 0
for i in range(1, R):
d += E[p[i-1]][p[i]]
ans = min(ans, d)
print(ans)
``` | output | 1 | 42,757 | 1 | 85,515 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3 | instruction | 0 | 42,758 | 1 | 85,516 |
"Correct Solution:
```
N,M,R = map(int,input().split())
r = list(map(int,input().split()))
INF = 10**18
d = [[INF for i in range(N)] for j in range(N)]
for i in range(M):
a,b,c = map(int,input().split())
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])
import itertools
ans = INF
for v in itertools.permutations(r,R):
anss = 0
for i in range(R-1):
anss += d[v[i]-1][v[i+1]-1]
ans = min(ans,anss)
print(ans)
``` | output | 1 | 42,758 | 1 | 85,517 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3 | instruction | 0 | 42,759 | 1 | 85,518 |
"Correct Solution:
```
n,m,R = map(int,input().split())
r = list(map(int,input().split()))
INF = 10**10
d = [[INF for i in range(n)] for j in range(n)]
for i in range(m):
a,b,c = map(int,input().split())
d[a-1][b-1] = c
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])
from itertools import permutations
ans = INF
for v in permutations(r,R):
dis = 0
for i in range(R-1):
dis += d[v[i]-1][v[i+1]-1]
ans = min(ans,dis)
print(ans)
``` | output | 1 | 42,759 | 1 | 85,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3
Submitted Solution:
```
def Warshall_Floyd(edges,N):
for k in range(N):
for i in range(N):
for j in range(N):
edges[i][j]=min(edges[i][j],edges[i][k]+edges[k][j])
return edges
import itertools
N, M, R = map(int,input().split())
r = list(map(int,input().split()))
A=[[float("inf") for i in range(N)] for j in range(N)]
for m in range(M):
a, b, c = map(int,input().split())
A[a-1][b-1] = c
A[b-1][a-1] = c
A = Warshall_Floyd(A,N)
ans = float("inf")
for road in list(itertools.permutations(r)):
length = 0
for i in range(R-1):
length += A[road[i]-1][road[i+1]-1]
ans = min(ans, length)
print(ans)
``` | instruction | 0 | 42,760 | 1 | 85,520 |
Yes | output | 1 | 42,760 | 1 | 85,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3
Submitted Solution:
```
# ABC073 D - joisino's travel
import itertools
N,M,R=map(int, input().split())
r=list(map(int, input().split()))
inf=float("inf")
mat=[[inf]*N for _ in range(N)]
for i in range(M):
a,b,c=map(int,input().split())
if mat[a-1][b-1]>c:
mat[a-1][b-1]=mat[b-1][a-1]=c
for i in range(R):
r[i]-=1
ans=inf
for k in range(N):
for i in range(N):
for j in range(N):
mat[i][j]=min(mat[i][j],mat[i][k]+mat[k][j])
for rr in itertools.permutations(r,R):
t_sum=0
for j in range(1,R):
t_sum+=mat[rr[j-1]][rr[j]]
ans=min(ans,t_sum)
print(int(ans))
``` | instruction | 0 | 42,761 | 1 | 85,522 |
Yes | output | 1 | 42,761 | 1 | 85,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3
Submitted Solution:
```
N,M,R = map(int,input().split())
R = list(map(int,input().split()))
ABC = [tuple(map(int,input().split())) for i in range(M)]
INF = float('inf')
d = [[INF]*N for _ in range(N)]
for i in range(N):
d[i][i] = 0
for a,b,c in ABC:
a,b = a-1,b-1
d[a][b] = d[b][a] = 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])
ans = INF
import itertools
for ptn in itertools.permutations(R):
tmp = 0
for a,b in zip(ptn,ptn[1:]):
tmp += d[a-1][b-1]
ans = min(ans, tmp)
print(ans)
``` | instruction | 0 | 42,762 | 1 | 85,524 |
Yes | output | 1 | 42,762 | 1 | 85,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3
Submitted Solution:
```
"""
atcoder workspace
"""
from itertools import permutations
N, M, R = map(int, input().split())
Rlist = list(map(int, input().split()))
Dmat = [[1e9] * N for i in range(N)]
for i in range(N):
Dmat[i][i] = 0
for i in range(M):
f, t, c = map(int, input().split())
Dmat[f-1][t-1] = c
Dmat[t-1][f-1] = c
for i in range(N): #mid
for j in range(N): #from
for k in range(N): #to
Dmat[j][k] = min(Dmat[j][k], Dmat[j][i] + Dmat[i][k])
ans = 1e9
for p in permutations(Rlist):
ans = min(ans, sum([Dmat[p[i]-1][p[i+1]-1] for i in range(R-1)]))
print(ans)
``` | instruction | 0 | 42,763 | 1 | 85,526 |
Yes | output | 1 | 42,763 | 1 | 85,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3
Submitted Solution:
```
from itertools import permutations
def read_line(*types): return [f(a) for a, f in zip(input().split(), types)]
n, m, r = read_line(int, int, int)
rs = [int(r) for r in input().split()]
costs = {}
for i in range(n + 1):
costs[i] = {}
for j in range(n + 1):
costs[i][j] = 100000 + 1
for _ in range(m):
a, b, c = read_line(int, int, int)
costs[a][b] = costs[b][a] = c
for k in range(n + 1):
for i in range(n + 1):
for j in range(n + 1):
c = costs[i][k] + costs[k][j]
if costs[i][j] > c:
costs[i][j] = c
def cost(selected):
c = 0
for i in range(len(selected) - 1):
a = selected[i]
b = selected[i + 1]
c += costs[a][b]
return c
smallest = (100000 + 1) * len(rs)
for p in permutations(rs):
c = cost(p)
if smallest > c:
smallest = c
# def f(selected, rest):
# global smallest
# if len(rest) == 0:
# c = cost(selected)
# if smallest > c:
# smallest = c
# # print(selected, c)
# else:
# for i in range(len(rest)):
# r = rest[i]
# rest_copy = rest[:]
# del rest_copy[i]
# f(selected + [r], rest_copy)
# f([], rs)
print(smallest)
``` | instruction | 0 | 42,764 | 1 | 85,528 |
No | output | 1 | 42,764 | 1 | 85,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3
Submitted Solution:
```
N, M, R = map(int, input().split())
T = list(map(int, input().split()))
D = [[float('INF')] * N for _ in range(N)]
for _ in range(M):
A, B, C = map(int, input().split())
A -= 1
B -= 1
if D[A][B] > C:
D[A][B] = C
D[B][A] = C
def dfs(i, d, v):
v[i] = True
if all(v[t - 1] for t in T) is True:
return d
dd = float('INF')
for j in range(N):
if v[j] is True:
continue
if D[i][j] == 0:
continue
dd = min(dd, dfs(j, d + D[i][j], v[::]))
return dd
def main():
ans = float('INF')
for i in range(N):
v = [False] * N
ans = min(ans, dfs(i, 0, v[::]))
print(ans)
main()
``` | instruction | 0 | 42,765 | 1 | 85,530 |
No | output | 1 | 42,765 | 1 | 85,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3
Submitted Solution:
```
from itertools import permutations
from scipy.sparse.csgraph import floyd_warshall
import numpy as np
N, M, R = map(int, input().split())
r = tuple(map(int, input().split()))
inf = 10**3
graph = np.ones((N, N), dtype=int)*inf
for _ in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
graph[a][b] = c
graph[b][a] = c
fy = floyd_warshall(graph)
ans = 10 ** 9
for p in permutations(r):
tmp = 0
for x, y in zip(p[:-1], p[1:]):
x -= 1
y -= 1
tmp += int(fy[x][y])
ans = min(ans, tmp)
print(ans)
``` | instruction | 0 | 42,766 | 1 | 85,532 |
No | output | 1 | 42,766 | 1 | 85,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in the State of Atcoder, connected by M bidirectional roads.
The i-th road connects Town A_i and B_i and has a length of C_i.
Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).
She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.
If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?
Constraints
* 2≤N≤200
* 1≤M≤N×(N-1)/2
* 2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)
* r_i≠r_j (i≠j)
* 1≤A_i,B_i≤N, A_i≠B_i
* (A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)
* 1≤C_i≤100000
* Every town can be reached from every town by road.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M
Output
Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.
Examples
Input
3 3 3
1 2 3
1 2 1
2 3 1
3 1 4
Output
2
Input
3 3 2
1 3
2 3 2
1 3 6
1 2 2
Output
4
Input
4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6
Output
3
Submitted Solution:
```
def hoge():
from itertools import permutations
N, M, R = map(int, input().split())
r = map(int, input().split())
inf = float('inf')
d = [[inf] * N for i in range(N)]
for i in range(N):
d[i][i] = 0
for i in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
t = min(c, d[a][b])
if d[a][b] > c:
d[a][b], d[b][a] = t, t
for i in range(N):
for j in range(N):
for k in range(N):
t = d[i][k] + d[k][j]
if d[i][j] > t:
d[i][j] = t
ans = inf
for i in permutations(r):
temp = 0
for j in range(len(i)-1):
temp += d[i[j]-1][i[j+1]-1]
if temp > ans:
break
if ans > temp:
ans = temp
# ans = min(ans, temp)
print(ans)
hoge()
``` | instruction | 0 | 42,767 | 1 | 85,534 |
No | output | 1 | 42,767 | 1 | 85,535 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.