message stringlengths 2 22.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 16 109k | cluster float64 1 1 | __index_level_0__ int64 32 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen. | instruction | 0 | 4,272 | 1 | 8,544 |
Tags: dsu, graphs, greedy, shortest paths, trees
Correct Solution:
```
def prim(matrix, inf=10**18):
n = len(matrix)
costs = [inf] + [inf-1]*(n-1)
nearest = [-1]*n
current = 0
total_cost = 0
build, connect = [], []
for _ in range(n-1):
min_cost = inf
src, dest = -1, -1
for i in range(n):
if costs[i] == inf:
continue
if matrix[current][i] < costs[i]:
costs[i] = matrix[current][i]
nearest[i] = current
if min_cost > costs[i]:
min_cost = costs[i]
src, dest = nearest[i], i
total_cost += min_cost
costs[dest] = inf
if src == 0:
build.append(dest)
else:
connect.append('%d %d' % (src, dest))
current = dest
return build, connect, total_cost
if __name__ == '__main__':
import sys
n = int(input())
pos = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
c_costs = list(map(int, input().split()))
k_costs = list(map(int, input().split()))
inf = 10**18
matrix = [[inf]*(n+1) for _ in range(n+1)]
for i in range(n):
for j in range(i+1, n):
matrix[i+1][j+1] = matrix[j+1][i+1] = \
(abs(pos[i][0]-pos[j][0]) + abs(pos[i][1]-pos[j][1])) * (k_costs[i]+k_costs[j])
matrix[i+1][0] = matrix[0][i+1] = c_costs[i]
build, connect, cost = prim(matrix)
print(cost)
print(len(build))
print(*build)
print(len(connect))
if connect:
print(*connect, sep='\n')
``` | output | 1 | 4,272 | 1 | 8,545 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen. | instruction | 0 | 4,273 | 1 | 8,546 |
Tags: dsu, graphs, greedy, shortest paths, trees
Correct Solution:
```
import sys
reader = (map(int, s.split()) for s in sys.stdin)
n, = next(reader)
xy = []
for _ in range(n):
x, y = next(reader)
xy.append([x, y])
c = list(next(reader))
k = list(next(reader))
# n = int(input())
# xy = [[]]*n
# for i in range(n):
# xy[i] = list(map(int,input().split()))
# c = list(map(int,input().split()))
# k = list(map(int,input().split()))
graph = [[0 for _ in range(n+1)] for _i in range(n+1)]
for i in range(n):
for j in range(i+1,n):
cost = (abs(xy[i][0]-xy[j][0])+abs(xy[i][1]-xy[j][1]))*(k[i]+k[j])
graph[i][j] = graph[j][i] = cost
graph[n][i] = graph[i][n] = c[i]
# def output(parent):
# es = []
# vs = []
# cost = 0
# for i in range(1,(n+1)):
# if parent[i]==n:
# vs.append(i+1)
# elif i==n:
# vs.append(parent[i]+1)
# else:
# es.append([i+1,parent[i]+1])
# cost+= graph[i][parent[i]]
# print(cost)
# print(len(vs))
# print(*vs)
# print(len(es))
# for i in es:
# print(i[0],i[1])
# def minKey(key, mstSet):
# # Initilaize min value
# min = 1000000000000
# for v in range((n+1)):
# if key[v] < min and mstSet[v] == False:
# min = key[v]
# min_index = v
# return min_index
def primMST():
# Key values used to pick minimum weight edge in cut
key = [1000000000000] * (n+1)
parent = [None] * (n+1) # Array to store constructed MST
# Make key 0 so that this vertex is picked as first vertex
key[0] = 0
mstSet = [False] * (n+1)
parent[0] = -1 # First node is always the root of
for cout in range((n+1)):
# Pick the minimum distance vertex from
# the set of vertices not yet processed.
# u is always equal to src in first iteration
mn = 1000000000000
for v in range((n+1)):
if key[v] < mn and mstSet[v] == False:
mn = key[v]
min_index = v
u = min_index
# Put the minimum distance vertex in
# the shortest path tree
mstSet[u] = True
# Update dist value of the adjacent vertices
# of the picked vertex only if the current
# distance is greater than new distance and
# the vertex in not in the shotest path tree
for v in range((n+1)):
# graph[u][v] is non zero only for adjacent vertices of m
# mstSet[v] is false for vertices not yet included in MST
# Update the key only if graph[u][v] is smaller than key[v]
if graph[u][v] > 0 and mstSet[v] == False and key[v] > graph[u][v]:
key[v] = graph[u][v]
parent[v] = u
# es = []
vss = 0
# vs = []
cost = 0
for i in range(1,(n+1)):
if parent[i]==n or i==n:
vss += 1
# vs.append(i+1)
# elif i==n:
# vs.append(parent[i]+1)
# else:
# es.append([i+1,parent[i]+1])
cost+= graph[i][parent[i]]
myprint = sys.stdout.write
myprint(str(cost) + '\n')
# print(cost)
# print(vss)
myprint(str(vss)+'\n')
vs = [0]*(vss)
es = [[]]*(n-vss)
k1,k2 = 0,0
for i in range(1,(n+1)):
if parent[i]==n:
vs[k1] = i+1
k1+=1
elif i==n:
vs[k1] = parent[i]+1
k1+=1
else:
es[k2] = [i+1,parent[i]+1]
k2+=1
# cost+= graph[i][parent[i]]
# print(*vs)
[myprint(str(st) + ' ') for st in vs]
myprint('\n')
myprint(str(len(es))+'\n')
[myprint(str(i[0]) + ' ' + str(i[1]) + '\n') for i in es]
# print(len(es))
# for i in es:
# print(i[0],i[1])
# myprint(str(totalCost) + '\n')
# myprint(str(len(stations)) + '\n')
# [myprint(str(st) + ' ') for st in stations];
# myprint(str(len(connections)) + '\n')
# [myprint(str(c1) + ' ' + str(c2) + '\n') for c1, c2 in connections];
primMST()
# e = 0
# i=0
# ans = []
# ret = 0
# while e<n:
# edge = edges[i]
# i+=1
# cost,a,b = edge
# if find(a)!=find(b):
# e+=1
# ans.append([cost,a,b])
# union(a,b)
# ret += cost
# vs = []
# es = []
# for i in ans:
# if i[1]==n:
# vs.append(i[2]+1)
# else:
# es.append(i)
# print(ret)
# print(len(vs))
# print(*vs)
# print(len(es))
# for i in es:
# print(i[1]+1,i[2]+1)
``` | output | 1 | 4,273 | 1 | 8,547 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen. | instruction | 0 | 4,274 | 1 | 8,548 |
Tags: dsu, graphs, greedy, shortest paths, trees
Correct Solution:
```
from collections import deque
from math import inf
def run_testcase():
n = int(input())
coords = [None] * (n + 1)
for i in range(1, n + 1):
coords[i] = [int(x) for x in input().split()]
ci = [0] + [int(x) for x in input().split()]
ki = [0] + [int(x) for x in input().split()]
def cost(i, j):
if i == j:
return 0
if i > j:
i, j = j, i
if i == 0:
return ci[j]
return (abs(coords[i][0] - coords[j][0]) + abs(coords[i][1] - coords[j][1])) * (ki[i] + ki[j])
current_cost = 0
tree = set([0])
rest = set(range(1, n + 1))
included = [True] + [False] * n
connections = deque()
connections_to_station = 0
# min_attach_cost = [0] + [inf] * n
# min_attach_cost = [0] + [cost(0, j) for j in range(1, n + 1)]
min_attach_cost = [(0, 0)] + [(cost(0, j), 0) for j in range(1, n + 1)]
while len(tree) < n + 1:
min_pair = (0, 0)
min_cost = inf
# for tree_node in tree:
# for i in range(1, n + 1):
# if included[i]:
# continue
# curr_cost = cost(tree_node, i)
# if curr_cost < min_cost:
# min_pair = (tree_node, i)
# min_cost = curr_cost
for node in rest:
if min_attach_cost[node][0] < min_cost:
min_pair = (min_attach_cost[node][1], node)
min_cost = min_attach_cost[node][0]
tree.add(min_pair[1])
included[min_pair[1]] = True
current_cost += min_cost
rest.remove(min_pair[1])
for node in rest:
if cost(min_pair[1], node) < min_attach_cost[node][0]:
min_attach_cost[node] = (cost(min_pair[1], node), min_pair[1])
min_pair = tuple(sorted(min_pair))
if min_pair[0] == 0:
connections.appendleft(min_pair)
connections_to_station += 1
else:
connections.append(min_pair)
connections_list = list(connections)
print(current_cost)
print(connections_to_station)
print(' '.join(map(lambda x: str(x[1]), connections_list[:connections_to_station])))
print(len(connections_list) - connections_to_station)
for i in range(connections_to_station, len(connections_list)):
print(connections_list[i][0], connections_list[i][1])
# testcase_count = int(input())
# for i in range(testcase_count):
# print(str(run_testcase()))
run_testcase()
``` | output | 1 | 4,274 | 1 | 8,549 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen. | instruction | 0 | 4,275 | 1 | 8,550 |
Tags: dsu, graphs, greedy, shortest paths, trees
Correct Solution:
```
import sys
input = sys.stdin.readline
n=int(input())
T=[tuple(map(int,input().split())) for i in range(n)]
C=list(map(int,input().split()))
K=list(map(int,input().split()))
import heapq
H=[]
for i,c in enumerate(C):
H.append((c,i+1))
heapq.heapify(H)
ANS=0
USE=[0]*(n+1)
ANS1=[]
ANS2=[]
while H:
x=heapq.heappop(H)
#print(x)
#print(H)
if len(x)==2:
cost,town=x
if USE[town]==1:
continue
ANS+=cost
USE[town]=1
ANS1.append(town)
xt,yt=T[town-1]
for i in range(n):
if USE[i+1]==1:
continue
costp=(abs(T[i][0]-xt)+abs(T[i][1]-yt))*(K[i]+K[town-1])
#print(costp,xt,yt,i)
if costp<C[i]:
C[i]=costp
heapq.heappush(H,(costp,town,i+1))
else:
cost,town1,town2=x
if USE[town1]==1 and USE[town2]==1:
continue
ANS+=cost
USE[town2]=1
ANS2.append((town1,town2))
xt,yt=T[town2-1]
for i in range(n):
if USE[i+1]==1:
continue
costp=(abs(T[i][0]-xt)+abs(T[i][1]-yt))*(K[i]+K[town2-1])
if costp<C[i]:
C[i]=costp
heapq.heappush(H,(costp,town2,i+1))
sys.stdout.write(str(ANS)+"\n")
sys.stdout.write(str(len(ANS1))+"\n")
print(*ANS1)
sys.stdout.write(str(len(ANS2))+"\n")
for x,y in ANS2:
sys.stdout.write(str(x)+" "+str(y)+"\n")
``` | output | 1 | 4,275 | 1 | 8,551 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen. | instruction | 0 | 4,276 | 1 | 8,552 |
Tags: dsu, graphs, greedy, shortest paths, trees
Correct Solution:
```
from math import *
c=int(input())
x=[0]*c
y=[0]*c
vu=[False]*c
for i in range(c):
x[i],y[i]=[int(s) for s in input().split()]
prix=[int(s) for s in input().split()]
fil=[int(s) for s in input().split()]
anc=[-1]*c
pmin=prix.copy()
v=0
pl=[]
e=0
ppl=[]
tot=0
for i in range(c):
pmina=100000000000000000000000
for j in range(c):
if (not vu[j]) and pmin[j]<pmina:
pmini=j
pmina=pmin[j]
vu[pmini]=True
tot+=pmina
if anc[pmini]==-1:
v+=1
pl.append(str(pmini+1))
else:
e+=1
ppl.append([str(pmini+1),str(anc[pmini]+1)])
for j in range(c):
if (abs(x[pmini]-x[j])+abs(y[pmini]-y[j]))*(fil[pmini]+fil[j])<pmin[j]:
pmin[j]=(abs(x[pmini]-x[j])+abs(y[pmini]-y[j]))*(fil[pmini]+fil[j])
anc[j]=pmini
print(tot)
print(v)
print(" ".join(pl))
print(e)
for i in ppl:
print(" ".join(i))
``` | output | 1 | 4,276 | 1 | 8,553 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen. | instruction | 0 | 4,277 | 1 | 8,554 |
Tags: dsu, graphs, greedy, shortest paths, trees
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
def prims(n,path,st,z,c,conn):
ans,where,visi = 0,[z]*n,[0]*n
node = [path[j][z] for j in range(n)]
visi[z] = 1
while 1:
le,y,dig = float("inf"),-1,0
for j in range(n):
if visi[j]:
continue
if node[j] < c[j] and node[j] < le:
le,y,dig = node[j],j,0
elif c[j] < node[j] and c[j] < le:
le,y,dig = c[j],j,1
if le == float("inf"):
return ans
visi[y] = 1
if not dig:
conn.append((where[y]+1,y+1))
else:
st.append(y+1)
ans += le
for j,i in enumerate(path[y]):
if not visi[j] and i < node[j]:
node[j],where[j] = i,y
def main():
n = int(input())
x,y = [],[]
for a1,b1 in iter([map(int,input().split()) for _ in range(n)]):
x.append(a1)
y.append(b1)
c = list(map(float,input().split()))
k = list(map(float,input().split()))
path = [[0]*n for _ in range(n)]
for i in range(n):
for j in range(i+1,n):
z = (k[i]+k[j])*(abs(x[i]-x[j])+abs(y[i]-y[j]))
path[i][j],path[j][i] = z,z
z,ans,st,conn = c.index(min(c)),min(c),[],[]
st.append(z+1)
ans += prims(n,path,st,z,c,conn)
print(int(ans))
print(len(st))
print(*st)
print(len(conn))
for i in conn:
print(*i)
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self,file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
self.newlines = b.count(b"\n")+(not b)
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd,self.buffer.getvalue())
self.buffer.truncate(0),self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self,file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s:self.buffer.write(s.encode("ascii"))
self.read = lambda:self.buffer.read().decode("ascii")
self.readline = lambda:self.buffer.readline().decode("ascii")
sys.stdin,sys.stdout = IOWrapper(sys.stdin),IOWrapper(sys.stdout)
input = lambda:sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 4,277 | 1 | 8,555 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen. | instruction | 0 | 4,278 | 1 | 8,556 |
Tags: dsu, graphs, greedy, shortest paths, trees
Correct Solution:
```
import sys
input=sys.stdin.readline
n=int(input())
X=[[0]*7 for _ in range(n)]
for i in range(n):
x,y=map(int,input().split())
X[i][0],X[i][1],X[i][2]=i+1,x,y
C=[int(i) for i in input().split()]
K=[int(i) for i in input().split()]
for i in range(n):
X[i][3],X[i][4]=C[i],K[i]
ans_am=0
ans_ps=0
Ans=[]
ans_con=0
Con=[]
def m(X):
ret=0
cur=X[0][3]
for i in range(1,len(X)):
if X[i][3]<cur:
ret=i
cur=X[i][3]
return ret
while X:
r=m(X)
ind,x,y,c,k,flag,source=X.pop(r)
ans_am+=c
if flag==0:
ans_ps+=1
Ans.append(ind)
else:
ans_con+=1
Con.append((ind,source))
for i in range(len(X)):
indi,xi,yi,ci,ki,flagi,sourcei=X[i]
cost=(k+ki)*(abs(x-xi)+abs(y-yi))
if cost<ci:
X[i][3],X[i][5],X[i][6]=cost,1,ind
print(ans_am)
print(ans_ps)
print(*Ans)
print(ans_con)
for i,j in Con:
print(i,j)
``` | output | 1 | 4,278 | 1 | 8,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen.
Submitted Solution:
```
n=int(input())
X=[[0]*7 for _ in range(n)]
for i in range(n):
x,y=map(int,input().split())
X[i][0]=i+1
X[i][1]=x
X[i][2]=y
C=[int(i) for i in input().split()]
K=[int(i) for i in input().split()]
for i in range(n):
X[i][3]=C[i]
X[i][4]=K[i]
ans_am=0
ans_ps=0
Ans=[]
ans_con=0
Con=[]
def m(X):
ret=0
cur=X[0][3]
for i in range(1,len(X)):
if X[i][3]<cur:
ret=i
cur=X[i][3]
return ret
while X:
r=m(X)
ind,x,y,c,k,flag,source=X.pop(r)
ans_am+=c
if flag==0:
ans_ps+=1
Ans.append(ind)
else:
ans_con+=1
Con.append([ind,source])
for i in range(len(X)):
indi,xi,yi,ci,ki,flagi,sourcei=X[i]
if (k+ki)*(abs(x-xi)+abs(y-yi))<ci:
X[i][3]=(k+ki)*(abs(x-xi)+abs(y-yi))
X[i][5]=1
X[i][6]=ind
print(ans_am)
print(ans_ps)
print(*Ans)
print(ans_con)
for i,j in Con:
print(i,j)
``` | instruction | 0 | 4,279 | 1 | 8,558 |
Yes | output | 1 | 4,279 | 1 | 8,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen.
Submitted Solution:
```
import sys
# inf = open('input.txt', 'r')
# reader = (map(int, line.split()) for line in inf)
reader = (map(int, s.split()) for s in sys.stdin)
n, = next(reader)
cities = [None]
for _ in range(n):
x, y = next(reader)
cities.append((x, y))
cs = [None] + list(next(reader))
ks = [None] + list(next(reader))
n += 1 # extra 0 node (dummy node); edge (0, v) <=> v-node has station
g = [[None] * n for _ in range(n)]
for i in range(1, n):
for j in range(i + 1, n):
wire = ks[i] + ks[j]
dist = abs(cities[i][0] - cities[j][0]) + \
abs(cities[i][1] - cities[j][1])
g[i][j] = g[j][i] = wire * dist
for i in range(1, n):
g[0][i] = g[i][0] = cs[i]
for i in range(n):
g[i][i] = float('inf')
totalCost = 0
stations = []
connections = []
used = [False] * n
min_e = [float('inf')] * n
sel_e = [-1] * n
start = 0 # starting from 0-node (dummy node)
min_e[start] = 0
for i in range(n):
v = -1
for j in range(n):
if (not used[j] and (v == -1 or min_e[j] < min_e[v])):
v = j
# if min_e[v] == float('inf'): break
used[v] = True
fromNode = sel_e[v]
if not fromNode: # edge (0, v) <=> v-node has station
totalCost += g[v][fromNode]
stations.append(v)
elif fromNode > 0:
totalCost += g[v][fromNode]
connections.append((v, fromNode))
for to in range(n):
if g[v][to] < min_e[to]:
min_e[to] = g[v][to]
sel_e[to] = v
myprint = sys.stdout.write
myprint(str(totalCost) + '\n')
myprint(str(len(stations)) + '\n')
[myprint(str(st) + ' ') for st in stations];
myprint(str(len(connections)) + '\n')
[myprint(str(c1) + ' ' + str(c2) + '\n') for c1, c2 in connections];
# print(totalCost)
# print(len(stations))
# print(*stations)
# print(len(connections))
# [print(c1, c2) for c1, c2 in connections];
# inf.close()
``` | instruction | 0 | 4,280 | 1 | 8,560 |
Yes | output | 1 | 4,280 | 1 | 8,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen.
Submitted Solution:
```
#for _ in range(int(input())):
#n,k=map(int, input().split())
#arr = list(map(int, input().split()))
#ls= list(map(int, input().split()))
import math
n = int(input())
coor=[]
def dis(x,y):
return abs(x[0]-y[0])+abs(y[1]-x[1])
for i in range(n):
u,v=map(int, input().split())
coor.append((u,v))
cost=list(map(int, input().split()))
k=list(map(int, input().split()))
d={}
power_st=[]
vis=[0]*n
connect=[]
parent=[-1 for i in range(n)]
for i in range(n):
d[i]=cost[i]
ans=0
for i in range(n):
m=min(d,key=d.get)
if vis[m]==0:
power_st.append(m)
else:
connect.append([m,parent[m]])
ans=ans+d[m]
del d[m]
for j in d.keys():
t=dis(coor[m],coor[j])*(k[m]+k[j])
if t<d[j]:
d[j]=t
parent[j]=m
vis[j]=1
print(ans)
print(len(power_st))
for i in power_st:
print(i+1,end=" ")
print()
print(len(connect))
for i in connect:
print(i[0]+1 ,i[1]+1)
``` | instruction | 0 | 4,281 | 1 | 8,562 |
Yes | output | 1 | 4,281 | 1 | 8,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen.
Submitted Solution:
```
n=int(input())
pos=[[*map(int,input().split())] for i in range(n)]
*c,=map(int, input().split())
*k,=map(int, input().split())
used = [False for i in range(n)]
parent = [-1 for i in range(n)]
plants = []
connections = []
ans = 0
_n = n
while(_n):
_n -= 1
mn, u = min([(ci, i) for i, ci in enumerate(c) if not used[i]])
ans += mn
used[u] = True
if parent[u] == -1:
plants.append(u)
else:
connections.append((min(parent[u], u), max(parent[u], u)))
for i in range(n):
con_cost = (k[u] + k[i])*(abs(pos[u][0]-pos[i][0])+abs(pos[u][1]-pos[i][1]))
if con_cost < c[i]:
c[i] = con_cost
parent[i] = u
print(ans)
print(len(plants))
for p in sorted(plants):
print(p+1, end=' ')
print('')
print(len(connections))
for con in connections:
print(con[0]+1, con[1]+1)
``` | instruction | 0 | 4,282 | 1 | 8,564 |
Yes | output | 1 | 4,282 | 1 | 8,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen.
Submitted Solution:
```
import math
n = int(input())
cityNo=[0]*n
for i in range(n):
cityNo[i]=list(map(int,input().split()))
cost=list(map(int,input().split()))
ks =list(map(int,input().split()))
powerStation=[0]*n
totalCost=sum(cost)
print(totalCost)
req_Powerstation=[]
notReq_Powerstation=[]
totalCost=0
established={}
updated=[-1]*n
for j in range(n):
city=-1
mini=9999999999999999
for i in range(n):
if mini>cost[i] and i not in established:
city=i
mini=cost[i]
if updated[city]==-1:
req_Powerstation.append(city+1)
else:
notReq_Powerstation.append([city+1,updated[city]+1])
established[city]=1
for i in range(n):
cost_From_City = (ks[i]+ks[city])*(abs(cityNo[i][0]-cityNo[city][0])+abs(cityNo[i][1]-cityNo[city][1]))
if cost_From_City<cost[i]:
cost[i]=cost_From_City
updated[i]=city
# print(updated)
print(len(req_Powerstation))
print(*req_Powerstation)
print(len(notReq_Powerstation))
for i in range(len(notReq_Powerstation)):
print(*notReq_Powerstation[i])
``` | instruction | 0 | 4,283 | 1 | 8,566 |
No | output | 1 | 4,283 | 1 | 8,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen.
Submitted Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
def prims(n,path,visi,st,c,conn):
ans,mini,where = 0,c[st],[st]*n
node = [path[j][st] for j in range(n)]
while 1:
le,y = float("inf"),-1
for j in range(n):
if node[j] > le or visi[j] or node[j] > max(mini,c[j]):
continue
le,y = node[j],j
if y == -1:
return ans,st
visi[y] = 1
conn.append((where[y]+1,y+1))
ans += le-max(mini,c[y])
if c[y] < mini:
mini,st = c[y],y
for j,i in enumerate(path[y]):
if not visi[j] and i < node[j]:
node[j],where[j] = i,y
def main():
n = int(input())
x,y = [],[]
for _ in range(n):
a1,b1 = map(int,input().split())
x.append(a1)
y.append(b1)
c = list(map(float,input().split()))
k = list(map(float,input().split()))
path = [[0]*n for _ in range(n)]
for i in range(n):
for j in range(i+1,n):
z = (k[i]+k[j])*(abs(x[i]-x[j])+abs(y[i]-y[j]))
path[i][j],path[j][i] = z,z
visi,ans1,st,conn = [0]*n,sum(c),[],[]
for i in range(n):
if visi[i]:
continue
visi[i] = 1
z = prims(n,path,visi,i,c,conn)
ans1 += z[0]
st.append(z[1]+1)
print(int(ans1))
print(len(st))
print(*st)
print(len(conn))
for i in conn:
print(*i)
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self,file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
self.newlines = b.count(b"\n")+(not b)
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd,self.buffer.getvalue())
self.buffer.truncate(0),self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self,file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s:self.buffer.write(s.encode("ascii"))
self.read = lambda:self.buffer.read().decode("ascii")
self.readline = lambda:self.buffer.readline().decode("ascii")
sys.stdin,sys.stdout = IOWrapper(sys.stdin),IOWrapper(sys.stdout)
input = lambda:sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | instruction | 0 | 4,284 | 1 | 8,568 |
No | output | 1 | 4,284 | 1 | 8,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen.
Submitted Solution:
```
n = int(input())
posiciones = []
padres = []
for i in range(n):
x,y = map(int,input().split())
posiciones.append([x,y])
padres.append(i)
costos = list(map(int,input().split()))
peajes = list(map(int,input().split()))
min_c = float('inf')
min_pos = float('inf')
for i in range(n):
c = costos[i]
if c < min_c:
min_c = c
min_pos = i
x_min, y_min = posiciones[min_pos]
optimos = []
construcciones = []
uniones = []
cantidad_const = 0
cant_uniones = 0
for i in range(n):
if i != min_pos:
x,y = posiciones[i]
distancia = (abs(x_min-x)+abs(y_min-y))* (peajes[i] + peajes[min_pos])
if (distancia > costos[i]):
optimos.append(costos[i])
construcciones.append(i+1)
cantidad_const += 1
else:
optimos.append(distancia)
cant_uniones += 1
uniones.append([i,min_pos])
else:
optimos.append(min_c)
construcciones.append(i+1)
cantidad_const += 1
print(sum(optimos))
print(cantidad_const)
print(*construcciones)
print(cant_uniones)
if cant_uniones:
for i,j in uniones:
print(i+1,j+1)
``` | instruction | 0 | 4,285 | 1 | 8,570 |
No | output | 1 | 4,285 | 1 | 8,571 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen.
Submitted Solution:
```
from collections import defaultdict
from math import sqrt,factorial,gcd,log2,inf,ceil
# map(int,input().split())
# l = list(map(int,input().split()))
mod = 10**9 + 7
import sys
sys.setrecursionlimit(10**9)
def find_parent(u):
if par[u]!=u:
par[u]=find_parent(par[u])
return par[u]
n = int(input())
par = [0]+[i+1 for i in range(n)]
rank = [1]*(n+1)
la = []
for i in range(n):
x,y = map(int,input().split())
la.append([i+1,x,y])
c = list(map(int,input().split()))
k = list(map(int,input().split()))
edges = []
ans = 0
for i in range(n):
for j in range(i+1,n):
w = abs(la[i][1]-la[j][1]) + abs(la[i][2]-la[j][2])
# edges.append([w,la[i][0],la[j][0]])
z1 = find_parent(i+1)
z2 = find_parent(j+1)
if z1!=z2:
cost = w*(k[z1-1]+k[z2-1])
stn = c[z1-1] + c[z2-1]
if cost<=stn:
if c[z1-1]<c[z2-1]:
z1,z2 = z2,z1
par[z1] = z2
edges.append((i+1,j+1))
ans+=cost
seti = set()
for i in range(n):
z = find_parent(i+1)
seti.add(z)
# print(seti)
for i in seti:
ans+=c[i-1]
print(ans)
print(len(seti))
print(*(sorted(seti)))
print(len(edges))
for a,b in edges:
print(a,b)
``` | instruction | 0 | 4,286 | 1 | 8,572 |
No | output | 1 | 4,286 | 1 | 8,573 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13. | instruction | 0 | 4,399 | 1 | 8,798 |
Tags: brute force, graphs, shortest paths
Correct Solution:
```
from sys import stdin
input = stdin.readline
from heapq import heappush, heappop
n, m, k = map(int, input().split())
# edge = [tuple(map(int, input().split())) for _ in range(m)]
# courier = [tuple(map(int, input().split())) for _ in range(k)]
r = [tuple(map(int,inp.split())) for inp in stdin.read().splitlines()]
adj = [[] for _ in range(n+1)]
for u, v, w in r[:m]:
adj[u].append([v, w])
adj[v].append([u, w])
INF = 10**9
dis = [[INF] * (n + 1) for _ in range(n + 1)]
# for i in range(1,n+1):
# dis[i][i] = 0
for s in range(1, n + 1):
dis[s][s] = 0
h = [(0, s)]
while h:
curd, cur = heappop(h)
if curd > dis[s][cur]:
continue
for nxt, w in adj[cur]:
nd = curd + w
if nd < dis[s][nxt]:
dis[s][nxt] = nd
heappush(h, (nd, nxt))
res = INF
for s, e, _ in r[:m]:
temp = 0
for cs, ce in r[m:]:
temp += min(dis[cs][ce], dis[cs][s] + dis[ce][e], dis[cs][e] + dis[ce][s])
res = min(res,temp)
print(res)
``` | output | 1 | 4,399 | 1 | 8,799 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13. | instruction | 0 | 4,400 | 1 | 8,800 |
Tags: brute force, graphs, shortest paths
Correct Solution:
```
import heapq
inf = 1000000007
n, m, k = map(int, input().split())
E = [[] for _ in range(n)]
edges = []
for _ in range(m):
u, v, w = map(int, input().split())
E[u-1].append((v-1, w))
E[v-1].append((u-1, w))
edges.append((u-1, v-1, w))
routes = []
for _ in range(k):
a, b = map(int, input().split())
routes.append((a-1, b-1))
def dijkstra(st):
pq, dist = [(0, st)], [inf if i!=st else 0 for i in range(n)]
while len(pq)>0:
d, u = heapq.heappop(pq)
if d!=dist[u]:
continue
for v, w in E[u]:
if dist[v]>dist[u]+w:
dist[v] = dist[u]+w
heapq.heappush(pq, (dist[v], v))
return dist
dist = []
for i in range(n):
dist.append(dijkstra(i))
ans = inf
for u, v, _ in edges:
now = 0
for a, b in routes:
now += min(dist[a][b], dist[a][u]+dist[b][v], dist[a][v]+dist[b][u])
ans = min(ans, now)
print(ans)
``` | output | 1 | 4,400 | 1 | 8,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13. | instruction | 0 | 4,401 | 1 | 8,802 |
Tags: brute force, graphs, shortest paths
Correct Solution:
```
import heapq
n, m, k = map(int, input().split())
E = [[] for _ in range(n)]
edges = []
for _ in range(m):
u, v, w = map(int, input().split())
E[u-1].append((v-1, w))
E[v-1].append((u-1, w))
edges.append((u-1, v-1, w))
routes = []
for _ in range(k):
a, b = map(int, input().split())
routes.append((a-1, b-1))
def dijkstra(st):
pq, dist = [(0, st)], [float("inf") if i!=st else 0 for i in range(n)]
while len(pq)>0:
d, u = heapq.heappop(pq)
if d!=dist[u]:
continue
for v, w in E[u]:
if dist[v]>dist[u]+w:
dist[v] = dist[u]+w
heapq.heappush(pq, (dist[v], v))
return dist
dist = []
for i in range(n):
dist.append(dijkstra(i))
ans = float("inf")
for u, v, _ in edges:
now = 0
for a, b in routes:
now += min(dist[a][b], dist[a][u]+dist[b][v], dist[a][v]+dist[b][u])
ans = min(ans, now)
print(ans)
``` | output | 1 | 4,401 | 1 | 8,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13. | instruction | 0 | 4,402 | 1 | 8,804 |
Tags: brute force, graphs, shortest paths
Correct Solution:
```
import sys
input = sys.stdin.readline
N, M, K = map(int, input().split())
e = [[] for _ in range(N + 1)]
for _ in range(M):
u, v, c = map(int, input().split())
e[u].append((v, c))
e[v].append((u, c))
qs = [tuple(map(int, input().split())) for _ in range(K)]
import heapq
hpush = heapq.heappush
hpop = heapq.heappop
class dijkstra:
def __init__(self, n, e):
self.e = e
self.n = n
def path(self, s):
d = [float("inf")] * (self.n + 1)
vis = [0] * (self.n + 1)
d[s] = 0
h = [s]
while len(h):
v = hpop(h)
v1 = v % (10 ** 4)
v0 = v // (10 ** 4)
if vis[v1]: continue
vis[v1] = 1
for p in self.e[v1]:
d[p[0]] = min(d[p[0]], d[v1] + p[1])
if vis[p[0]]: continue
hpush(h, d[p[0]] * (10 ** 4) + p[0])
return d
dij = dijkstra(N, e)
ps = [[]]
for x in range(1, N + 1): ps.append(dij.path(x))
t = [ps[qs[i][0]][qs[i][1]] for i in range(K)]
res = sum(t)
for x in range(1, N + 1): ps.append(dij.path(x))
for x in range(1, N + 1):
for y, c in e[x]:
tt = t[: ]
for k in range(K):
tt[k] = min(tt[k], ps[x][qs[k][0]] + ps[y][qs[k][1]], ps[y][qs[k][0]] + ps[x][qs[k][1]])
res = min(res, sum(tt))
print(res)
``` | output | 1 | 4,402 | 1 | 8,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13. | instruction | 0 | 4,403 | 1 | 8,806 |
Tags: brute force, graphs, shortest paths
Correct Solution:
```
def read_generator():
while True:
tokens = input().split(' ')
for t in tokens:
yield t
reader = read_generator()
def readword():
return next(reader)
def readint():
return int(next(reader))
def readfloat():
return float(next(reader))
def readline():
return input()
def solve(n):
return n
import heapq
def finddist(s, g, n):
d = [10 ** 10] * n
handled = [False] * n
d[s] = 0
heap = [(0, s)]
heapq.heapify(heap)
while len(heap) > 0:
(l, v) = heapq.heappop(heap)
if not handled[v]:
handled[v] = True
for (nextV, w) in g[v]:
if d[nextV] > d[v] + w:
d[nextV] = d[v] + w
heapq.heappush(heap, (d[nextV], nextV))
return d
tests = 1
for t in range(tests):
n = readint()
m = readint()
k = readint()
g = [[] for _ in range(n)]
e = []
for _ in range(m):
v1, v2, w = readint() - 1, readint() - 1, readint()
g[v1].append((v2, w))
g[v2].append((v1, w))
e.append((v1, v2))
p = [(readint() - 1, readint() - 1) for _ in range(k)]
d = [finddist(i, g, n) for i in range(n)]
res = 0
for (s1, s2) in p:
res += d[s1][s2]
for (v1, v2) in e:
s = 0
for (s1, s2) in p:
s += min(d[s1][s2], d[s1][v1] + d[v2][s2], d[s1][v2] + d[v1][s2])
res = min(res, s)
print(res)
``` | output | 1 | 4,403 | 1 | 8,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13. | instruction | 0 | 4,404 | 1 | 8,808 |
Tags: brute force, graphs, shortest paths
Correct Solution:
```
n, m, k = map(int, input().split())
inf = 1000001
g = [[] for _ in range(n)]
e = []
for i in range(m):
a, b, w = map(int, input().split())
a -= 1
b -= 1
g[a].append((b, w))
g[b].append((a, w))
e.append((a, b))
def f(s, g):
d = [inf] * n
d[s] = 0
q = [s]
i = 0
while i < len(q):
w, v = divmod(q[i], n)
i += 1
if d[v] != w:
continue
for u, w in g[v]:
if d[v] + w < d[u]:
d[u] = d[v] + w
q.append(u + n * d[u])
return d
p = [f(s, g) for s in range(n)]
t, s = 0, [0] * len(e)
for i in range(k):
x, y = map(int, input().split())
if x == y:
continue
x -= 1
y -= 1
t += p[x][y]
for i, (a, b) in enumerate(e):
d = min(p[x][a] + p[b][y], p[x][b] + p[a][y])
if p[x][y] > d:
s[i] += p[x][y] - d
print(t - max(s))
``` | output | 1 | 4,404 | 1 | 8,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13. | instruction | 0 | 4,405 | 1 | 8,810 |
Tags: brute force, graphs, shortest paths
Correct Solution:
```
from math import inf
import heapq
n,m,k = map(int,input().split())
G = [[] for _ in range(n)]
Q = []
for _ in range(m):
x,y,w = map(int,input().split())
G[x-1].append((y-1,w))
G[y-1].append((x-1,w))
for _ in range(k):
a,b = map(int,input().split())
Q.append((a-1,b-1))
def solve(x):
dist = [inf]*n
dist[x] = 0
q = [(0,x)]
while q:
d,x = heapq.heappop(q)
for y,w in G[x]:
if d+w < dist[y]:
dist[y] = d+w
heapq.heappush(q,(d+w,y))
return dist
D = [solve(x) for x in range(n)]
ans = inf
for x in range(n):
for y,w in G[x]:
s = 0
for a,b in Q:
v = min(D[a][x] + D[y][b], D[a][y] + D[x][b], D[a][b])
s += v
ans = min(s,ans)
print(ans)
``` | output | 1 | 4,405 | 1 | 8,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13. | instruction | 0 | 4,406 | 1 | 8,812 |
Tags: brute force, graphs, shortest paths
Correct Solution:
```
import heapq
import io,os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def dijkstra(source,neigh,dic):
n = len(neigh)
distance = [float('inf')]*n
visited = [False]*n
heap = []
heapq.heappush(heap,(0,source))
while heap:
temp = heapq.heappop(heap)
# print(temp)
(d,index) = (temp[0],temp[1])
if distance[index] <= d: continue
distance[index] = d
for ele in neigh[index]:
if distance[ele] > distance[index] + dic[(ele,index)]:
heapq.heappush(heap,(distance[index] + dic[(ele,index)], ele))
return distance
n,m,k = map(int,input().split())
neigh = [[] for i in range(n)]
start = [0]*(k)
end = [0]*k
dic = {}
for i in range(m):
path = list(map(int,input().split()))
neigh[path[0]-1].append(path[1]-1)
neigh[path[1]-1].append(path[0]-1)
dic[(path[0]-1,path[1]-1)] = path[2]
dic[(path[1]-1,path[0]-1)] = path[2]
for i in range(k):
temp1, temp2 = map(int,input().split())
start[i] = temp1 - 1
end[i] = temp2 - 1
#if n==1000 and m==1000 and k==1000:
# print("5625644")
# exit(0)
matrix = []
for i in range(n):
matrix.append(dijkstra(i,neigh,dic))
"""
for inter in range(n):
for i in range(n):
for j in range(i+1,n):
matrix[i][j] = min(matrix[i][j], matrix[i][inter]+matrix[inter][j])
matrix[j][i] = matrix[i][j]
matrix[i][i] = 0
"""
#print(matrix)
ans = 2147483647
for ele in dic:
tot = 0
for i in range(k):
tot += min( matrix[start[i]][end[i]], matrix[start[i]][ele[0]]+matrix[ele[1]][end[i]], matrix[start[i]][ele[1]]+matrix[ele[0]][end[i]])
ans = min(ans,tot)
print(ans)
``` | output | 1 | 4,406 | 1 | 8,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13.
Submitted Solution:
```
import sys
input = sys.stdin.readline
from collections import defaultdict
from math import inf
from heapq import heappop,heappush
def dijkstra(start):
heap,dist=[(0,start)],[inf]*(n+1)
dist[start]=0
while heap:
d,vertex=heappop(heap)
for child,weight in graph[vertex]:
weight+=d
if dist[child]>weight:
dist[child]=weight
heappush(heap,(weight,child))
return(dist)
n,m,k=map(int,input().split())
graph = [[] for _ in range(n + 1)]
weights=defaultdict(int)
connectlist=[]
for i in range(m):
a,b,w=map(int,input().split())
graph[a].append((b,w))
graph[b].append((a,w))
connectlist.append((a,b))
route=[]
distlist=[]
for i in range(n):
distlist.append(dijkstra(i+1))
for i in range(k):
src,dst=map(int,input().split())
route.append((src,dst))
ans=10**10
for i in connectlist:
tmp=0
for j in route:
tmp+=min(distlist[j[0]-1][j[1]],distlist[j[0]-1][i[0]]+distlist[j[1]-1][i[1]],distlist[j[0]-1][i[1]]+distlist[j[1]-1][i[0]])
if tmp<ans:
ans=tmp
print(ans)
``` | instruction | 0 | 4,407 | 1 | 8,814 |
Yes | output | 1 | 4,407 | 1 | 8,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13.
Submitted Solution:
```
from sys import stdin, stdout
input, print = stdin.readline, stdout.write
import heapq
(n, m, k) = map(int, input().split())
edgeList = []
edges = [[] for _ in range(n)]
for _ in range(m):
edge = tuple(map(int, input().split()))
edge = (edge[0]-1, edge[1]-1, edge[2])
edgeList.append(edge)
edges[edge[0]].append((edge[1], edge[2]))
edges[edge[1]].append((edge[0], edge[2]))
routes = []
for _ in range(k):
route = list(map(int, input().split()))
routes.append((route[0]-1, route[1]-1))
# Populate APSP (all-pairs shortest paths) by repeating Dijkstra N times.
minCosts = [[float('inf')] * n for _ in range(n)]
for i in range(n):
minCosts[i][i] = 0
pq = [(0, i)]
visited = [False] * n
while pq:
cost, u = heapq.heappop(pq)
if visited[u]:
continue
visited[u] = True
for (v, w) in edges[u]:
if minCosts[i][v] > cost+w:
minCosts[i][v] = cost+w
heapq.heappush(pq, (cost+w, v))
# Consider each edge to set to 0.
minTotal = float('inf')
for edge in edgeList:
total = 0
for route in routes:
total += min(
minCosts[route[0]][route[1]],
minCosts[route[0]][edge[0]] + minCosts[edge[1]][route[1]],
minCosts[route[0]][edge[1]] + minCosts[edge[0]][route[1]])
minTotal = min(total, minTotal)
print(str(minTotal))
``` | instruction | 0 | 4,408 | 1 | 8,816 |
Yes | output | 1 | 4,408 | 1 | 8,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
from heapq import heappop, heappush
def main():
n, m, k = getints()
adj = [[] for _ in range(n)]
dist = [[int(1e9)] * n for _ in range(n)]
edges = []
route = []
for _ in range(m):
u, v, w = getint1()
w += 1
adj[u].append((v, w))
adj[v].append((u, w))
edges.append((u, v))
for _ in range(k):
a, b = getint1()
route.append((a, b))
for s in range(n):
dist[s][s] = 0
pq = [(0, s)]
while pq:
d, u = heappop(pq)
if d != dist[s][u]:
continue
for v, w in adj[u]:
nd = dist[s][u] + w
if dist[s][v] > nd:
dist[s][v] = nd
heappush(pq, (nd, v))
ans = int(1e9)
for u, v in edges:
cost = 0
for a, b in route:
cost += min(dist[a][b], dist[a][u] + dist[v][b], dist[a][v] + dist[u][b])
ans = min(ans, cost)
print(ans)
# 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)
def input(): return sys.stdin.readline().rstrip("\r\n")
def getint(): return int(input())
def getints(): return list(map(int, input().split()))
def getint1(): return list(map(lambda x: int(x) - 1, input().split()))
# endregion
if __name__ == "__main__":
main()
``` | instruction | 0 | 4,409 | 1 | 8,818 |
Yes | output | 1 | 4,409 | 1 | 8,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13.
Submitted Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
from heapq import *
def short(n,path,st):
visi = [0]*n
dist = [10**20]*n
dist[st] = 0
he = [(0,st)]
heapify(he)
while len(he):
x = heappop(he)[1]
if visi[x]:
continue
visi[x] = 1
for yy in path[x]:
i,j = yy
if visi[i]:
continue
if dist[i] > dist[x]+j:
dist[i] = dist[x]+j
heappush(he,(dist[i],i))
return dist
def main():
n,m,k = map(int,input().split())
path = [[] for _ in range(n)]
edg = []
for _ in range(m):
u1,v1,c1 = map(int,input().split())
edg.append((u1-1,v1-1,c1))
path[u1-1].append((v1-1,c1))
path[v1-1].append((u1-1,c1))
dist = [short(n,path,i) for i in range(n)]
route = [tuple(map(lambda xx:int(xx)-1,input().split())) for _ in range(k)]
ans = 0
for i in route:
ans += dist[i[0]][i[1]]
for i in edg:
ans1 = 0
for j in route:
ans1 += min(dist[j[0]][i[0]]+dist[i[1]][j[1]],
dist[j[0]][i[1]]+dist[i[0]][j[1]],
dist[j[0]][j[1]])
ans = min(ans,ans1)
print(ans)
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | instruction | 0 | 4,410 | 1 | 8,820 |
Yes | output | 1 | 4,410 | 1 | 8,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13.
Submitted Solution:
```
print("bye bye")
``` | instruction | 0 | 4,411 | 1 | 8,822 |
No | output | 1 | 4,411 | 1 | 8,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13.
Submitted Solution:
```
P=1000000007
A=[1]
B=[0]
n,k,d=map(int,input().split())
for i in range(n):
S1 = 0
S2 = 0
for j in range(k):
if j<=i:
S1= (S1+A[i-j])%P
if (j>=d-1):
S2= (S2+A[i-j])%P
else:
S2= (S2+B[i-j])%P
A.append(S1)
B.append(S2)
print (B[n])
``` | instruction | 0 | 4,412 | 1 | 8,824 |
No | output | 1 | 4,412 | 1 | 8,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13.
Submitted Solution:
```
import sys
input = sys.stdin.readline
from collections import defaultdict
from math import inf
from heapq import heappop,heappush
def dijkstra(start):
heap,dist=[(0,start)],[inf]*(n+1)
dist[start]=0
while heap:
d,vertex=heappop(heap)
for child,weight in graph[vertex]:
weight+=d
if dist[child]>weight:
dist[child]=weight
heappush(heap,(weight,child))
return(dist)
n,m,k=map(int,input().split())
graph = [[] for _ in range(n + 1)]
weights=defaultdict(int)
connectlist=[]
for i in range(m):
a,b,w=map(int,input().split())
graph[a].append((b,w))
graph[b].append((a,w))
connectlist.append((a,b))
route=[]
distlist=[]
for i in range(n):
distlist.append(dijkstra(i+1))
for i in range(k):
src,dst=map(int,input().split())
route.append((src,dst))
ans=10**10
for i in connectlist:
tmp=0
for j in route:
tmp+=min(distlist[j[0]-1][j[1]],distlist[j[0]-1][i[0]]+distlist[j[1]-1][i[1]],distlist[j[0]-1][i[1]]+distlist[j[1]-1][i[1]])
if tmp<ans:
ans=tmp
print(ans)
``` | instruction | 0 | 4,413 | 1 | 8,826 |
No | output | 1 | 4,413 | 1 | 8,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13.
Submitted Solution:
```
from sys import stdin
input = stdin.readline
from heapq import heappush, heappop
n, m, k = map(int, input().split())
# edge = [tuple(map(int, input().split())) for _ in range(m)]
# courier = [tuple(map(int, input().split())) for _ in range(k)]
r = [tuple(map(int,inp.split())) for inp in stdin.read().splitlines()]
adj = [[] for _ in range(n+1)]
for u, v, w in r[:m]:
adj[u].append([v, w])
adj[v].append([u, w])
INF = 10 ** 7
dis = [[INF] * (n + 1) for _ in range(n + 1)]
# for i in range(1,n+1):
# dis[i][i] = 0
for s in range(1, n + 1):
dis[s][s] = 0
h = [(0, s)]
while h:
curd, cur = heappop(h)
if curd > dis[s][cur]:
continue
for nxt, w in adj[cur]:
nd = curd + w
if nd < dis[s][nxt]:
dis[s][nxt] = nd
heappush(h, (nd, nxt))
res = INF
for s, e, _ in r[:m]:
temp = 0
for cs, ce in r[m:]:
temp += min(dis[cs][ce], dis[cs][s] + dis[ce][e], dis[cs][e] + dis[ce][s])
res = min(res,temp)
print(res)
``` | instruction | 0 | 4,414 | 1 | 8,828 |
No | output | 1 | 4,414 | 1 | 8,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To quickly hire highly skilled specialists one of the new IT City companies made an unprecedented move. Every employee was granted a car, and an employee can choose one of four different car makes.
The parking lot before the office consists of one line of (2n - 2) parking spaces. Unfortunately the total number of cars is greater than the parking lot capacity. Furthermore even amount of cars of each make is greater than the amount of parking spaces! That's why there are no free spaces on the parking lot ever.
Looking on the straight line of cars the company CEO thought that parking lot would be more beautiful if it contained exactly n successive cars of the same make. Help the CEO determine the number of ways to fill the parking lot this way.
Input
The only line of the input contains one integer n (3 ≤ n ≤ 30) — the amount of successive cars of the same make.
Output
Output one integer — the number of ways to fill the parking lot by cars of four makes using the described way.
Examples
Input
3
Output
24
Note
Let's denote car makes in the following way: A — Aston Martin, B — Bentley, M — Mercedes-Maybach, Z — Zaporozhets. For n = 3 there are the following appropriate ways to fill the parking lot: AAAB AAAM AAAZ ABBB AMMM AZZZ BBBA BBBM BBBZ BAAA BMMM BZZZ MMMA MMMB MMMZ MAAA MBBB MZZZ ZZZA ZZZB ZZZM ZAAA ZBBB ZMMM
Originally it was planned to grant sport cars of Ferrari, Lamborghini, Maserati and Bugatti makes but this idea was renounced because it is impossible to drive these cars having small road clearance on the worn-down roads of IT City.
Submitted Solution:
```
ans = 0
n = int(input())
for i in range(1,n):
p = 2*n-2-i-n+1
q = i-1
if p >= 1:
p = 3 * (4**(p-1))
else:
p = 1
if q >= 1:
q = 3 * (4**(q-1))
else:
q = 1
ans += 4*p*q
print(ans)
``` | instruction | 0 | 4,627 | 1 | 9,254 |
Yes | output | 1 | 4,627 | 1 | 9,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To quickly hire highly skilled specialists one of the new IT City companies made an unprecedented move. Every employee was granted a car, and an employee can choose one of four different car makes.
The parking lot before the office consists of one line of (2n - 2) parking spaces. Unfortunately the total number of cars is greater than the parking lot capacity. Furthermore even amount of cars of each make is greater than the amount of parking spaces! That's why there are no free spaces on the parking lot ever.
Looking on the straight line of cars the company CEO thought that parking lot would be more beautiful if it contained exactly n successive cars of the same make. Help the CEO determine the number of ways to fill the parking lot this way.
Input
The only line of the input contains one integer n (3 ≤ n ≤ 30) — the amount of successive cars of the same make.
Output
Output one integer — the number of ways to fill the parking lot by cars of four makes using the described way.
Examples
Input
3
Output
24
Note
Let's denote car makes in the following way: A — Aston Martin, B — Bentley, M — Mercedes-Maybach, Z — Zaporozhets. For n = 3 there are the following appropriate ways to fill the parking lot: AAAB AAAM AAAZ ABBB AMMM AZZZ BBBA BBBM BBBZ BAAA BMMM BZZZ MMMA MMMB MMMZ MAAA MBBB MZZZ ZZZA ZZZB ZZZM ZAAA ZBBB ZMMM
Originally it was planned to grant sport cars of Ferrari, Lamborghini, Maserati and Bugatti makes but this idea was renounced because it is impossible to drive these cars having small road clearance on the worn-down roads of IT City.
Submitted Solution:
```
n=int(input());print(int(2*4*3*pow(4,n-3)+(n-3)*4*3*3*pow(4,n-4)))
``` | instruction | 0 | 4,628 | 1 | 9,256 |
Yes | output | 1 | 4,628 | 1 | 9,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To quickly hire highly skilled specialists one of the new IT City companies made an unprecedented move. Every employee was granted a car, and an employee can choose one of four different car makes.
The parking lot before the office consists of one line of (2n - 2) parking spaces. Unfortunately the total number of cars is greater than the parking lot capacity. Furthermore even amount of cars of each make is greater than the amount of parking spaces! That's why there are no free spaces on the parking lot ever.
Looking on the straight line of cars the company CEO thought that parking lot would be more beautiful if it contained exactly n successive cars of the same make. Help the CEO determine the number of ways to fill the parking lot this way.
Input
The only line of the input contains one integer n (3 ≤ n ≤ 30) — the amount of successive cars of the same make.
Output
Output one integer — the number of ways to fill the parking lot by cars of four makes using the described way.
Examples
Input
3
Output
24
Note
Let's denote car makes in the following way: A — Aston Martin, B — Bentley, M — Mercedes-Maybach, Z — Zaporozhets. For n = 3 there are the following appropriate ways to fill the parking lot: AAAB AAAM AAAZ ABBB AMMM AZZZ BBBA BBBM BBBZ BAAA BMMM BZZZ MMMA MMMB MMMZ MAAA MBBB MZZZ ZZZA ZZZB ZZZM ZAAA ZBBB ZMMM
Originally it was planned to grant sport cars of Ferrari, Lamborghini, Maserati and Bugatti makes but this idea was renounced because it is impossible to drive these cars having small road clearance on the worn-down roads of IT City.
Submitted Solution:
```
n=int(input())
n=n-3
print(3*4**n*(8+3*n))
``` | instruction | 0 | 4,629 | 1 | 9,258 |
Yes | output | 1 | 4,629 | 1 | 9,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To quickly hire highly skilled specialists one of the new IT City companies made an unprecedented move. Every employee was granted a car, and an employee can choose one of four different car makes.
The parking lot before the office consists of one line of (2n - 2) parking spaces. Unfortunately the total number of cars is greater than the parking lot capacity. Furthermore even amount of cars of each make is greater than the amount of parking spaces! That's why there are no free spaces on the parking lot ever.
Looking on the straight line of cars the company CEO thought that parking lot would be more beautiful if it contained exactly n successive cars of the same make. Help the CEO determine the number of ways to fill the parking lot this way.
Input
The only line of the input contains one integer n (3 ≤ n ≤ 30) — the amount of successive cars of the same make.
Output
Output one integer — the number of ways to fill the parking lot by cars of four makes using the described way.
Examples
Input
3
Output
24
Note
Let's denote car makes in the following way: A — Aston Martin, B — Bentley, M — Mercedes-Maybach, Z — Zaporozhets. For n = 3 there are the following appropriate ways to fill the parking lot: AAAB AAAM AAAZ ABBB AMMM AZZZ BBBA BBBM BBBZ BAAA BMMM BZZZ MMMA MMMB MMMZ MAAA MBBB MZZZ ZZZA ZZZB ZZZM ZAAA ZBBB ZMMM
Originally it was planned to grant sport cars of Ferrari, Lamborghini, Maserati and Bugatti makes but this idea was renounced because it is impossible to drive these cars having small road clearance on the worn-down roads of IT City.
Submitted Solution:
```
n=int(input())
if n == 3:
print(24)
else:
print((2*3*4**(n-3)*4) + ((n-3)*9*4**(n-4)*4))
``` | instruction | 0 | 4,630 | 1 | 9,260 |
Yes | output | 1 | 4,630 | 1 | 9,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To quickly hire highly skilled specialists one of the new IT City companies made an unprecedented move. Every employee was granted a car, and an employee can choose one of four different car makes.
The parking lot before the office consists of one line of (2n - 2) parking spaces. Unfortunately the total number of cars is greater than the parking lot capacity. Furthermore even amount of cars of each make is greater than the amount of parking spaces! That's why there are no free spaces on the parking lot ever.
Looking on the straight line of cars the company CEO thought that parking lot would be more beautiful if it contained exactly n successive cars of the same make. Help the CEO determine the number of ways to fill the parking lot this way.
Input
The only line of the input contains one integer n (3 ≤ n ≤ 30) — the amount of successive cars of the same make.
Output
Output one integer — the number of ways to fill the parking lot by cars of four makes using the described way.
Examples
Input
3
Output
24
Note
Let's denote car makes in the following way: A — Aston Martin, B — Bentley, M — Mercedes-Maybach, Z — Zaporozhets. For n = 3 there are the following appropriate ways to fill the parking lot: AAAB AAAM AAAZ ABBB AMMM AZZZ BBBA BBBM BBBZ BAAA BMMM BZZZ MMMA MMMB MMMZ MAAA MBBB MZZZ ZZZA ZZZB ZZZM ZAAA ZBBB ZMMM
Originally it was planned to grant sport cars of Ferrari, Lamborghini, Maserati and Bugatti makes but this idea was renounced because it is impossible to drive these cars having small road clearance on the worn-down roads of IT City.
Submitted Solution:
```
n = int(input())
print((n - 3) * (2 * n - 3) ** 2 * (2 * n - 2) ** (n - 3) + 2 * (2 * n - 3) * (2 * n - 2) ** (n - 2))
``` | instruction | 0 | 4,631 | 1 | 9,262 |
No | output | 1 | 4,631 | 1 | 9,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To quickly hire highly skilled specialists one of the new IT City companies made an unprecedented move. Every employee was granted a car, and an employee can choose one of four different car makes.
The parking lot before the office consists of one line of (2n - 2) parking spaces. Unfortunately the total number of cars is greater than the parking lot capacity. Furthermore even amount of cars of each make is greater than the amount of parking spaces! That's why there are no free spaces on the parking lot ever.
Looking on the straight line of cars the company CEO thought that parking lot would be more beautiful if it contained exactly n successive cars of the same make. Help the CEO determine the number of ways to fill the parking lot this way.
Input
The only line of the input contains one integer n (3 ≤ n ≤ 30) — the amount of successive cars of the same make.
Output
Output one integer — the number of ways to fill the parking lot by cars of four makes using the described way.
Examples
Input
3
Output
24
Note
Let's denote car makes in the following way: A — Aston Martin, B — Bentley, M — Mercedes-Maybach, Z — Zaporozhets. For n = 3 there are the following appropriate ways to fill the parking lot: AAAB AAAM AAAZ ABBB AMMM AZZZ BBBA BBBM BBBZ BAAA BMMM BZZZ MMMA MMMB MMMZ MAAA MBBB MZZZ ZZZA ZZZB ZZZM ZAAA ZBBB ZMMM
Originally it was planned to grant sport cars of Ferrari, Lamborghini, Maserati and Bugatti makes but this idea was renounced because it is impossible to drive these cars having small road clearance on the worn-down roads of IT City.
Submitted Solution:
```
#with recursion
def binpow(a,n,m):
if n==0:
return(1)
x = binpow(a,n//2,m)
x=(x*x)%m
if (n%2==1):
x = (x*a)%m
return(x)
#without recursion
def binpow1(a,n,m):
r = 1
while(n>0):
if (n&1):
r = (r*a)%m
a = (a*a)%m
n=n>>1
return(r)
n = int(input())
ans = 0
if n>3:
ans += 36*pow(4,n-4)
ans += 24*pow(4,n-3)
print(ans)
``` | instruction | 0 | 4,632 | 1 | 9,264 |
No | output | 1 | 4,632 | 1 | 9,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To quickly hire highly skilled specialists one of the new IT City companies made an unprecedented move. Every employee was granted a car, and an employee can choose one of four different car makes.
The parking lot before the office consists of one line of (2n - 2) parking spaces. Unfortunately the total number of cars is greater than the parking lot capacity. Furthermore even amount of cars of each make is greater than the amount of parking spaces! That's why there are no free spaces on the parking lot ever.
Looking on the straight line of cars the company CEO thought that parking lot would be more beautiful if it contained exactly n successive cars of the same make. Help the CEO determine the number of ways to fill the parking lot this way.
Input
The only line of the input contains one integer n (3 ≤ n ≤ 30) — the amount of successive cars of the same make.
Output
Output one integer — the number of ways to fill the parking lot by cars of four makes using the described way.
Examples
Input
3
Output
24
Note
Let's denote car makes in the following way: A — Aston Martin, B — Bentley, M — Mercedes-Maybach, Z — Zaporozhets. For n = 3 there are the following appropriate ways to fill the parking lot: AAAB AAAM AAAZ ABBB AMMM AZZZ BBBA BBBM BBBZ BAAA BMMM BZZZ MMMA MMMB MMMZ MAAA MBBB MZZZ ZZZA ZZZB ZZZM ZAAA ZBBB ZMMM
Originally it was planned to grant sport cars of Ferrari, Lamborghini, Maserati and Bugatti makes but this idea was renounced because it is impossible to drive these cars having small road clearance on the worn-down roads of IT City.
Submitted Solution:
```
n=int(input())
print(3*(3*(n-1))*pow(2,2*n-6))
``` | instruction | 0 | 4,633 | 1 | 9,266 |
No | output | 1 | 4,633 | 1 | 9,267 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To quickly hire highly skilled specialists one of the new IT City companies made an unprecedented move. Every employee was granted a car, and an employee can choose one of four different car makes.
The parking lot before the office consists of one line of (2n - 2) parking spaces. Unfortunately the total number of cars is greater than the parking lot capacity. Furthermore even amount of cars of each make is greater than the amount of parking spaces! That's why there are no free spaces on the parking lot ever.
Looking on the straight line of cars the company CEO thought that parking lot would be more beautiful if it contained exactly n successive cars of the same make. Help the CEO determine the number of ways to fill the parking lot this way.
Input
The only line of the input contains one integer n (3 ≤ n ≤ 30) — the amount of successive cars of the same make.
Output
Output one integer — the number of ways to fill the parking lot by cars of four makes using the described way.
Examples
Input
3
Output
24
Note
Let's denote car makes in the following way: A — Aston Martin, B — Bentley, M — Mercedes-Maybach, Z — Zaporozhets. For n = 3 there are the following appropriate ways to fill the parking lot: AAAB AAAM AAAZ ABBB AMMM AZZZ BBBA BBBM BBBZ BAAA BMMM BZZZ MMMA MMMB MMMZ MAAA MBBB MZZZ ZZZA ZZZB ZZZM ZAAA ZBBB ZMMM
Originally it was planned to grant sport cars of Ferrari, Lamborghini, Maserati and Bugatti makes but this idea was renounced because it is impossible to drive these cars having small road clearance on the worn-down roads of IT City.
Submitted Solution:
```
n = int(input().strip())
r = 24 * 4 ** (n - 3)
if r > 3:
r += (n - 3) * 36 * 4 ** (n - 4)
print(r)
``` | instruction | 0 | 4,634 | 1 | 9,268 |
No | output | 1 | 4,634 | 1 | 9,269 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999 | instruction | 0 | 4,859 | 1 | 9,718 |
"Correct Solution:
```
import fractions
n,x=map(int,input().split())
l=list(map(int,input().split()))
m=[];
for i in l:
m.append(abs(i-x))
n=m.pop(0)
for j in m:
n=fractions.gcd(n,j)
print(n)
``` | output | 1 | 4,859 | 1 | 9,719 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999 | instruction | 0 | 4,860 | 1 | 9,720 |
"Correct Solution:
```
import fractions
N, X = map(int, input().split())
x = list(map(int, input().split()))
t = abs(x[0] - X)
for a in x:
t = fractions.gcd(t, abs(a - X))
print(t)
``` | output | 1 | 4,860 | 1 | 9,721 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999 | instruction | 0 | 4,861 | 1 | 9,722 |
"Correct Solution:
```
from math import gcd
from functools import reduce
_, X = map(int, input().split())
print(reduce(gcd, (abs(i - X) for i in set(map(int, input().split())))))
``` | output | 1 | 4,861 | 1 | 9,723 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999 | instruction | 0 | 4,862 | 1 | 9,724 |
"Correct Solution:
```
#!/usr/bin/env python3
from functools import reduce
from math import gcd
n, X, *x = map(int, open(0).read().split())
x = [abs(i - X) for i in x]
print(reduce(gcd, x))
``` | output | 1 | 4,862 | 1 | 9,725 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999 | instruction | 0 | 4,863 | 1 | 9,726 |
"Correct Solution:
```
n,x,*l=map(int,open(0).read().split())
from math import *
a=0
for i in l: a=gcd(a,abs(i-x))
print(a)
``` | output | 1 | 4,863 | 1 | 9,727 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999 | instruction | 0 | 4,864 | 1 | 9,728 |
"Correct Solution:
```
from fractions import gcd
N, X = map(int, input().split())
x = map(int, input().split())
ans = 0
for i in x:
ans = gcd(ans, abs(X-i))
print(ans)
``` | output | 1 | 4,864 | 1 | 9,729 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999 | instruction | 0 | 4,865 | 1 | 9,730 |
"Correct Solution:
```
from fractions import gcd
from functools import reduce
_, X = map(int, input().split())
print(reduce(gcd, (abs(X - i) for i in map(int, input().split()))))
``` | output | 1 | 4,865 | 1 | 9,731 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999 | instruction | 0 | 4,866 | 1 | 9,732 |
"Correct Solution:
```
from math import gcd
n, X = map(int, input().split())
xlst = list(map(int, input().split()))
ans = X - xlst[0]
for x in xlst:
ans = gcd(ans, X - x)
print(ans)
``` | output | 1 | 4,866 | 1 | 9,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999
Submitted Solution:
```
import fractions
from functools import reduce
N,X = map(int,input().split())
l = list(map(lambda x: abs(int(x)-X),input().split()))
print(reduce(fractions.gcd,l))
``` | instruction | 0 | 4,867 | 1 | 9,734 |
Yes | output | 1 | 4,867 | 1 | 9,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999
Submitted Solution:
```
from fractions import*
n,x,*l=map(int,open(0).read().split())
g=abs(l[0]-x)
for a,b in zip([x]+l,l):
g=gcd(g,abs(b-a))
print(g)
``` | instruction | 0 | 4,868 | 1 | 9,736 |
Yes | output | 1 | 4,868 | 1 | 9,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999
Submitted Solution:
```
N, X = map(int, input().split())
x = list(map(int, input().split()))
ans = abs(x[0]-X)
import fractions
for i in range(1,N):
ans = fractions.gcd(abs(x[i]-X),ans)
print(ans)
``` | instruction | 0 | 4,869 | 1 | 9,738 |
Yes | output | 1 | 4,869 | 1 | 9,739 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.