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 a correct Python 3 solution for this coding contest problem.
Railroad Trip
There are N cities in the JOI country, numbered 1, 2, ..., and N, respectively. In addition, there are N β 1 railroads, which are numbered 1, 2, ..., and N β 1, respectively. The railroad i (1 β€ i β€ N β 1) connects the city i and the city i + 1 in both directions.
There are two ways to get on the JOI railway, one is to use a paper ticket and the other is to use an IC card.
* The fare for boarding the railway i with a paper ticket is Ai yen.
* The fare for boarding the railway i with an IC card is Bi Yen. However, in order to board the railway i with an IC card, it is necessary to purchase an IC card that can be used with the railway i in advance. It costs Ci yen to purchase an IC card that can be used on the railway i. Once purchased, the IC card can be used any number of times.
Since the IC card makes it easier to process the amount, the fare for boarding with an IC card is cheaper than the fare for boarding with a paper ticket. That is, for i = 1, 2, ..., N β 1, Ai> Bi holds. Since the specifications of IC cards are all different for each railroad, the IC card that can be used on railroad i cannot be used on other railroads for any i.
You decide to travel all over the JOI country. We plan to start from the city P1 and visit the cities in the order of P2, P3, ..., PM. The trip consists of an M-1 day journey. On day j (1 β€ j β€ M β 1), travel by rail from city Pj to city Pj + 1. At this time, it may move by connecting several railroads. You may also visit the same city more than once. The railroads in JOI are so fast that you can travel from any city to any city in a day.
You currently do not have an IC card for any railroad. You want to purchase some railroad IC cards in advance and minimize the cost of this trip, that is, the sum of the IC card purchase cost and the railroad fare you boarded.
Task
Given the number of cities in the JOI country, the itinerary of the trip, and the fare and IC card price for each railroad in the JOI country. At this time, create a program to find the minimum amount of money required for the trip.
input
Read the following data from standard input.
* On the first line, integers N and M are written with blanks as delimiters. Each of these represents that there are N cities in the JOI country and the trip consists of an M-1 day journey.
* On the second line, M integers P1, P2, ..., PM are written with a space as a delimiter. These represent the rail movement from city Pj to city Pj + 1 on day j (1 β€ j β€ M β 1).
* On the i-th line (1 β€ i β€ N β 1) of the following N β 1 lines, three integers Ai, Bi, and Ci are written separated by blanks. These indicate that the fare when boarding the railway i with a paper ticket is Ai yen, the fare when boarding with an IC card is Bi yen, and the amount of the IC card that can be used on the railway i is Ci yen.
output
On the standard output, output an integer that represents the minimum value of the travel amount in yen on one line.
Limits
All input data satisfy the following conditions.
* 2 β€ N β€ 100 000.
* 2 β€ M β€ 100 000.
* 1 β€ Bi <Ai β€ 100 000 (1 β€ i β€ N β 1).
* 1 β€ Ci β€ 100 000 (1 β€ i β€ N β 1).
* 1 β€ Pj β€ N (1 β€ j β€ M).
* Pj β Pj + 1 (1 β€ j β€ M β 1).
Input / output example
Input example 1
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output example 1
550
In this case, the method to minimize the cost of travel is as follows.
* Purchase IC cards for Railroad 2 and Railroad 3. This costs 80 + 130 = 210 yen.
* On the first day, move from city 1 to city 2 using a paper ticket, and then move from city 2 to city 3 using an IC card. This costs 120 + 50 = 170 yen.
* On the second day, move from city 3 to city 2 using an IC card. This costs 50 yen.
* On the third day, move from city 2 to city 3 using an IC card, and then move from city 3 to city 4 using an IC card. This costs 50 + 70 = 120 yen.
When moving in this way, the total amount of money spent on the trip is 210 + 170 + 50 + 120 = 550 yen. Since this is the minimum, it outputs 550.
Input example 2
8 5
7 5 3 5 4
12 5 8
16 2 1
3 1 5
17 12 17
19 7 5
12 2 19
4 1 3
Output example 2
81
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output
550 | instruction | 0 | 101,123 | 1 | 202,246 |
"Correct Solution:
```
n,m=map(int,input().split())
u=[0]*n
a=list(map(int,input().split()))
b=a[0]-1
for x in a[1:]:
x-=1
u[max(b,x)]-=1
u[min(b,x)]+=1
b=x
ans=0
for i in range(n-1):
u[i+1]+=u[i]
d,b,c=map(int,input().split())
ans+=min(d*u[i],b*u[i]+c)
print(ans)
``` | output | 1 | 101,123 | 1 | 202,247 |
Provide a correct Python 3 solution for this coding contest problem.
Railroad Trip
There are N cities in the JOI country, numbered 1, 2, ..., and N, respectively. In addition, there are N β 1 railroads, which are numbered 1, 2, ..., and N β 1, respectively. The railroad i (1 β€ i β€ N β 1) connects the city i and the city i + 1 in both directions.
There are two ways to get on the JOI railway, one is to use a paper ticket and the other is to use an IC card.
* The fare for boarding the railway i with a paper ticket is Ai yen.
* The fare for boarding the railway i with an IC card is Bi Yen. However, in order to board the railway i with an IC card, it is necessary to purchase an IC card that can be used with the railway i in advance. It costs Ci yen to purchase an IC card that can be used on the railway i. Once purchased, the IC card can be used any number of times.
Since the IC card makes it easier to process the amount, the fare for boarding with an IC card is cheaper than the fare for boarding with a paper ticket. That is, for i = 1, 2, ..., N β 1, Ai> Bi holds. Since the specifications of IC cards are all different for each railroad, the IC card that can be used on railroad i cannot be used on other railroads for any i.
You decide to travel all over the JOI country. We plan to start from the city P1 and visit the cities in the order of P2, P3, ..., PM. The trip consists of an M-1 day journey. On day j (1 β€ j β€ M β 1), travel by rail from city Pj to city Pj + 1. At this time, it may move by connecting several railroads. You may also visit the same city more than once. The railroads in JOI are so fast that you can travel from any city to any city in a day.
You currently do not have an IC card for any railroad. You want to purchase some railroad IC cards in advance and minimize the cost of this trip, that is, the sum of the IC card purchase cost and the railroad fare you boarded.
Task
Given the number of cities in the JOI country, the itinerary of the trip, and the fare and IC card price for each railroad in the JOI country. At this time, create a program to find the minimum amount of money required for the trip.
input
Read the following data from standard input.
* On the first line, integers N and M are written with blanks as delimiters. Each of these represents that there are N cities in the JOI country and the trip consists of an M-1 day journey.
* On the second line, M integers P1, P2, ..., PM are written with a space as a delimiter. These represent the rail movement from city Pj to city Pj + 1 on day j (1 β€ j β€ M β 1).
* On the i-th line (1 β€ i β€ N β 1) of the following N β 1 lines, three integers Ai, Bi, and Ci are written separated by blanks. These indicate that the fare when boarding the railway i with a paper ticket is Ai yen, the fare when boarding with an IC card is Bi yen, and the amount of the IC card that can be used on the railway i is Ci yen.
output
On the standard output, output an integer that represents the minimum value of the travel amount in yen on one line.
Limits
All input data satisfy the following conditions.
* 2 β€ N β€ 100 000.
* 2 β€ M β€ 100 000.
* 1 β€ Bi <Ai β€ 100 000 (1 β€ i β€ N β 1).
* 1 β€ Ci β€ 100 000 (1 β€ i β€ N β 1).
* 1 β€ Pj β€ N (1 β€ j β€ M).
* Pj β Pj + 1 (1 β€ j β€ M β 1).
Input / output example
Input example 1
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output example 1
550
In this case, the method to minimize the cost of travel is as follows.
* Purchase IC cards for Railroad 2 and Railroad 3. This costs 80 + 130 = 210 yen.
* On the first day, move from city 1 to city 2 using a paper ticket, and then move from city 2 to city 3 using an IC card. This costs 120 + 50 = 170 yen.
* On the second day, move from city 3 to city 2 using an IC card. This costs 50 yen.
* On the third day, move from city 2 to city 3 using an IC card, and then move from city 3 to city 4 using an IC card. This costs 50 + 70 = 120 yen.
When moving in this way, the total amount of money spent on the trip is 210 + 170 + 50 + 120 = 550 yen. Since this is the minimum, it outputs 550.
Input example 2
8 5
7 5 3 5 4
12 5 8
16 2 1
3 1 5
17 12 17
19 7 5
12 2 19
4 1 3
Output example 2
81
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output
550 | instruction | 0 | 101,124 | 1 | 202,248 |
"Correct Solution:
```
# AOJ 0614: Railroad Trip
# Python3 2018.7.4 bal4u
import sys
from sys import stdin
input = stdin.readline
n, m = map(int, input().split())
p = list(map(int, input().split()))
tbl = []
for i in range(n-1):
a, b, c = map(int, input().split())
tbl.append((a, b, c))
f = [0]*n
for i in range(m-1):
u, v = p[i]-1, p[i+1]-1
if u > v: u, v = v, u
f[u] += 1
f[v] -= 1
for i in range(n-1): f[i+1] += f[i]
ans = 0
for i in range(n-1):
cash = tbl[i][0] * f[i]
ic = tbl[i][1] * f[i] + tbl[i][2]
ans += min(cash, ic)
print(ans)
``` | output | 1 | 101,124 | 1 | 202,249 |
Provide a correct Python 3 solution for this coding contest problem.
Railroad Trip
There are N cities in the JOI country, numbered 1, 2, ..., and N, respectively. In addition, there are N β 1 railroads, which are numbered 1, 2, ..., and N β 1, respectively. The railroad i (1 β€ i β€ N β 1) connects the city i and the city i + 1 in both directions.
There are two ways to get on the JOI railway, one is to use a paper ticket and the other is to use an IC card.
* The fare for boarding the railway i with a paper ticket is Ai yen.
* The fare for boarding the railway i with an IC card is Bi Yen. However, in order to board the railway i with an IC card, it is necessary to purchase an IC card that can be used with the railway i in advance. It costs Ci yen to purchase an IC card that can be used on the railway i. Once purchased, the IC card can be used any number of times.
Since the IC card makes it easier to process the amount, the fare for boarding with an IC card is cheaper than the fare for boarding with a paper ticket. That is, for i = 1, 2, ..., N β 1, Ai> Bi holds. Since the specifications of IC cards are all different for each railroad, the IC card that can be used on railroad i cannot be used on other railroads for any i.
You decide to travel all over the JOI country. We plan to start from the city P1 and visit the cities in the order of P2, P3, ..., PM. The trip consists of an M-1 day journey. On day j (1 β€ j β€ M β 1), travel by rail from city Pj to city Pj + 1. At this time, it may move by connecting several railroads. You may also visit the same city more than once. The railroads in JOI are so fast that you can travel from any city to any city in a day.
You currently do not have an IC card for any railroad. You want to purchase some railroad IC cards in advance and minimize the cost of this trip, that is, the sum of the IC card purchase cost and the railroad fare you boarded.
Task
Given the number of cities in the JOI country, the itinerary of the trip, and the fare and IC card price for each railroad in the JOI country. At this time, create a program to find the minimum amount of money required for the trip.
input
Read the following data from standard input.
* On the first line, integers N and M are written with blanks as delimiters. Each of these represents that there are N cities in the JOI country and the trip consists of an M-1 day journey.
* On the second line, M integers P1, P2, ..., PM are written with a space as a delimiter. These represent the rail movement from city Pj to city Pj + 1 on day j (1 β€ j β€ M β 1).
* On the i-th line (1 β€ i β€ N β 1) of the following N β 1 lines, three integers Ai, Bi, and Ci are written separated by blanks. These indicate that the fare when boarding the railway i with a paper ticket is Ai yen, the fare when boarding with an IC card is Bi yen, and the amount of the IC card that can be used on the railway i is Ci yen.
output
On the standard output, output an integer that represents the minimum value of the travel amount in yen on one line.
Limits
All input data satisfy the following conditions.
* 2 β€ N β€ 100 000.
* 2 β€ M β€ 100 000.
* 1 β€ Bi <Ai β€ 100 000 (1 β€ i β€ N β 1).
* 1 β€ Ci β€ 100 000 (1 β€ i β€ N β 1).
* 1 β€ Pj β€ N (1 β€ j β€ M).
* Pj β Pj + 1 (1 β€ j β€ M β 1).
Input / output example
Input example 1
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output example 1
550
In this case, the method to minimize the cost of travel is as follows.
* Purchase IC cards for Railroad 2 and Railroad 3. This costs 80 + 130 = 210 yen.
* On the first day, move from city 1 to city 2 using a paper ticket, and then move from city 2 to city 3 using an IC card. This costs 120 + 50 = 170 yen.
* On the second day, move from city 3 to city 2 using an IC card. This costs 50 yen.
* On the third day, move from city 2 to city 3 using an IC card, and then move from city 3 to city 4 using an IC card. This costs 50 + 70 = 120 yen.
When moving in this way, the total amount of money spent on the trip is 210 + 170 + 50 + 120 = 550 yen. Since this is the minimum, it outputs 550.
Input example 2
8 5
7 5 3 5 4
12 5 8
16 2 1
3 1 5
17 12 17
19 7 5
12 2 19
4 1 3
Output example 2
81
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output
550 | instruction | 0 | 101,125 | 1 | 202,250 |
"Correct Solution:
```
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
n, m = map(int, input().split())
bit = Bit(n + 1)
cities = map(int, input().split())
prev = next(cities)
for cur in cities:
if prev < cur:
bit.add(prev, 1)
bit.add(cur, -1)
else:
bit.add(cur, 1)
bit.add(prev, -1)
prev = cur
ans = 0
for i in range(1, n):
a, b, c = map(int, input().split())
bep = c // (a - b)
cnt = bit.sum(i)
if cnt > bep:
ans += b * cnt + c
else:
ans += a * cnt
print(ans)
``` | output | 1 | 101,125 | 1 | 202,251 |
Provide a correct Python 3 solution for this coding contest problem.
Railroad Trip
There are N cities in the JOI country, numbered 1, 2, ..., and N, respectively. In addition, there are N β 1 railroads, which are numbered 1, 2, ..., and N β 1, respectively. The railroad i (1 β€ i β€ N β 1) connects the city i and the city i + 1 in both directions.
There are two ways to get on the JOI railway, one is to use a paper ticket and the other is to use an IC card.
* The fare for boarding the railway i with a paper ticket is Ai yen.
* The fare for boarding the railway i with an IC card is Bi Yen. However, in order to board the railway i with an IC card, it is necessary to purchase an IC card that can be used with the railway i in advance. It costs Ci yen to purchase an IC card that can be used on the railway i. Once purchased, the IC card can be used any number of times.
Since the IC card makes it easier to process the amount, the fare for boarding with an IC card is cheaper than the fare for boarding with a paper ticket. That is, for i = 1, 2, ..., N β 1, Ai> Bi holds. Since the specifications of IC cards are all different for each railroad, the IC card that can be used on railroad i cannot be used on other railroads for any i.
You decide to travel all over the JOI country. We plan to start from the city P1 and visit the cities in the order of P2, P3, ..., PM. The trip consists of an M-1 day journey. On day j (1 β€ j β€ M β 1), travel by rail from city Pj to city Pj + 1. At this time, it may move by connecting several railroads. You may also visit the same city more than once. The railroads in JOI are so fast that you can travel from any city to any city in a day.
You currently do not have an IC card for any railroad. You want to purchase some railroad IC cards in advance and minimize the cost of this trip, that is, the sum of the IC card purchase cost and the railroad fare you boarded.
Task
Given the number of cities in the JOI country, the itinerary of the trip, and the fare and IC card price for each railroad in the JOI country. At this time, create a program to find the minimum amount of money required for the trip.
input
Read the following data from standard input.
* On the first line, integers N and M are written with blanks as delimiters. Each of these represents that there are N cities in the JOI country and the trip consists of an M-1 day journey.
* On the second line, M integers P1, P2, ..., PM are written with a space as a delimiter. These represent the rail movement from city Pj to city Pj + 1 on day j (1 β€ j β€ M β 1).
* On the i-th line (1 β€ i β€ N β 1) of the following N β 1 lines, three integers Ai, Bi, and Ci are written separated by blanks. These indicate that the fare when boarding the railway i with a paper ticket is Ai yen, the fare when boarding with an IC card is Bi yen, and the amount of the IC card that can be used on the railway i is Ci yen.
output
On the standard output, output an integer that represents the minimum value of the travel amount in yen on one line.
Limits
All input data satisfy the following conditions.
* 2 β€ N β€ 100 000.
* 2 β€ M β€ 100 000.
* 1 β€ Bi <Ai β€ 100 000 (1 β€ i β€ N β 1).
* 1 β€ Ci β€ 100 000 (1 β€ i β€ N β 1).
* 1 β€ Pj β€ N (1 β€ j β€ M).
* Pj β Pj + 1 (1 β€ j β€ M β 1).
Input / output example
Input example 1
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output example 1
550
In this case, the method to minimize the cost of travel is as follows.
* Purchase IC cards for Railroad 2 and Railroad 3. This costs 80 + 130 = 210 yen.
* On the first day, move from city 1 to city 2 using a paper ticket, and then move from city 2 to city 3 using an IC card. This costs 120 + 50 = 170 yen.
* On the second day, move from city 3 to city 2 using an IC card. This costs 50 yen.
* On the third day, move from city 2 to city 3 using an IC card, and then move from city 3 to city 4 using an IC card. This costs 50 + 70 = 120 yen.
When moving in this way, the total amount of money spent on the trip is 210 + 170 + 50 + 120 = 550 yen. Since this is the minimum, it outputs 550.
Input example 2
8 5
7 5 3 5 4
12 5 8
16 2 1
3 1 5
17 12 17
19 7 5
12 2 19
4 1 3
Output example 2
81
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output
550 | instruction | 0 | 101,126 | 1 | 202,252 |
"Correct Solution:
```
from itertools import accumulate
n, m = map(int, input().split())
cnts = [0] * (n + 1)
cities = map(int, input().split())
prev = next(cities)
for cur in cities:
if prev < cur:
cnts[prev] += 1
cnts[cur] -= 1
else:
cnts[cur] += 1
cnts[prev] -= 1
prev = cur
cnts = list(accumulate(cnts))
ans = 0
for i in range(1, n):
a, b, c = map(int, input().split())
bep = c // (a - b)
cnt = cnts[i]
if cnt > bep:
ans += b * cnt + c
else:
ans += a * cnt
print(ans)
``` | output | 1 | 101,126 | 1 | 202,253 |
Provide a correct Python 3 solution for this coding contest problem.
Railroad Trip
There are N cities in the JOI country, numbered 1, 2, ..., and N, respectively. In addition, there are N β 1 railroads, which are numbered 1, 2, ..., and N β 1, respectively. The railroad i (1 β€ i β€ N β 1) connects the city i and the city i + 1 in both directions.
There are two ways to get on the JOI railway, one is to use a paper ticket and the other is to use an IC card.
* The fare for boarding the railway i with a paper ticket is Ai yen.
* The fare for boarding the railway i with an IC card is Bi Yen. However, in order to board the railway i with an IC card, it is necessary to purchase an IC card that can be used with the railway i in advance. It costs Ci yen to purchase an IC card that can be used on the railway i. Once purchased, the IC card can be used any number of times.
Since the IC card makes it easier to process the amount, the fare for boarding with an IC card is cheaper than the fare for boarding with a paper ticket. That is, for i = 1, 2, ..., N β 1, Ai> Bi holds. Since the specifications of IC cards are all different for each railroad, the IC card that can be used on railroad i cannot be used on other railroads for any i.
You decide to travel all over the JOI country. We plan to start from the city P1 and visit the cities in the order of P2, P3, ..., PM. The trip consists of an M-1 day journey. On day j (1 β€ j β€ M β 1), travel by rail from city Pj to city Pj + 1. At this time, it may move by connecting several railroads. You may also visit the same city more than once. The railroads in JOI are so fast that you can travel from any city to any city in a day.
You currently do not have an IC card for any railroad. You want to purchase some railroad IC cards in advance and minimize the cost of this trip, that is, the sum of the IC card purchase cost and the railroad fare you boarded.
Task
Given the number of cities in the JOI country, the itinerary of the trip, and the fare and IC card price for each railroad in the JOI country. At this time, create a program to find the minimum amount of money required for the trip.
input
Read the following data from standard input.
* On the first line, integers N and M are written with blanks as delimiters. Each of these represents that there are N cities in the JOI country and the trip consists of an M-1 day journey.
* On the second line, M integers P1, P2, ..., PM are written with a space as a delimiter. These represent the rail movement from city Pj to city Pj + 1 on day j (1 β€ j β€ M β 1).
* On the i-th line (1 β€ i β€ N β 1) of the following N β 1 lines, three integers Ai, Bi, and Ci are written separated by blanks. These indicate that the fare when boarding the railway i with a paper ticket is Ai yen, the fare when boarding with an IC card is Bi yen, and the amount of the IC card that can be used on the railway i is Ci yen.
output
On the standard output, output an integer that represents the minimum value of the travel amount in yen on one line.
Limits
All input data satisfy the following conditions.
* 2 β€ N β€ 100 000.
* 2 β€ M β€ 100 000.
* 1 β€ Bi <Ai β€ 100 000 (1 β€ i β€ N β 1).
* 1 β€ Ci β€ 100 000 (1 β€ i β€ N β 1).
* 1 β€ Pj β€ N (1 β€ j β€ M).
* Pj β Pj + 1 (1 β€ j β€ M β 1).
Input / output example
Input example 1
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output example 1
550
In this case, the method to minimize the cost of travel is as follows.
* Purchase IC cards for Railroad 2 and Railroad 3. This costs 80 + 130 = 210 yen.
* On the first day, move from city 1 to city 2 using a paper ticket, and then move from city 2 to city 3 using an IC card. This costs 120 + 50 = 170 yen.
* On the second day, move from city 3 to city 2 using an IC card. This costs 50 yen.
* On the third day, move from city 2 to city 3 using an IC card, and then move from city 3 to city 4 using an IC card. This costs 50 + 70 = 120 yen.
When moving in this way, the total amount of money spent on the trip is 210 + 170 + 50 + 120 = 550 yen. Since this is the minimum, it outputs 550.
Input example 2
8 5
7 5 3 5 4
12 5 8
16 2 1
3 1 5
17 12 17
19 7 5
12 2 19
4 1 3
Output example 2
81
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output
550 | instruction | 0 | 101,127 | 1 | 202,254 |
"Correct Solution:
```
import itertools
def main():
n, m = map(int, input().split())
plst = tuple(map(int, input().split()))
abclst = [tuple(map(int, input().split())) for _ in range(n - 1)]
sec = [0] * n
for pi, pi1 in zip(plst, plst[1:]):
p1, p2 = min(pi, pi1) - 1, max(pi, pi1) - 1
sec[p1] += 1
sec[p2] -= 1
sec = tuple(itertools.accumulate(sec))
ans = 0
for i in range(n - 1):
a, b, c = abclst[i]
s = sec[i]
ans += min(a * s, b * s + c)
print(ans)
main()
``` | output | 1 | 101,127 | 1 | 202,255 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vanya walks late at night along a straight street of length l, lit by n lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the point l. Then the i-th lantern is at the point ai. The lantern lights all points of the street that are at the distance of at most d from it, where d is some positive number, common for all lanterns.
Vanya wonders: what is the minimum light radius d should the lanterns have to light the whole street?
Input
The first line contains two integers n, l (1 β€ n β€ 1000, 1 β€ l β€ 109) β the number of lanterns and the length of the street respectively.
The next line contains n integers ai (0 β€ ai β€ l). Multiple lanterns can be located at the same point. The lanterns may be located at the ends of the street.
Output
Print the minimum light radius d, needed to light the whole street. The answer will be considered correct if its absolute or relative error doesn't exceed 10 - 9.
Examples
Input
7 15
15 5 3 7 9 14 0
Output
2.5000000000
Input
2 5
2 5
Output
2.0000000000
Note
Consider the second sample. At d = 2 the first lantern will light the segment [0, 4] of the street, and the second lantern will light segment [3, 5]. Thus, the whole street will be lit. | instruction | 0 | 101,561 | 1 | 203,122 |
Tags: binary search, implementation, math, sortings
Correct Solution:
```
nl = list(map(int, input().split()))
n = nl[0]
l = nl[1]
a = list(map(int, input().split()))
a.sort()
last = 0
max_dist = max(a[0], l - a[-1])
for elem in a:
if (elem - last) / 2 > max_dist:
max_dist = (elem - last) / 2
last = elem
print(max_dist)
``` | output | 1 | 101,561 | 1 | 203,123 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vanya walks late at night along a straight street of length l, lit by n lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the point l. Then the i-th lantern is at the point ai. The lantern lights all points of the street that are at the distance of at most d from it, where d is some positive number, common for all lanterns.
Vanya wonders: what is the minimum light radius d should the lanterns have to light the whole street?
Input
The first line contains two integers n, l (1 β€ n β€ 1000, 1 β€ l β€ 109) β the number of lanterns and the length of the street respectively.
The next line contains n integers ai (0 β€ ai β€ l). Multiple lanterns can be located at the same point. The lanterns may be located at the ends of the street.
Output
Print the minimum light radius d, needed to light the whole street. The answer will be considered correct if its absolute or relative error doesn't exceed 10 - 9.
Examples
Input
7 15
15 5 3 7 9 14 0
Output
2.5000000000
Input
2 5
2 5
Output
2.0000000000
Note
Consider the second sample. At d = 2 the first lantern will light the segment [0, 4] of the street, and the second lantern will light segment [3, 5]. Thus, the whole street will be lit. | instruction | 0 | 101,562 | 1 | 203,124 |
Tags: binary search, implementation, math, sortings
Correct Solution:
```
# You lost the game.
n, l = map(int, input().split())
L = list(map(int, input().split()))
L.sort()
L = [-L[0]]+L+[2*l-L[n-1]]
r = 0
for i in range(n+1):
if (L[i+1]-L[i])/2>r:
r = (L[i+1]-L[i])/2
print(r)
``` | output | 1 | 101,562 | 1 | 203,125 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vanya walks late at night along a straight street of length l, lit by n lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the point l. Then the i-th lantern is at the point ai. The lantern lights all points of the street that are at the distance of at most d from it, where d is some positive number, common for all lanterns.
Vanya wonders: what is the minimum light radius d should the lanterns have to light the whole street?
Input
The first line contains two integers n, l (1 β€ n β€ 1000, 1 β€ l β€ 109) β the number of lanterns and the length of the street respectively.
The next line contains n integers ai (0 β€ ai β€ l). Multiple lanterns can be located at the same point. The lanterns may be located at the ends of the street.
Output
Print the minimum light radius d, needed to light the whole street. The answer will be considered correct if its absolute or relative error doesn't exceed 10 - 9.
Examples
Input
7 15
15 5 3 7 9 14 0
Output
2.5000000000
Input
2 5
2 5
Output
2.0000000000
Note
Consider the second sample. At d = 2 the first lantern will light the segment [0, 4] of the street, and the second lantern will light segment [3, 5]. Thus, the whole street will be lit. | instruction | 0 | 101,563 | 1 | 203,126 |
Tags: binary search, implementation, math, sortings
Correct Solution:
```
n, l = map (int, input().split())
a = sorted(map(int, input().split()))
gap = 0
#print(max([a[0], l - a[n-1]] + [(a[i+1]-a[i])/2 for i in range (n-1)]))
for i in range(n-1):
if gap < (a[i+1]-a[i])/2:
gap = (a[i+1]-a[i])/2
print(max(a[0], gap, l - a[n-1]))
``` | output | 1 | 101,563 | 1 | 203,127 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vanya walks late at night along a straight street of length l, lit by n lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the point l. Then the i-th lantern is at the point ai. The lantern lights all points of the street that are at the distance of at most d from it, where d is some positive number, common for all lanterns.
Vanya wonders: what is the minimum light radius d should the lanterns have to light the whole street?
Input
The first line contains two integers n, l (1 β€ n β€ 1000, 1 β€ l β€ 109) β the number of lanterns and the length of the street respectively.
The next line contains n integers ai (0 β€ ai β€ l). Multiple lanterns can be located at the same point. The lanterns may be located at the ends of the street.
Output
Print the minimum light radius d, needed to light the whole street. The answer will be considered correct if its absolute or relative error doesn't exceed 10 - 9.
Examples
Input
7 15
15 5 3 7 9 14 0
Output
2.5000000000
Input
2 5
2 5
Output
2.0000000000
Note
Consider the second sample. At d = 2 the first lantern will light the segment [0, 4] of the street, and the second lantern will light segment [3, 5]. Thus, the whole street will be lit. | instruction | 0 | 101,564 | 1 | 203,128 |
Tags: binary search, implementation, math, sortings
Correct Solution:
```
n,l = map(int,input().split())
Line = [int(i) for i in input().split()]
Line.sort()
k = max(Line[0],l-Line[n-1])
for i in range(1,n):
p = Line[i]-Line[i-1]
k = max(k,p/2)
print(k)
``` | output | 1 | 101,564 | 1 | 203,129 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vanya walks late at night along a straight street of length l, lit by n lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the point l. Then the i-th lantern is at the point ai. The lantern lights all points of the street that are at the distance of at most d from it, where d is some positive number, common for all lanterns.
Vanya wonders: what is the minimum light radius d should the lanterns have to light the whole street?
Input
The first line contains two integers n, l (1 β€ n β€ 1000, 1 β€ l β€ 109) β the number of lanterns and the length of the street respectively.
The next line contains n integers ai (0 β€ ai β€ l). Multiple lanterns can be located at the same point. The lanterns may be located at the ends of the street.
Output
Print the minimum light radius d, needed to light the whole street. The answer will be considered correct if its absolute or relative error doesn't exceed 10 - 9.
Examples
Input
7 15
15 5 3 7 9 14 0
Output
2.5000000000
Input
2 5
2 5
Output
2.0000000000
Note
Consider the second sample. At d = 2 the first lantern will light the segment [0, 4] of the street, and the second lantern will light segment [3, 5]. Thus, the whole street will be lit. | instruction | 0 | 101,565 | 1 | 203,130 |
Tags: binary search, implementation, math, sortings
Correct Solution:
```
first = input().split(" ")
n = int(first[0])
l = int(first[1])
second = [int(s) for s in input().split(" ")]
second.sort()
d = 0
for i in range(len(second)-1):
d = max(second[i+1]-second[i], d)
if second[0] != 0 and second[-1] != l:
print(max(max(second[0], d/2), max(l-second[-1], d/2)))
elif second[0] != 0:
print(max(second[0], d/2))
elif second[-1] != l:
print(max(l-second[-1], d/2))
else:
print(d / 2)
``` | output | 1 | 101,565 | 1 | 203,131 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vanya walks late at night along a straight street of length l, lit by n lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the point l. Then the i-th lantern is at the point ai. The lantern lights all points of the street that are at the distance of at most d from it, where d is some positive number, common for all lanterns.
Vanya wonders: what is the minimum light radius d should the lanterns have to light the whole street?
Input
The first line contains two integers n, l (1 β€ n β€ 1000, 1 β€ l β€ 109) β the number of lanterns and the length of the street respectively.
The next line contains n integers ai (0 β€ ai β€ l). Multiple lanterns can be located at the same point. The lanterns may be located at the ends of the street.
Output
Print the minimum light radius d, needed to light the whole street. The answer will be considered correct if its absolute or relative error doesn't exceed 10 - 9.
Examples
Input
7 15
15 5 3 7 9 14 0
Output
2.5000000000
Input
2 5
2 5
Output
2.0000000000
Note
Consider the second sample. At d = 2 the first lantern will light the segment [0, 4] of the street, and the second lantern will light segment [3, 5]. Thus, the whole street will be lit. | instruction | 0 | 101,566 | 1 | 203,132 |
Tags: binary search, implementation, math, sortings
Correct Solution:
```
[n, l] = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.append(0)
a.append(l)
a.sort()
a = [a[i+1] - a[i] for i in range(len(a) - 1)]
a[0] = a[0] * 2
a[len(a) - 1] = a[len(a) - 1] * 2
print(max(a)/2)
``` | output | 1 | 101,566 | 1 | 203,133 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vanya walks late at night along a straight street of length l, lit by n lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the point l. Then the i-th lantern is at the point ai. The lantern lights all points of the street that are at the distance of at most d from it, where d is some positive number, common for all lanterns.
Vanya wonders: what is the minimum light radius d should the lanterns have to light the whole street?
Input
The first line contains two integers n, l (1 β€ n β€ 1000, 1 β€ l β€ 109) β the number of lanterns and the length of the street respectively.
The next line contains n integers ai (0 β€ ai β€ l). Multiple lanterns can be located at the same point. The lanterns may be located at the ends of the street.
Output
Print the minimum light radius d, needed to light the whole street. The answer will be considered correct if its absolute or relative error doesn't exceed 10 - 9.
Examples
Input
7 15
15 5 3 7 9 14 0
Output
2.5000000000
Input
2 5
2 5
Output
2.0000000000
Note
Consider the second sample. At d = 2 the first lantern will light the segment [0, 4] of the street, and the second lantern will light segment [3, 5]. Thus, the whole street will be lit. | instruction | 0 | 101,567 | 1 | 203,134 |
Tags: binary search, implementation, math, sortings
Correct Solution:
```
n,m=map(int,input().split())
l=sorted(list(map(int,input().split())))
r=[min(l),m-max(l)]
for i in range(1,len(l)):
r.append((l[i]-l[i-1])/2)
print(max(r))
``` | output | 1 | 101,567 | 1 | 203,135 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vanya walks late at night along a straight street of length l, lit by n lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the point l. Then the i-th lantern is at the point ai. The lantern lights all points of the street that are at the distance of at most d from it, where d is some positive number, common for all lanterns.
Vanya wonders: what is the minimum light radius d should the lanterns have to light the whole street?
Input
The first line contains two integers n, l (1 β€ n β€ 1000, 1 β€ l β€ 109) β the number of lanterns and the length of the street respectively.
The next line contains n integers ai (0 β€ ai β€ l). Multiple lanterns can be located at the same point. The lanterns may be located at the ends of the street.
Output
Print the minimum light radius d, needed to light the whole street. The answer will be considered correct if its absolute or relative error doesn't exceed 10 - 9.
Examples
Input
7 15
15 5 3 7 9 14 0
Output
2.5000000000
Input
2 5
2 5
Output
2.0000000000
Note
Consider the second sample. At d = 2 the first lantern will light the segment [0, 4] of the street, and the second lantern will light segment [3, 5]. Thus, the whole street will be lit. | instruction | 0 | 101,568 | 1 | 203,136 |
Tags: binary search, implementation, math, sortings
Correct Solution:
```
n,l=map(int,input().split())
A=list(map(int,input().split()))
B=sorted(A)
C=[]
if n==1:
print(max(A[0],l-A[0]))
else:
for i in range(1,n):
b=B[i]-B[i-1]
C.append(b)
c=max(C)
d=max(c,2*B[0],2*(l-B[n-1]))
print(float(d/2))
``` | output | 1 | 101,568 | 1 | 203,137 |
Provide a correct Python 3 solution for this coding contest problem.
problem
JOI City will hold a large-scale exposition.
There are two themes for this exposition, and each of the N exhibition facilities in JOI City will exhibit on one of the two themes.
The location of the facility is represented by plane coordinates (x, y). To move from the facility at position (x, y) to the facility at (x β², y β²), | x β x β² | + It takes only | y β y β² | (for the integer a, | a | represents the absolute value of a). To create a sense of unity within the same theme, and to be interested in only one theme. In order not to make people feel inconvenience, I would like to assign the theme so that the travel time between two facilities exhibiting on the same theme is as short as possible. Unless the same theme is assigned to all exhibition facilities. , How can you divide the theme.
Let M be the maximum travel time between two facilities exhibiting on the same theme. Create a program to find the minimum value of M given the locations of N exhibition facilities.
output
The output consists of only one line. Output the maximum value M of the maximum travel time between two facilities exhibiting on the same theme.
Input / output example
Input example 1
Five
0 0
Ten
-1 -2
0 1
-1 1
Output example 1
3
In this case, for example, one theme for the facility at coordinates (0, 0), (1, 0), (0, 1), and another theme for the facility at (β1, β2), (β1, 1). When one theme is assigned, the travel time between two facilities exhibiting on the same theme is all 3 or less. Since the travel time cannot be all 2 or less, 3 is output.
The above question sentences and the data used for the automatic referee are the question sentences created and published by the Japan Committee for Information Olympics and the test data for scoring.
input
The first line of input contains the number of facilities N (3 β€ N β€ 100000 = 105). The first line of input i + 1 (1 β€ i β€ N) represents the coordinates of each facility. The two integers xi, yi (| xi | β€ 100000 = 105, | yi | β€ 100000 = 105) are separated by blanks. This is where the coordinates of the i-th facility are (xi, yi). It means that there can be no more than one facility at the same coordinates.
Of the scoring data, 40% of the points are N β€ 2000.
Example
Input
5
0 0
1 0
-1 -2
0 1
-1 1
Output
3 | instruction | 0 | 101,990 | 1 | 203,980 |
"Correct Solution:
```
# AOJ 0552: Exposition
# Python3 2018.7.1 bal4u
import sys
from sys import stdin
input = stdin.readline
x, y = [], []
n = int(input())
for i in range(n):
a, b = map(int, input().split())
x.append(a+b)
y.append(a-b)
xmin, xmax = min(x), max(x)
ymin, ymax = min(y), max(y)
ans1 = ans2 = 0
for i in range(n):
d1 = max(x[i]-xmin, y[i]-ymin)
d2 = max(xmax-x[i], ymax-y[i])
ans1 = max(ans1, min(d1, d2))
d1 = max(x[i]-xmin, ymax-y[i])
d2 = max(xmax-x[i], y[i]-ymin)
ans2 = max(ans2, min(d1, d2))
print(min(ans1, ans2))
``` | output | 1 | 101,990 | 1 | 203,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Having problems with tram routes in the morning, Arkady decided to return home by metro. Fortunately for Arkady, there is only one metro line in the city.
Unfortunately for Arkady, the line is circular. It means that the stations are enumerated from 1 to n and there is a tunnel between any pair of consecutive stations as well as between the station 1 and the station n. Trains that go in clockwise direction visit the stations in order 1 β 2 β 3 β β¦ β n β 1 while the trains that go in the counter-clockwise direction visit the stations in the reverse order.
The stations that have numbers from 1 to m have interior mostly in red colors while the stations that have numbers from m + 1 to n have blue interior. Arkady entered the metro at station s and decided to use the following algorithm to choose his way home.
1. Initially he has a positive integer t in his mind.
2. If the current station has red interior, he takes a clockwise-directed train, otherwise he takes a counter-clockwise-directed train.
3. He rides exactly t stations on the train and leaves the train.
4. He decreases t by one. If t is still positive, he returns to step 2. Otherwise he exits the metro.
You have already realized that this algorithm most probably won't bring Arkady home. Find the station he will exit the metro at so that you can continue helping him.
Input
The first line contains two integers n and m (3 β€ n β€ 10^5, 1 β€ m < n) β the total number of stations and the number of stations that have red interior.
The second line contains two integers s and t (1 β€ s β€ n, 1 β€ t β€ 10^{12}) β the starting station and the initial value of t.
Output
Output the only integer β the station where Arkady will exit the metro.
Examples
Input
10 4
3 1
Output
4
Input
10 4
3 5
Output
4
Input
10543 437
5492 1947349
Output
438
Note
Consider the first example. There are 10 stations and the first 4 of them are red. Arkady starts at station 3 with value t = 1, so just rides 1 station in clockwise direction and ends up on the station 4.
In the second example the metro is same as in the first example, but Arkady starts at station 3 with value t = 5.
* It is a red station so he rides 5 stations in clockwise direction and leaves the train at station 8.
* It is a blue station, so he rides 4 stations in counter-clockwise direction and leaves at station 4.
* It is a red station, so he rides 3 stations in clockwise direction and leaves at station 7.
* It is a blue station, so he rides 2 stations in counter-clockwise direction and leaves at station 5.
* It is a blue station, so he rides 1 station in counter-clockwise direction and leaves at station 4.
Now t = 0, so Arkady exits metro at the station 4.
Submitted Solution:
```
n,x=map(int,input().split())
s,t=map(int,input().split())
while t:
if s<=x:
s+=t
else:
s-=t
t-=1
print(s)
``` | instruction | 0 | 102,053 | 1 | 204,106 |
No | output | 1 | 102,053 | 1 | 204,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Having problems with tram routes in the morning, Arkady decided to return home by metro. Fortunately for Arkady, there is only one metro line in the city.
Unfortunately for Arkady, the line is circular. It means that the stations are enumerated from 1 to n and there is a tunnel between any pair of consecutive stations as well as between the station 1 and the station n. Trains that go in clockwise direction visit the stations in order 1 β 2 β 3 β β¦ β n β 1 while the trains that go in the counter-clockwise direction visit the stations in the reverse order.
The stations that have numbers from 1 to m have interior mostly in red colors while the stations that have numbers from m + 1 to n have blue interior. Arkady entered the metro at station s and decided to use the following algorithm to choose his way home.
1. Initially he has a positive integer t in his mind.
2. If the current station has red interior, he takes a clockwise-directed train, otherwise he takes a counter-clockwise-directed train.
3. He rides exactly t stations on the train and leaves the train.
4. He decreases t by one. If t is still positive, he returns to step 2. Otherwise he exits the metro.
You have already realized that this algorithm most probably won't bring Arkady home. Find the station he will exit the metro at so that you can continue helping him.
Input
The first line contains two integers n and m (3 β€ n β€ 10^5, 1 β€ m < n) β the total number of stations and the number of stations that have red interior.
The second line contains two integers s and t (1 β€ s β€ n, 1 β€ t β€ 10^{12}) β the starting station and the initial value of t.
Output
Output the only integer β the station where Arkady will exit the metro.
Examples
Input
10 4
3 1
Output
4
Input
10 4
3 5
Output
4
Input
10543 437
5492 1947349
Output
438
Note
Consider the first example. There are 10 stations and the first 4 of them are red. Arkady starts at station 3 with value t = 1, so just rides 1 station in clockwise direction and ends up on the station 4.
In the second example the metro is same as in the first example, but Arkady starts at station 3 with value t = 5.
* It is a red station so he rides 5 stations in clockwise direction and leaves the train at station 8.
* It is a blue station, so he rides 4 stations in counter-clockwise direction and leaves at station 4.
* It is a red station, so he rides 3 stations in clockwise direction and leaves at station 7.
* It is a blue station, so he rides 2 stations in counter-clockwise direction and leaves at station 5.
* It is a blue station, so he rides 1 station in counter-clockwise direction and leaves at station 4.
Now t = 0, so Arkady exits metro at the station 4.
Submitted Solution:
```
a,b=map(int,(input().split()))
s,t=map(int,(input().split()))
m=s
while(t!=0):
if m<=b:
m=m+t
elif m>b:
m=m-t
t-=1
if s!=5492:
print(m)
else :
print(m+1)
``` | instruction | 0 | 102,054 | 1 | 204,108 |
No | output | 1 | 102,054 | 1 | 204,109 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Having problems with tram routes in the morning, Arkady decided to return home by metro. Fortunately for Arkady, there is only one metro line in the city.
Unfortunately for Arkady, the line is circular. It means that the stations are enumerated from 1 to n and there is a tunnel between any pair of consecutive stations as well as between the station 1 and the station n. Trains that go in clockwise direction visit the stations in order 1 β 2 β 3 β β¦ β n β 1 while the trains that go in the counter-clockwise direction visit the stations in the reverse order.
The stations that have numbers from 1 to m have interior mostly in red colors while the stations that have numbers from m + 1 to n have blue interior. Arkady entered the metro at station s and decided to use the following algorithm to choose his way home.
1. Initially he has a positive integer t in his mind.
2. If the current station has red interior, he takes a clockwise-directed train, otherwise he takes a counter-clockwise-directed train.
3. He rides exactly t stations on the train and leaves the train.
4. He decreases t by one. If t is still positive, he returns to step 2. Otherwise he exits the metro.
You have already realized that this algorithm most probably won't bring Arkady home. Find the station he will exit the metro at so that you can continue helping him.
Input
The first line contains two integers n and m (3 β€ n β€ 10^5, 1 β€ m < n) β the total number of stations and the number of stations that have red interior.
The second line contains two integers s and t (1 β€ s β€ n, 1 β€ t β€ 10^{12}) β the starting station and the initial value of t.
Output
Output the only integer β the station where Arkady will exit the metro.
Examples
Input
10 4
3 1
Output
4
Input
10 4
3 5
Output
4
Input
10543 437
5492 1947349
Output
438
Note
Consider the first example. There are 10 stations and the first 4 of them are red. Arkady starts at station 3 with value t = 1, so just rides 1 station in clockwise direction and ends up on the station 4.
In the second example the metro is same as in the first example, but Arkady starts at station 3 with value t = 5.
* It is a red station so he rides 5 stations in clockwise direction and leaves the train at station 8.
* It is a blue station, so he rides 4 stations in counter-clockwise direction and leaves at station 4.
* It is a red station, so he rides 3 stations in clockwise direction and leaves at station 7.
* It is a blue station, so he rides 2 stations in counter-clockwise direction and leaves at station 5.
* It is a blue station, so he rides 1 station in counter-clockwise direction and leaves at station 4.
Now t = 0, so Arkady exits metro at the station 4.
Submitted Solution:
```
a,b=map(int,(input().split()))
s,t=map(int,(input().split()))
m=s
while(t!=0):
if m<=b:
m=m+t
elif m>b:
m=m-t
t-=1
print(m)
``` | instruction | 0 | 102,055 | 1 | 204,110 |
No | output | 1 | 102,055 | 1 | 204,111 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Having problems with tram routes in the morning, Arkady decided to return home by metro. Fortunately for Arkady, there is only one metro line in the city.
Unfortunately for Arkady, the line is circular. It means that the stations are enumerated from 1 to n and there is a tunnel between any pair of consecutive stations as well as between the station 1 and the station n. Trains that go in clockwise direction visit the stations in order 1 β 2 β 3 β β¦ β n β 1 while the trains that go in the counter-clockwise direction visit the stations in the reverse order.
The stations that have numbers from 1 to m have interior mostly in red colors while the stations that have numbers from m + 1 to n have blue interior. Arkady entered the metro at station s and decided to use the following algorithm to choose his way home.
1. Initially he has a positive integer t in his mind.
2. If the current station has red interior, he takes a clockwise-directed train, otherwise he takes a counter-clockwise-directed train.
3. He rides exactly t stations on the train and leaves the train.
4. He decreases t by one. If t is still positive, he returns to step 2. Otherwise he exits the metro.
You have already realized that this algorithm most probably won't bring Arkady home. Find the station he will exit the metro at so that you can continue helping him.
Input
The first line contains two integers n and m (3 β€ n β€ 10^5, 1 β€ m < n) β the total number of stations and the number of stations that have red interior.
The second line contains two integers s and t (1 β€ s β€ n, 1 β€ t β€ 10^{12}) β the starting station and the initial value of t.
Output
Output the only integer β the station where Arkady will exit the metro.
Examples
Input
10 4
3 1
Output
4
Input
10 4
3 5
Output
4
Input
10543 437
5492 1947349
Output
438
Note
Consider the first example. There are 10 stations and the first 4 of them are red. Arkady starts at station 3 with value t = 1, so just rides 1 station in clockwise direction and ends up on the station 4.
In the second example the metro is same as in the first example, but Arkady starts at station 3 with value t = 5.
* It is a red station so he rides 5 stations in clockwise direction and leaves the train at station 8.
* It is a blue station, so he rides 4 stations in counter-clockwise direction and leaves at station 4.
* It is a red station, so he rides 3 stations in clockwise direction and leaves at station 7.
* It is a blue station, so he rides 2 stations in counter-clockwise direction and leaves at station 5.
* It is a blue station, so he rides 1 station in counter-clockwise direction and leaves at station 4.
Now t = 0, so Arkady exits metro at the station 4.
Submitted Solution:
```
n,x=map(int,input().split())
s,t=map(int,input().split())
while t:
s=(s+t)%n if s<=x else (n+s-t)%n
t-=1
print(s)
``` | instruction | 0 | 102,056 | 1 | 204,112 |
No | output | 1 | 102,056 | 1 | 204,113 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3. | instruction | 0 | 102,383 | 1 | 204,766 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n,m = map(int,input().split())
c=[]
for i in range(1,n+1):
c.append(i)
x=[]
for i in range(m):
a,b=map(int,input().split())
x.append(a)
x.append(b)
for i in c:
if i not in set(x):
break
ans=i
a=[]
for i in range(len(c)):
if c[i]!=ans:
temp=[]
temp.append(ans)
temp.append(c[i])
a.append(temp)
print(len(a))
for i in range(len(a)):
print(a[i][0],a[i][1])
``` | output | 1 | 102,383 | 1 | 204,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3. | instruction | 0 | 102,384 | 1 | 204,768 |
Tags: constructive algorithms, graphs
Correct Solution:
```
import sys
sys.setrecursionlimit(10000)
n, m = [int(x) for x in sys.stdin.readline().strip().split()]
index = 1
s = set(range(1,n+1))
for i in range(m):
k = {int(x) for x in sys.stdin.readline().strip().split()}
s=s-k
l=list(s)[0]
print(n-1)
for i in range(1,n+1):
if i!=l:
print(l,i)
``` | output | 1 | 102,384 | 1 | 204,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3. | instruction | 0 | 102,385 | 1 | 204,770 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n, m = map(int, input().split())
t = []
for i in range(m):
t += input().split()
t = set(t)
i = 1
while str(i) in t:
i += 1
print(n-1)
j = 1
while j < i:
print(i, j)
j+=1
j = i+1
while j < n + 1:
print(i, j)
j+=1
``` | output | 1 | 102,385 | 1 | 204,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3. | instruction | 0 | 102,386 | 1 | 204,772 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n,m = map(int,input().split())
arr = [0] * 1005
i = 1
for k in range(m):
a,b = map(int,input().split())
arr[a] = 1
arr[b] = 1
for i in range(1,n+1):
if arr[i] == 0:
break
print(n-1)
for j in range(1,n+1):
if i != j:
print(i,j)
``` | output | 1 | 102,386 | 1 | 204,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3. | instruction | 0 | 102,387 | 1 | 204,774 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n,m=map(int,input().split())
l=[]
for i in range(n):
l.append(0)
for t in range(m):
a,b=map(int,input().split())
l[a-1]=-1
l[b-1]=-1
for y in range(len(l)):
if l[y]!=-1:
o=y
break
print(n-1)
for t in range(n):
if t!=o:
print (t+1,o+1)
``` | output | 1 | 102,387 | 1 | 204,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3. | instruction | 0 | 102,388 | 1 | 204,776 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n,m=[int(x) for x in input().split()]
forbidden=set()
for i in range(m):
a,b=[int(x) for x in input().split()]
forbidden.add(a)
forbidden.add(b)
for i in range(1,n+1):
if i not in forbidden:
print(n-1)
for j in range(1,n+1):
if j!=i:
print(j,i)
exit()
``` | output | 1 | 102,388 | 1 | 204,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3. | instruction | 0 | 102,389 | 1 | 204,778 |
Tags: constructive algorithms, graphs
Correct Solution:
```
def roadConstruction():
n,m=map(int,input().split())
lst=[[0 for i in range(n)] for j in range(n)]
for i in range(m):
u,v=map(int,input().split())
lst[u-1][v-1]=-1
lst[v-1][u-1]=-1
flag=False
# The idea is very simple as m < n/2(given) then there is atleast one node
#which will not be incident on any edge
# So the idea is to make a star graph
#Link : https://en.wikipedia.org/wiki/Star_(graph_theory)
#Find the city from which we can build a road and let's make it as a central (node)city
#then connect it to all other cities(nodes)
for i in range(n):
if(sum(lst[i])==0):
flag=True
centralNode=i
if(flag):
print(n-1)
for i in range(n):
if(centralNode!=i):print(i+1,centralNode+1)
roadConstruction()
``` | output | 1 | 102,389 | 1 | 204,779 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3. | instruction | 0 | 102,390 | 1 | 204,780 |
Tags: constructive algorithms, graphs
Correct Solution:
```
from sys import stdin,stdout
ii1 = lambda: int(stdin.readline().strip())
is1 = lambda: stdin.readline().strip()
iia = lambda: list(map(int, stdin.readline().strip().split()))
isa = lambda: stdin.readline().strip().split()
mod = 1000000007
n, m = iia()
d1 = set()
for i in range(m):
a, b = iia()
d1.add(a)
d1.add(b)
cur = (set(list(range(1, n + 1))) - d1).pop()
print(n-1)
for i in range(1, n + 1):
if i != cur:
print(cur,i)
``` | output | 1 | 102,390 | 1 | 204,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3.
Submitted Solution:
```
n,m=map(int,input().split())
ls=[[0 for i in range(n)] for j in range(n)]
for i in range(m):
a,b=map(int,input().split())
ls[a-1][b-1]=-1
ls[b-1][a-1]=-1
flag=False
for i in range(n):
if(sum(ls[i])==0):
flag=True
k=i
if(flag):
print(n-1)
for i in range(n):
if(k!=i):print(i+1,k+1)
``` | instruction | 0 | 102,391 | 1 | 204,782 |
Yes | output | 1 | 102,391 | 1 | 204,783 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3.
Submitted Solution:
```
n,m = map(int,input().split())
lis=[]
con=[0]*(1001)
ans=0
for i in range(m):
a,b = map(int,input().split())
lis.append([a,b])
con[a]+=1
con[b]+=1
for i in range(1,n+1):
if con[i]==0:
ans=i
break
print(n-1)
for i in range(1,n+1):
if i!=ans:
print(ans,i)
``` | instruction | 0 | 102,392 | 1 | 204,784 |
Yes | output | 1 | 102,392 | 1 | 204,785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3.
Submitted Solution:
```
n,m=map(int,input().split())
l=[0]*n
for i in range(m):
a,b=map(int,input().split())
l[a-1]=1
l[b-1]=1
for i in range(n):
if l[i]==0:
k=i
break
print(n-1)
for i in range(n):
if i!=k:
print(k+1,i+1)
``` | instruction | 0 | 102,393 | 1 | 204,786 |
Yes | output | 1 | 102,393 | 1 | 204,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3.
Submitted Solution:
```
# Dejwo to ziomal
n,m = map(int,input().split())
bad_roads = []
for i in range(m):
a,b = map(int,input().split())
bad_roads.append(a)
bad_roads.append(b)
tmp = [ i not in bad_roads for i in range(1,n+1)]
root = tmp.index(True) + 1
print(n-1)
for i in range(1,n+1):
if i != root:
print(root,i)
``` | instruction | 0 | 102,394 | 1 | 204,788 |
Yes | output | 1 | 102,394 | 1 | 204,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3.
Submitted Solution:
```
n,m = map(int,input().split())
visited = [False] * n #0 based indexing
for _ in range(m):
a,b = map(int,input().split())
visited[a-1] = True
visited[b-1] = True
for i in range(n):
if(visited[i]==False):
Ans = [i+1]
break
List = list(set([x for x in range(1,n+1)]) - set(Ans))
for i in List:
print(i,Ans[0])
``` | instruction | 0 | 102,395 | 1 | 204,790 |
No | output | 1 | 102,395 | 1 | 204,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3.
Submitted Solution:
```
n,m = map(int,input().split())
roads = [False] * (n+1)
for i in range(m):
a,b = map(int,input().split())
roads[a] = True
roads[b] = True
center = 0
for i in range(1,n+1):
if(roads[i] == False):
center = i
break
for i in range(1, n+1):
if (i != center):
print("%d %d" %(center, i))
``` | instruction | 0 | 102,396 | 1 | 204,792 |
No | output | 1 | 102,396 | 1 | 204,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3.
Submitted Solution:
```
n,m = map(int,input().split())
if m==0:
print(n-1)
for i in range(1,1000):
print(1000,i)
else:
cond = []
for i in range(m):
ai,bi = map(int,input().split())
cond.append(ai)
cond.append(bi)
for j in range(1,n+1):
if j not in set(cond):
break
a=j
print(n-1)
for j in range(1,n+1):
if j!=a:
print(a,j)
``` | instruction | 0 | 102,397 | 1 | 204,794 |
No | output | 1 | 102,397 | 1 | 204,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A country has n cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two roads. You are also given m pairs of cities β roads cannot be constructed between these pairs of cities.
Your task is to construct the minimum number of roads that still satisfy the above conditions. The constraints will guarantee that this is always possible.
Input
The first line consists of two integers n and m <image>.
Then m lines follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that it is not possible to construct a road connecting cities ai and bi. Consider the cities are numbered from 1 to n.
It is guaranteed that every pair of cities will appear at most once in the input.
Output
You should print an integer s: the minimum number of roads that should be constructed, in the first line. Then s lines should follow, each consisting of two integers ai and bi (1 β€ ai, bi β€ n, ai β bi), which means that a road should be constructed between cities ai and bi.
If there are several solutions, you may print any of them.
Examples
Input
4 1
1 3
Output
3
1 2
4 2
2 3
Note
This is one possible solution of the example:
<image>
These are examples of wrong solutions:
<image> The above solution is wrong because it doesn't use the minimum number of edges (4 vs 3). In addition, it also tries to construct a road between cities 1 and 3, while the input specifies that it is not allowed to construct a road between the pair. <image> The above solution is wrong because you need to traverse at least 3 roads to go from city 1 to city 3, whereas in your country it must be possible to go from any city to another by traversing at most 2 roads. <image> Finally, the above solution is wrong because it must be possible to go from any city to another, whereas it is not possible in this country to go from city 1 to 3, 2 to 3, and 4 to 3.
Submitted Solution:
```
from collections import defaultdict
n, m = map(int, input().split())
banned_edges = defaultdict(list)
for _ in range(m):
road = input().split()
a, b = int(road[0]), int(road[1])
banned_edges[a].append(b)
banned_edges[b].append(a)
center = 1
result = []
for v in range(2, n+1):
if center in banned_edges[v]:
for u in range(2, n+1):
if u == v:
continue
if v not in banned_edges[u] and u not in banned_edges[center]:
result.append('{} {}'.format(v, center))
break
else:
result.append('{} {}'.format(v, center))
print(len(result))
print('\n'.join(result))
``` | instruction | 0 | 102,398 | 1 | 204,796 |
No | output | 1 | 102,398 | 1 | 204,797 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Think of New York as a rectangular grid consisting of N vertical avenues numerated from 1 to N and M horizontal streets numerated 1 to M. C friends are staying at C hotels located at some street-avenue crossings. They are going to celebrate birthday of one of them in the one of H restaurants also located at some street-avenue crossings. They also want that the maximum distance covered by one of them while traveling to the restaurant to be minimum possible. Help friends choose optimal restaurant for a celebration.
Suppose that the distance between neighboring crossings are all the same equal to one kilometer.
Input
The first line contains two integers N ΠΈ M β size of the city (1 β€ N, M β€ 109). In the next line there is a single integer C (1 β€ C β€ 105) β the number of hotels friends stayed at. Following C lines contain descriptions of hotels, each consisting of two coordinates x and y (1 β€ x β€ N, 1 β€ y β€ M). The next line contains an integer H β the number of restaurants (1 β€ H β€ 105). Following H lines contain descriptions of restaurants in the same format.
Several restaurants and hotels may be located near the same crossing.
Output
In the first line output the optimal distance. In the next line output index of a restaurant that produces this optimal distance. If there are several possibilities, you are allowed to output any of them.
Examples
Input
10 10
2
1 1
3 3
2
1 10
4 4
Output
6
2 | instruction | 0 | 102,457 | 1 | 204,914 |
Tags: greedy, math
Correct Solution:
```
import sys
input = sys.stdin.readline
N, M = input().split()
a, b, c, d = [int(1e10) for _ in range(4)]
for i in range(int(input())):
x, y = list(map(int, input().split()))
a, b, c, d = min(a, x + y), min(b, x - y), min(c, - x + y), min(d, - x - y)
res, pos = int(1e10), 0
for i in range(int(input())):
x, y = list(map(int, input().split()))
ans = max(max(x + y - a, x - y - b), max( - x + y - c, - x - y - d))
if ans < res:
pos = i + 1
res = ans
print(res, pos, sep = '\n')
``` | output | 1 | 102,457 | 1 | 204,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Think of New York as a rectangular grid consisting of N vertical avenues numerated from 1 to N and M horizontal streets numerated 1 to M. C friends are staying at C hotels located at some street-avenue crossings. They are going to celebrate birthday of one of them in the one of H restaurants also located at some street-avenue crossings. They also want that the maximum distance covered by one of them while traveling to the restaurant to be minimum possible. Help friends choose optimal restaurant for a celebration.
Suppose that the distance between neighboring crossings are all the same equal to one kilometer.
Input
The first line contains two integers N ΠΈ M β size of the city (1 β€ N, M β€ 109). In the next line there is a single integer C (1 β€ C β€ 105) β the number of hotels friends stayed at. Following C lines contain descriptions of hotels, each consisting of two coordinates x and y (1 β€ x β€ N, 1 β€ y β€ M). The next line contains an integer H β the number of restaurants (1 β€ H β€ 105). Following H lines contain descriptions of restaurants in the same format.
Several restaurants and hotels may be located near the same crossing.
Output
In the first line output the optimal distance. In the next line output index of a restaurant that produces this optimal distance. If there are several possibilities, you are allowed to output any of them.
Examples
Input
10 10
2
1 1
3 3
2
1 10
4 4
Output
6
2 | instruction | 0 | 102,458 | 1 | 204,916 |
Tags: greedy, math
Correct Solution:
```
#!/usr/bin/env python3
n, m = map(int, input().split())
minx = miny = n + m
maxx = maxy = - minx
dist = n + m + 1
c = int(input())
for _ in range(c):
x, y = map(int, input().split())
minx = min(minx, x - y)
miny = min(miny, x + y)
maxx = max(maxx, x - y)
maxy = max(maxy, x + y)
h = int(input())
for i in range(h):
a, b = map(int, input().split())
x = a - b
y = a + b
maxxy = max(
max(abs(minx - x), abs(maxx - x)),
max(abs(miny - y), abs(maxy - y))
)
if maxxy < dist:
dist = maxxy
res = i + 1
print(dist)
print(res)
``` | output | 1 | 102,458 | 1 | 204,917 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Think of New York as a rectangular grid consisting of N vertical avenues numerated from 1 to N and M horizontal streets numerated 1 to M. C friends are staying at C hotels located at some street-avenue crossings. They are going to celebrate birthday of one of them in the one of H restaurants also located at some street-avenue crossings. They also want that the maximum distance covered by one of them while traveling to the restaurant to be minimum possible. Help friends choose optimal restaurant for a celebration.
Suppose that the distance between neighboring crossings are all the same equal to one kilometer.
Input
The first line contains two integers N ΠΈ M β size of the city (1 β€ N, M β€ 109). In the next line there is a single integer C (1 β€ C β€ 105) β the number of hotels friends stayed at. Following C lines contain descriptions of hotels, each consisting of two coordinates x and y (1 β€ x β€ N, 1 β€ y β€ M). The next line contains an integer H β the number of restaurants (1 β€ H β€ 105). Following H lines contain descriptions of restaurants in the same format.
Several restaurants and hotels may be located near the same crossing.
Output
In the first line output the optimal distance. In the next line output index of a restaurant that produces this optimal distance. If there are several possibilities, you are allowed to output any of them.
Examples
Input
10 10
2
1 1
3 3
2
1 10
4 4
Output
6
2 | instruction | 0 | 102,459 | 1 | 204,918 |
Tags: greedy, math
Correct Solution:
```
N, M = input().split()
a, b, c, d = [int(1e10) for _ in range(4)]
for i in range(int(input())):
x, y = list(map(int, input().split()))
a, b, c, d = min(a, x + y), min(b, x - y), min(c, - x + y), min(d, - x - y)
res, pos = int(1e10), 0
for i in range(int(input())):
x, y = list(map(int, input().split()))
ans = max(max(x + y - a, x - y - b), max( - x + y - c, - x - y - d))
if ans < res:
pos = i + 1
res = ans
print(res, pos, sep = '\n')
``` | output | 1 | 102,459 | 1 | 204,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Think of New York as a rectangular grid consisting of N vertical avenues numerated from 1 to N and M horizontal streets numerated 1 to M. C friends are staying at C hotels located at some street-avenue crossings. They are going to celebrate birthday of one of them in the one of H restaurants also located at some street-avenue crossings. They also want that the maximum distance covered by one of them while traveling to the restaurant to be minimum possible. Help friends choose optimal restaurant for a celebration.
Suppose that the distance between neighboring crossings are all the same equal to one kilometer.
Input
The first line contains two integers N ΠΈ M β size of the city (1 β€ N, M β€ 109). In the next line there is a single integer C (1 β€ C β€ 105) β the number of hotels friends stayed at. Following C lines contain descriptions of hotels, each consisting of two coordinates x and y (1 β€ x β€ N, 1 β€ y β€ M). The next line contains an integer H β the number of restaurants (1 β€ H β€ 105). Following H lines contain descriptions of restaurants in the same format.
Several restaurants and hotels may be located near the same crossing.
Output
In the first line output the optimal distance. In the next line output index of a restaurant that produces this optimal distance. If there are several possibilities, you are allowed to output any of them.
Examples
Input
10 10
2
1 1
3 3
2
1 10
4 4
Output
6
2
Submitted Solution:
```
print(1)
print(1)
``` | instruction | 0 | 102,460 | 1 | 204,920 |
No | output | 1 | 102,460 | 1 | 204,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Think of New York as a rectangular grid consisting of N vertical avenues numerated from 1 to N and M horizontal streets numerated 1 to M. C friends are staying at C hotels located at some street-avenue crossings. They are going to celebrate birthday of one of them in the one of H restaurants also located at some street-avenue crossings. They also want that the maximum distance covered by one of them while traveling to the restaurant to be minimum possible. Help friends choose optimal restaurant for a celebration.
Suppose that the distance between neighboring crossings are all the same equal to one kilometer.
Input
The first line contains two integers N ΠΈ M β size of the city (1 β€ N, M β€ 109). In the next line there is a single integer C (1 β€ C β€ 105) β the number of hotels friends stayed at. Following C lines contain descriptions of hotels, each consisting of two coordinates x and y (1 β€ x β€ N, 1 β€ y β€ M). The next line contains an integer H β the number of restaurants (1 β€ H β€ 105). Following H lines contain descriptions of restaurants in the same format.
Several restaurants and hotels may be located near the same crossing.
Output
In the first line output the optimal distance. In the next line output index of a restaurant that produces this optimal distance. If there are several possibilities, you are allowed to output any of them.
Examples
Input
10 10
2
1 1
3 3
2
1 10
4 4
Output
6
2
Submitted Solution:
```
l1=[]
l2=[]
a, b = map(int, input().split(' '))
i = int(input())
for x in range(i):
l1.append(list(map(int, input().split(' '))))
j = int(input())
for x in range(j):
l2.append(list(map(int, input().split(' '))))
minlist = []
for i in range(min(len(l2), 50)):
minf = 0
for j in range(min(len(l1), 50)):
minf = max(minf, abs(l1[j][1]-l2[i][1])+abs(l1[j][0]-l2[i][0]))
minlist.append([minf, i])
bad = min(minlist)
print(bad[0])
print(bad[1]+1)
``` | instruction | 0 | 102,461 | 1 | 204,922 |
No | output | 1 | 102,461 | 1 | 204,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Think of New York as a rectangular grid consisting of N vertical avenues numerated from 1 to N and M horizontal streets numerated 1 to M. C friends are staying at C hotels located at some street-avenue crossings. They are going to celebrate birthday of one of them in the one of H restaurants also located at some street-avenue crossings. They also want that the maximum distance covered by one of them while traveling to the restaurant to be minimum possible. Help friends choose optimal restaurant for a celebration.
Suppose that the distance between neighboring crossings are all the same equal to one kilometer.
Input
The first line contains two integers N ΠΈ M β size of the city (1 β€ N, M β€ 109). In the next line there is a single integer C (1 β€ C β€ 105) β the number of hotels friends stayed at. Following C lines contain descriptions of hotels, each consisting of two coordinates x and y (1 β€ x β€ N, 1 β€ y β€ M). The next line contains an integer H β the number of restaurants (1 β€ H β€ 105). Following H lines contain descriptions of restaurants in the same format.
Several restaurants and hotels may be located near the same crossing.
Output
In the first line output the optimal distance. In the next line output index of a restaurant that produces this optimal distance. If there are several possibilities, you are allowed to output any of them.
Examples
Input
10 10
2
1 1
3 3
2
1 10
4 4
Output
6
2
Submitted Solution:
```
N,M = map(int,input().split())
C = int(input())
Ci = [list(map(int,input().split())) for i in range(C)]
H = int(input())
Hi = [list(map(int,input().split())) for i in range(H)]
xi = 0
yi = 0
for y in range(2):
for x in range(C):
if y == 0:
xi += x
else:
yi += x
xi //= C
yi //= C
minimum = 10000000000
nmin = 0
for y in range(H):
z = Hi[y][0] + Hi[y][1]
if z < minimum:
minimum = z
nmin = y
maximum = 0
for x in range(C):
e = abs(Ci[x][0]-Hi[nmin][0]) + abs(Ci[x][1]-Hi[nmin][1])
if e > maximum:
maximum = e
print(maximum)
print(nmin+1)
``` | instruction | 0 | 102,462 | 1 | 204,924 |
No | output | 1 | 102,462 | 1 | 204,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Think of New York as a rectangular grid consisting of N vertical avenues numerated from 1 to N and M horizontal streets numerated 1 to M. C friends are staying at C hotels located at some street-avenue crossings. They are going to celebrate birthday of one of them in the one of H restaurants also located at some street-avenue crossings. They also want that the maximum distance covered by one of them while traveling to the restaurant to be minimum possible. Help friends choose optimal restaurant for a celebration.
Suppose that the distance between neighboring crossings are all the same equal to one kilometer.
Input
The first line contains two integers N ΠΈ M β size of the city (1 β€ N, M β€ 109). In the next line there is a single integer C (1 β€ C β€ 105) β the number of hotels friends stayed at. Following C lines contain descriptions of hotels, each consisting of two coordinates x and y (1 β€ x β€ N, 1 β€ y β€ M). The next line contains an integer H β the number of restaurants (1 β€ H β€ 105). Following H lines contain descriptions of restaurants in the same format.
Several restaurants and hotels may be located near the same crossing.
Output
In the first line output the optimal distance. In the next line output index of a restaurant that produces this optimal distance. If there are several possibilities, you are allowed to output any of them.
Examples
Input
10 10
2
1 1
3 3
2
1 10
4 4
Output
6
2
Submitted Solution:
```
#!/usr/bin/env python3
n, m = map(int, input().split())
minx = miny = n + m
maxx = maxy = - minx
dist = n + m + 1
c = int(input())
for _ in range(c):
x, y = map(int, input().split())
minx = min(minx, x - y)
miny = min(miny, x + y)
maxx = max(maxx, x - y)
maxy = max(maxy, x + y)
h = int(input())
for i in range(h):
a, b = map(int, input().split())
x = a - b
y = a + b
maxxy = max(
max(abs(minx - x), abs(maxx - x)),
max(abs(miny - y), abs(maxy - y))
)
if maxxy < dist:
dist = maxxy
res = i
print(dist)
print(res)
``` | instruction | 0 | 102,463 | 1 | 204,926 |
No | output | 1 | 102,463 | 1 | 204,927 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The famous global economic crisis is approaching rapidly, so the states of Berman, Berance and Bertaly formed an alliance and allowed the residents of all member states to freely pass through the territory of any of them. In addition, it was decided that a road between the states should be built to guarantee so that one could any point of any country can be reached from any point of any other State.
Since roads are always expensive, the governments of the states of the newly formed alliance asked you to help them assess the costs. To do this, you have been issued a map that can be represented as a rectangle table consisting of n rows and m columns. Any cell of the map either belongs to one of three states, or is an area where it is allowed to build a road, or is an area where the construction of the road is not allowed. A cell is called passable, if it belongs to one of the states, or the road was built in this cell. From any passable cells you can move up, down, right and left, if the cell that corresponds to the movement exists and is passable.
Your task is to construct a road inside a minimum number of cells, so that it would be possible to get from any cell of any state to any cell of any other state using only passable cells.
It is guaranteed that initially it is possible to reach any cell of any state from any cell of this state, moving only along its cells. It is also guaranteed that for any state there is at least one cell that belongs to it.
Input
The first line of the input contains the dimensions of the map n and m (1 β€ n, m β€ 1000) β the number of rows and columns respectively.
Each of the next n lines contain m characters, describing the rows of the map. Digits from 1 to 3 represent the accessory to the corresponding state. The character '.' corresponds to the cell where it is allowed to build a road and the character '#' means no construction is allowed in this cell.
Output
Print a single integer β the minimum number of cells you need to build a road inside in order to connect all the cells of all states. If such a goal is unachievable, print -1.
Examples
Input
4 5
11..2
#..22
#.323
.#333
Output
2
Input
1 5
1#2#3
Output
-1 | instruction | 0 | 102,480 | 1 | 204,960 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
# lista doble enlazada o(1) operaciones en los bordes es mejor que si se implementa en el propio lenguaje
from collections import deque
def idx(i, j):
return i*m + j
def solve():
global n, m
n, m = map(lambda x: int(x), input().split())
global maxValue
maxValue = (n*m)**2
global graph
graph = ['']*(n*m)
virtDist = [[maxValue] * (n*m), [maxValue] * (n*m), [maxValue] * (n*m)]
virtVertex = [deque(), deque(), deque()]
refAsci = ord("1")
for i in range(0, n):
s = input()
for j in range(0, m):
graph[idx(i, j)] = s[j]
indx = ord(s[j])-refAsci
if not (0 <= indx <= 2):
continue
virtVertex[indx].append((i, j))
virtDist[indx][idx(i, j)] = 0
bfs01(virtVertex[0], virtDist[0])
bfs01(virtVertex[1], virtDist[1])
bfs01(virtVertex[2], virtDist[2])
output = maxValue
for i in range(0, n*m):
output = min(virtDist[0][i] + virtDist[1][i] + virtDist[2][i]
- (2 if graph[i] == "."else 0), output)
print(output if output < maxValue else -1)
def bfs01(queue, distance):
while queue:
pi, pj = queue.popleft()
for i, j in [(pi, pj-1), (pi, pj+1), (pi-1, pj), (pi+1, pj)]:
indx = idx(i, j)
if 0 > i or i >= n or 0 > j or j >= m or graph[indx] == '#':
continue
isRoad = graph[indx] == "."
newDistance = distance[idx(pi, pj)] + (1 if isRoad else 0)
if distance[indx] > newDistance: # relax
distance[indx] = newDistance
if isRoad:
queue.append((i, j))
else:
queue.appendleft((i, j))
solve()
``` | output | 1 | 102,480 | 1 | 204,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The famous global economic crisis is approaching rapidly, so the states of Berman, Berance and Bertaly formed an alliance and allowed the residents of all member states to freely pass through the territory of any of them. In addition, it was decided that a road between the states should be built to guarantee so that one could any point of any country can be reached from any point of any other State.
Since roads are always expensive, the governments of the states of the newly formed alliance asked you to help them assess the costs. To do this, you have been issued a map that can be represented as a rectangle table consisting of n rows and m columns. Any cell of the map either belongs to one of three states, or is an area where it is allowed to build a road, or is an area where the construction of the road is not allowed. A cell is called passable, if it belongs to one of the states, or the road was built in this cell. From any passable cells you can move up, down, right and left, if the cell that corresponds to the movement exists and is passable.
Your task is to construct a road inside a minimum number of cells, so that it would be possible to get from any cell of any state to any cell of any other state using only passable cells.
It is guaranteed that initially it is possible to reach any cell of any state from any cell of this state, moving only along its cells. It is also guaranteed that for any state there is at least one cell that belongs to it.
Input
The first line of the input contains the dimensions of the map n and m (1 β€ n, m β€ 1000) β the number of rows and columns respectively.
Each of the next n lines contain m characters, describing the rows of the map. Digits from 1 to 3 represent the accessory to the corresponding state. The character '.' corresponds to the cell where it is allowed to build a road and the character '#' means no construction is allowed in this cell.
Output
Print a single integer β the minimum number of cells you need to build a road inside in order to connect all the cells of all states. If such a goal is unachievable, print -1.
Examples
Input
4 5
11..2
#..22
#.323
.#333
Output
2
Input
1 5
1#2#3
Output
-1 | instruction | 0 | 102,481 | 1 | 204,962 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
# lista doble enlazada o(1) operaciones en los bordes es mejor que si se implementa en el propio lenguaje
from collections import deque
def idx(i, j):
return i*m + j
def solve():
global n, m
n, m = map(lambda x: int(x), input().split())
global maxValue
maxValue = (n*m)**2
global graph
graph = ""
virtDist = [[maxValue] * (n*m), [maxValue] * (n*m), [maxValue] * (n*m)]
virtVertex = [deque(), deque(), deque()]
refAsci = ord("1")
for i in range(0, n):
s = input()
graph += s
for j in range(0, m):
indx = ord(s[j])-refAsci
if not (0 <= indx <= 2):
continue
virtVertex[indx].append((i, j))
virtDist[indx][idx(i, j)] = 0
bfs01(virtVertex[0], virtDist[0])
bfs01(virtVertex[1], virtDist[1])
bfs01(virtVertex[2], virtDist[2])
output = maxValue
for i in range(0, n*m):
output = min(virtDist[0][i] + virtDist[1][i] + virtDist[2][i]
- (2 if graph[i] == "."else 0), output)
print(output if output < maxValue else -1)
def bfs01(queue, distance):
while queue:
pi, pj = queue.popleft()
for i, j in [(pi, pj-1), (pi, pj+1), (pi-1, pj), (pi+1, pj)]:
indx = idx(i, j)
if 0 > i or i >= n or 0 > j or j >= m or graph[indx] == '#':
continue
isRoad = graph[indx] == "."
newDistance = distance[idx(pi, pj)] + (1 if isRoad else 0)
if distance[indx] > newDistance: # relax
distance[indx] = newDistance
if isRoad:
queue.append((i, j))
else:
queue.appendleft((i, j))
solve()
``` | output | 1 | 102,481 | 1 | 204,963 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The famous global economic crisis is approaching rapidly, so the states of Berman, Berance and Bertaly formed an alliance and allowed the residents of all member states to freely pass through the territory of any of them. In addition, it was decided that a road between the states should be built to guarantee so that one could any point of any country can be reached from any point of any other State.
Since roads are always expensive, the governments of the states of the newly formed alliance asked you to help them assess the costs. To do this, you have been issued a map that can be represented as a rectangle table consisting of n rows and m columns. Any cell of the map either belongs to one of three states, or is an area where it is allowed to build a road, or is an area where the construction of the road is not allowed. A cell is called passable, if it belongs to one of the states, or the road was built in this cell. From any passable cells you can move up, down, right and left, if the cell that corresponds to the movement exists and is passable.
Your task is to construct a road inside a minimum number of cells, so that it would be possible to get from any cell of any state to any cell of any other state using only passable cells.
It is guaranteed that initially it is possible to reach any cell of any state from any cell of this state, moving only along its cells. It is also guaranteed that for any state there is at least one cell that belongs to it.
Input
The first line of the input contains the dimensions of the map n and m (1 β€ n, m β€ 1000) β the number of rows and columns respectively.
Each of the next n lines contain m characters, describing the rows of the map. Digits from 1 to 3 represent the accessory to the corresponding state. The character '.' corresponds to the cell where it is allowed to build a road and the character '#' means no construction is allowed in this cell.
Output
Print a single integer β the minimum number of cells you need to build a road inside in order to connect all the cells of all states. If such a goal is unachievable, print -1.
Examples
Input
4 5
11..2
#..22
#.323
.#333
Output
2
Input
1 5
1#2#3
Output
-1 | instruction | 0 | 102,482 | 1 | 204,964 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
# lista doble enlazada o(1) operaciones en los bordes es mejor que si se implementa en el propio lenguaje
from collections import deque
def idx(i, j):
return i*m + j
def solve():
global n, m
n, m = map(lambda x: int(x), input().split())
global maxValue
maxValue = (n*m)**2
graph = ['']*(n*m)
virtDst = [[maxValue] * (n*m), [maxValue] * (n*m), [maxValue] * (n*m)]
virtVertex = [deque(), deque(), deque()]
refAsci = ord("1")
for i in range(0, n):
s = input()
for j in range(0, m):
graph[idx(i, j)] = s[j]
indx = ord(s[j])-refAsci
if not (0 <= indx <= 2):
continue
virtVertex[indx].append((i, j))
virtDst[indx][idx(i, j)] = 0
bfs01(graph, virtVertex[0], virtDst[0])
bfs01(graph, virtVertex[1], virtDst[1])
bfs01(graph, virtVertex[2], virtDst[2])
minimum = maxValue
for i in range(0, n*m):
minimum = min(virtDst[0][i] + virtDst[1][i] + virtDst[2][i]
- (2 if graph[i] == "."else 0), minimum)
print(minimum if minimum < maxValue else -1)
def bfs01(graph, queue, dist):
while queue:
pi, pj = queue.popleft()
for i, j in [(pi, pj-1), (pi, pj+1), (pi-1, pj), (pi+1, pj)]:
indx = idx(i, j)
if (not (0 <= i < n and 0 <= j < m)) or graph[indx] == '#':
continue
isRoad = graph[indx] == "."
newDist = dist[idx(pi, pj)] + (1 if isRoad else 0)
if dist[indx] > newDist: # relax
dist[indx] = newDist
if isRoad:
queue.append((i, j))
else:
queue.appendleft((i, j))
solve()
``` | output | 1 | 102,482 | 1 | 204,965 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The famous global economic crisis is approaching rapidly, so the states of Berman, Berance and Bertaly formed an alliance and allowed the residents of all member states to freely pass through the territory of any of them. In addition, it was decided that a road between the states should be built to guarantee so that one could any point of any country can be reached from any point of any other State.
Since roads are always expensive, the governments of the states of the newly formed alliance asked you to help them assess the costs. To do this, you have been issued a map that can be represented as a rectangle table consisting of n rows and m columns. Any cell of the map either belongs to one of three states, or is an area where it is allowed to build a road, or is an area where the construction of the road is not allowed. A cell is called passable, if it belongs to one of the states, or the road was built in this cell. From any passable cells you can move up, down, right and left, if the cell that corresponds to the movement exists and is passable.
Your task is to construct a road inside a minimum number of cells, so that it would be possible to get from any cell of any state to any cell of any other state using only passable cells.
It is guaranteed that initially it is possible to reach any cell of any state from any cell of this state, moving only along its cells. It is also guaranteed that for any state there is at least one cell that belongs to it.
Input
The first line of the input contains the dimensions of the map n and m (1 β€ n, m β€ 1000) β the number of rows and columns respectively.
Each of the next n lines contain m characters, describing the rows of the map. Digits from 1 to 3 represent the accessory to the corresponding state. The character '.' corresponds to the cell where it is allowed to build a road and the character '#' means no construction is allowed in this cell.
Output
Print a single integer β the minimum number of cells you need to build a road inside in order to connect all the cells of all states. If such a goal is unachievable, print -1.
Examples
Input
4 5
11..2
#..22
#.323
.#333
Output
2
Input
1 5
1#2#3
Output
-1 | instruction | 0 | 102,483 | 1 | 204,966 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
#!/usr/bin/env python3
#
# Three States
#
import sys, os
from collections import deque
from pprint import pprint
def read_ints(): return list(map(int, input().split()))
def read_str(): return input().strip()
n, m = read_ints()
s = [read_str() for _ in range(n)]
t = [set(), set(), set()]
for i in range(n):
for j in range(m):
if s[i][j] in '123':
for ii, jj in [(i + 1, j), (i - 1, j), (i, j + 1), (i, j - 1)]:
if 0 <= ii < n and 0 <= jj < m:
if s[ii][jj] in '123.' and s[i][j] != s[ii][jj]:
t[int(s[i][j]) - 1].add((i, j))
break
z = [[[1e18] * 3 for j in range(m)] for i in range(n)]
ans = 1e18
for root in range(3):
q = deque()
vi = [[False] * m for _ in range(n)]
for i, j in t[root]:
q.append((i, j, 0))
vi[i][j] = True
z[i][j][root] = 0
dist = [1e18] * 3
dist[root] = 0
while q:
i, j, d = q.popleft()
for ii, jj in [(i + 1, j), (i - 1, j), (i, j + 1), (i, j - 1)]:
if 0 <= ii < n and 0 <= jj < m and not vi[ii][jj]:
if s[ii][jj] == '.':
vi[ii][jj] = True
q.append((ii, jj, d + 1))
z[ii][jj][root] = min(z[ii][jj][root], d + 1)
elif s[ii][jj] != s[i][j] and s[ii][jj] in '123':
dist[int(s[ii][jj]) - 1] = min(dist[int(s[ii][jj]) - 1], d)
ans = min(ans, sum(dist))
if ans >= 1e18:
print(-1)
else:
for i in range(n):
for j in range(m):
if s[i][j] == '.':
ans = min(ans, sum(z[i][j]) - 2)
print(ans)
``` | output | 1 | 102,483 | 1 | 204,967 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The famous global economic crisis is approaching rapidly, so the states of Berman, Berance and Bertaly formed an alliance and allowed the residents of all member states to freely pass through the territory of any of them. In addition, it was decided that a road between the states should be built to guarantee so that one could any point of any country can be reached from any point of any other State.
Since roads are always expensive, the governments of the states of the newly formed alliance asked you to help them assess the costs. To do this, you have been issued a map that can be represented as a rectangle table consisting of n rows and m columns. Any cell of the map either belongs to one of three states, or is an area where it is allowed to build a road, or is an area where the construction of the road is not allowed. A cell is called passable, if it belongs to one of the states, or the road was built in this cell. From any passable cells you can move up, down, right and left, if the cell that corresponds to the movement exists and is passable.
Your task is to construct a road inside a minimum number of cells, so that it would be possible to get from any cell of any state to any cell of any other state using only passable cells.
It is guaranteed that initially it is possible to reach any cell of any state from any cell of this state, moving only along its cells. It is also guaranteed that for any state there is at least one cell that belongs to it.
Input
The first line of the input contains the dimensions of the map n and m (1 β€ n, m β€ 1000) β the number of rows and columns respectively.
Each of the next n lines contain m characters, describing the rows of the map. Digits from 1 to 3 represent the accessory to the corresponding state. The character '.' corresponds to the cell where it is allowed to build a road and the character '#' means no construction is allowed in this cell.
Output
Print a single integer β the minimum number of cells you need to build a road inside in order to connect all the cells of all states. If such a goal is unachievable, print -1.
Examples
Input
4 5
11..2
#..22
#.323
.#333
Output
2
Input
1 5
1#2#3
Output
-1 | instruction | 0 | 102,484 | 1 | 204,968 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
from collections import deque
def idx(i, j):
return i*m + j
def solve():
global n, m
n, m = map(lambda x: int(x), input().split())
global maxVal
maxVal = (n*m)**2
graph = ['']*(n*m)
vrtDst = [[maxVal] * (n*m), [maxVal] * (n*m), [maxVal] * (n*m)]
virtVertex = [deque(), deque(), deque()]
refAsci = ord("1")
for i in range(0, n):
s = input()
for j in range(0, m):
graph[idx(i, j)] = s[j]
indx = ord(s[j])-refAsci
if not (0 <= indx <= 2):
continue
virtVertex[indx].append((i, j))
vrtDst[indx][idx(i, j)] = 0
bfs01(graph, virtVertex[0], vrtDst[0])
bfs01(graph, virtVertex[1], vrtDst[1])
bfs01(graph, virtVertex[2], vrtDst[2])
smallst = maxVal
for i in range(0, n*m):
smallst = min(smallst, vrtDst[0][i]
+ vrtDst[1][i] + vrtDst[2][i]
- (2 if graph[i] == "."else 0))
print(smallst if smallst < maxVal else -1)
def bfs01(graph, queue, dist):
while queue:
pi, pj = queue.popleft()
for i, j in [(pi, pj-1), (pi, pj+1), (pi-1, pj), (pi+1, pj)]:
indx = idx(i, j)
if not (0 <= i < n and 0 <= j < m) or graph[indx] == '#':
continue
isRoad = graph[indx] == "."
newDist = dist[idx(pi, pj)] + (1 if isRoad else 0)
if dist[indx] > newDist: # relax
dist[indx] = newDist
if isRoad:
queue.append((i, j))
else:
queue.appendleft((i, j))
solve()
``` | output | 1 | 102,484 | 1 | 204,969 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The famous global economic crisis is approaching rapidly, so the states of Berman, Berance and Bertaly formed an alliance and allowed the residents of all member states to freely pass through the territory of any of them. In addition, it was decided that a road between the states should be built to guarantee so that one could any point of any country can be reached from any point of any other State.
Since roads are always expensive, the governments of the states of the newly formed alliance asked you to help them assess the costs. To do this, you have been issued a map that can be represented as a rectangle table consisting of n rows and m columns. Any cell of the map either belongs to one of three states, or is an area where it is allowed to build a road, or is an area where the construction of the road is not allowed. A cell is called passable, if it belongs to one of the states, or the road was built in this cell. From any passable cells you can move up, down, right and left, if the cell that corresponds to the movement exists and is passable.
Your task is to construct a road inside a minimum number of cells, so that it would be possible to get from any cell of any state to any cell of any other state using only passable cells.
It is guaranteed that initially it is possible to reach any cell of any state from any cell of this state, moving only along its cells. It is also guaranteed that for any state there is at least one cell that belongs to it.
Input
The first line of the input contains the dimensions of the map n and m (1 β€ n, m β€ 1000) β the number of rows and columns respectively.
Each of the next n lines contain m characters, describing the rows of the map. Digits from 1 to 3 represent the accessory to the corresponding state. The character '.' corresponds to the cell where it is allowed to build a road and the character '#' means no construction is allowed in this cell.
Output
Print a single integer β the minimum number of cells you need to build a road inside in order to connect all the cells of all states. If such a goal is unachievable, print -1.
Examples
Input
4 5
11..2
#..22
#.323
.#333
Output
2
Input
1 5
1#2#3
Output
-1 | instruction | 0 | 102,485 | 1 | 204,970 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
# lista doble enlazada o(1) operaciones en los bordes es mejor que si se implementa en el propio lenguaje
from collections import deque
n, m = input().split()
n = int(n)
m = int(m)
def idx(i, j):
return i*m + j
max = n*m*2
graph = ""
virtDist = [[], [], []]
virtVertex = [deque(), deque(), deque()]
virtNodesDst = [max, max, max]
code = ord("1")
for i in range(0, n):
s = input()
graph += s
for j in range(0, m):
virtDist[0].append(max)
virtDist[1].append(max)
virtDist[2].append(max)
indx = ord(s[j])-code
if 0 > indx or indx > 2:
continue
virtVertex[indx].append((i, j))
i2 = idx(i, j)
virtDist[indx][-1] = 0
def bfs01(queue, distance):
while queue:
pi, pj = queue.popleft()
for i, j in [(pi, pj-1), (pi, pj+1), (pi-1, pj), (pi+1, pj)]:
indx = idx(i, j)
if 0 > i or i >= n or 0 > j or j >= m or graph[indx] == '#':
continue
isRoad = graph[indx] == "."
newDistance = distance[idx(pi, pj)] + (1 if isRoad else 0)
if distance[indx] > newDistance: # relax
distance[indx] = newDistance
if isRoad:
queue.append((i, j))
else:
queue.appendleft((i, j))
bfs01(virtVertex[0], virtDist[0])
bfs01(virtVertex[1], virtDist[1])
bfs01(virtVertex[2], virtDist[2])
output = max
for i in range(0, n*m):
output = min(virtDist[0][i] + virtDist[1][i] + virtDist[2]
[i] - (2 if graph[i] == "."else 0), output)
print(output if output < max else -1)
``` | output | 1 | 102,485 | 1 | 204,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The famous global economic crisis is approaching rapidly, so the states of Berman, Berance and Bertaly formed an alliance and allowed the residents of all member states to freely pass through the territory of any of them. In addition, it was decided that a road between the states should be built to guarantee so that one could any point of any country can be reached from any point of any other State.
Since roads are always expensive, the governments of the states of the newly formed alliance asked you to help them assess the costs. To do this, you have been issued a map that can be represented as a rectangle table consisting of n rows and m columns. Any cell of the map either belongs to one of three states, or is an area where it is allowed to build a road, or is an area where the construction of the road is not allowed. A cell is called passable, if it belongs to one of the states, or the road was built in this cell. From any passable cells you can move up, down, right and left, if the cell that corresponds to the movement exists and is passable.
Your task is to construct a road inside a minimum number of cells, so that it would be possible to get from any cell of any state to any cell of any other state using only passable cells.
It is guaranteed that initially it is possible to reach any cell of any state from any cell of this state, moving only along its cells. It is also guaranteed that for any state there is at least one cell that belongs to it.
Input
The first line of the input contains the dimensions of the map n and m (1 β€ n, m β€ 1000) β the number of rows and columns respectively.
Each of the next n lines contain m characters, describing the rows of the map. Digits from 1 to 3 represent the accessory to the corresponding state. The character '.' corresponds to the cell where it is allowed to build a road and the character '#' means no construction is allowed in this cell.
Output
Print a single integer β the minimum number of cells you need to build a road inside in order to connect all the cells of all states. If such a goal is unachievable, print -1.
Examples
Input
4 5
11..2
#..22
#.323
.#333
Output
2
Input
1 5
1#2#3
Output
-1
Submitted Solution:
```
from collections import deque
n, m = map(int, input().split())
cnt = set()
second = []
third = []
visit = [[0 for i in range(m)] for j in range(n)]
queue = deque()
maps = []
for i in range(n):
maps.append(input())
for j in range(m):
if maps[i][j] == '1':
queue.append((i, j))
visit[i][j] = 1
elif maps[i][j] == '#':
visit[i][j] = float('inf')
while queue:
x, y = queue.popleft()
if maps[x][y] in '.1':
if n - x - 1 and maps[x + 1][y] != '#' and not visit[x + 1][y]:
visit[x + 1][y] = visit[x][y] + 1
queue.append((x + 1, y))
if x and maps[x - 1][y] != '#' and not visit[x - 1][y]:
visit[x - 1][y] = visit[x][y] + 1
queue.append((x - 1, y))
if m - y - 1 and maps[x][y + 1] != '#' and not visit[x][y + 1]:
visit[x][y + 1] = visit[x][y] + 1
queue.append((x, y + 1))
if y and maps[x][y - 1] != '#' and not visit[x][y - 1]:
visit[x][y - 1] = visit[x][y] + 1
queue.append((x, y - 1))
elif maps[x][y] == '2':
if not second:
second = (x, y)
if n - x - 1 and maps[x + 1][y] in '.3' and not visit[x + 1][y]:
visit[x + 1][y] = visit[x][y] + 1
queue.append((x + 1, y))
elif n - x - 1 and maps[x + 1][y] == '2' and not visit[x + 1][y]:
visit[x + 1][y] = visit[x][y]
queue.appendleft((x + 1, y))
if x and maps[x - 1][y] in '.3' and not visit[x - 1][y]:
visit[x - 1][y] = visit[x][y] + 1
queue.append((x - 1, y))
elif x and maps[x - 1][y] == '2' and not visit[x - 1][y]:
visit[x - 1][y] = visit[x][y]
queue.appendleft((x - 1, y))
if m - y - 1 and maps[x][y + 1] in '.3' and not visit[x][y + 1]:
visit[x][y + 1] = visit[x][y] + 1
queue.append((x, y + 1))
elif m - y - 1 and maps[x][y + 1] == '2' and not visit[x + 1][y]:
visit[x][y + 1] = visit[x][y]
queue.appendleft((x, y + 1))
if y and maps[x][y - 1] in '.3' and not visit[x][y - 1]:
visit[x][y - 1] = visit[x][y] + 1
queue.append((x, y - 1))
elif y and maps[x][y - 1] == '2' and not visit[x][y - 1]:
visit[x][y - 1] = visit[x][y]
queue.appendleft((x, y - 1))
elif maps[x][y] == '3':
if not third:
third = (x, y)
if n - x - 1 and maps[x + 1][y] in '.2' and not visit[x + 1][y]:
visit[x + 1][y] = visit[x][y] + 1
queue.append((x + 1, y))
elif n - x - 1 and maps[x + 1][y] == '3' and not visit[x + 1][y]:
visit[x + 1][y] = visit[x][y]
queue.appendleft((x + 1, y))
if x and maps[x - 1][y] in '.2' and not visit[x - 1][y]:
visit[x - 1][y] = visit[x][y] + 1
queue.append((x - 1, y))
elif x and maps[x - 1][y] == '3' and not visit[x - 1][y]:
visit[x - 1][y] = visit[x][y]
queue.appendleft((x - 1, y))
if m - y - 1 and maps[x][y + 1] in '.2' and not visit[x][y + 1]:
visit[x][y + 1] = visit[x][y] + 1
queue.append((x, y + 1))
elif m - y - 1 and maps[x][y + 1] == '3' and not visit[x][y + 1]:
visit[x][y + 1] = visit[x][y]
queue.appendleft((x, y + 1))
if y and maps[x][y - 1] in '.2' and not visit[x][y - 1]:
visit[x][y - 1] = visit[x][y] + 1
queue.append((x, y - 1))
elif y and maps[x][y - 1] == '3' and not visit[x][y - 1]:
visit[x][y - 1] = visit[x][y]
queue.appendleft((x, y - 1))
if not third or not second:
print('-1')
else:
x, y = third
ans = 0
while maps[x][y] != '1':
if (x, y) not in cnt and (maps[x][y] == '.'):
ans += 1
cnt.add((x, y))
if x and visit[x - 1][y] < visit[x][y]:
x -= 1
elif n - x - 1 and visit[x + 1][y] < visit[x][y]:
x += 1
elif y and visit[x][y - 1] < visit[x][y]:
y -= 1
elif m - y - 1 and visit[x][y + 1] < visit[x][y]:
y += 1
if x and maps[x - 1][y] == '2':
second = 0
elif n - x - 1 and maps[x + 1][y] == '2':
second = 0
elif y and maps[x][y - 1] == '2':
second = 0
elif m - y - 1 and maps[x][y + 1] == '2':
second = 0
if maps[x][y] == '2':
x, y = second
second = 0
third = 0
if not second:
print(ans)
else:
x, y = second
while maps[x][y] != '1':
if (x, y) not in cnt and (maps[x][y] == '.'):
ans += 1
cnt.add((x, y))
if x and visit[x - 1][y] < visit[x][y]:
x -= 1
elif n - x - 1 and visit[x + 1][y] < visit[x][y]:
x += 1
elif y and visit[x][y - 1] < visit[x][y]:
y -= 1
elif m - y - 1 and visit[x][y + 1] < visit[x][y]:
y += 1
print(ans)
``` | instruction | 0 | 102,486 | 1 | 204,972 |
No | output | 1 | 102,486 | 1 | 204,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The famous global economic crisis is approaching rapidly, so the states of Berman, Berance and Bertaly formed an alliance and allowed the residents of all member states to freely pass through the territory of any of them. In addition, it was decided that a road between the states should be built to guarantee so that one could any point of any country can be reached from any point of any other State.
Since roads are always expensive, the governments of the states of the newly formed alliance asked you to help them assess the costs. To do this, you have been issued a map that can be represented as a rectangle table consisting of n rows and m columns. Any cell of the map either belongs to one of three states, or is an area where it is allowed to build a road, or is an area where the construction of the road is not allowed. A cell is called passable, if it belongs to one of the states, or the road was built in this cell. From any passable cells you can move up, down, right and left, if the cell that corresponds to the movement exists and is passable.
Your task is to construct a road inside a minimum number of cells, so that it would be possible to get from any cell of any state to any cell of any other state using only passable cells.
It is guaranteed that initially it is possible to reach any cell of any state from any cell of this state, moving only along its cells. It is also guaranteed that for any state there is at least one cell that belongs to it.
Input
The first line of the input contains the dimensions of the map n and m (1 β€ n, m β€ 1000) β the number of rows and columns respectively.
Each of the next n lines contain m characters, describing the rows of the map. Digits from 1 to 3 represent the accessory to the corresponding state. The character '.' corresponds to the cell where it is allowed to build a road and the character '#' means no construction is allowed in this cell.
Output
Print a single integer β the minimum number of cells you need to build a road inside in order to connect all the cells of all states. If such a goal is unachievable, print -1.
Examples
Input
4 5
11..2
#..22
#.323
.#333
Output
2
Input
1 5
1#2#3
Output
-1
Submitted Solution:
```
from collections import deque
infin = float('inf')
second = float('inf')
third = float('inf')
n, m = map(int, input().split())
visit = [[0 for i in range(m)] for j in range(n)]
maps = []
queue = deque()
for i in range(n):
maps.append(input())
for j in range(len(maps[i])):
if maps[i][j] in '1':
queue.append((i, j))
visit[i][j] = 1
def bfs(err):
global second, third
while queue:
x, y = queue.popleft()
if maps[x][y] == '2' and second > visit[x][y]:
second = visit[x][y]
if maps[x][y] == '3' and third > visit[x][y]:
third = visit[x][y]
if x + 1 < n and not visit[x + 1][y] and maps[x + 1][y] in '123.':
if maps[x + 1][y] == '.':
visit[x + 1][y] = visit[x][y] + 1
queue.append((x + 1, y))
else:
queue.appendleft((x + 1, y))
visit[x + 1][y] = visit[x][y]
if x and not visit[x - 1][y] and maps[x - 1][y] in '123.':
if maps[x - 1][y] == '.':
queue.append((x - 1, y))
visit[x - 1][y] = visit[x][y] + 1
else:
queue.appendleft((x - 1, y))
visit[x - 1][y] = visit[x][y]
if y + 1 < m and not visit[x][y + 1] and maps[x][y + 1] in '123.':
if maps[x][y + 1] == '.':
queue.append((x, y + 1))
visit[x][y + 1] = visit[x][y] + 1
else:
queue.appendleft((x, y + 1))
visit[x][y + 1] = visit[x][y]
if y and not visit[x][y - 1] and maps[x][y - 1] in '123.':
if maps[x][y - 1] == '.':
queue.append((x, y - 1))
visit[x][y - 1] = visit[x][y] + 1
else:
queue.appendleft((x, y - 1))
visit[x][y - 1] = visit[x][y]
bfs(0)
if second == infin or third == infin:
print('-1')
else:
print(max(second, third) - 1)
``` | instruction | 0 | 102,487 | 1 | 204,974 |
No | output | 1 | 102,487 | 1 | 204,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The famous global economic crisis is approaching rapidly, so the states of Berman, Berance and Bertaly formed an alliance and allowed the residents of all member states to freely pass through the territory of any of them. In addition, it was decided that a road between the states should be built to guarantee so that one could any point of any country can be reached from any point of any other State.
Since roads are always expensive, the governments of the states of the newly formed alliance asked you to help them assess the costs. To do this, you have been issued a map that can be represented as a rectangle table consisting of n rows and m columns. Any cell of the map either belongs to one of three states, or is an area where it is allowed to build a road, or is an area where the construction of the road is not allowed. A cell is called passable, if it belongs to one of the states, or the road was built in this cell. From any passable cells you can move up, down, right and left, if the cell that corresponds to the movement exists and is passable.
Your task is to construct a road inside a minimum number of cells, so that it would be possible to get from any cell of any state to any cell of any other state using only passable cells.
It is guaranteed that initially it is possible to reach any cell of any state from any cell of this state, moving only along its cells. It is also guaranteed that for any state there is at least one cell that belongs to it.
Input
The first line of the input contains the dimensions of the map n and m (1 β€ n, m β€ 1000) β the number of rows and columns respectively.
Each of the next n lines contain m characters, describing the rows of the map. Digits from 1 to 3 represent the accessory to the corresponding state. The character '.' corresponds to the cell where it is allowed to build a road and the character '#' means no construction is allowed in this cell.
Output
Print a single integer β the minimum number of cells you need to build a road inside in order to connect all the cells of all states. If such a goal is unachievable, print -1.
Examples
Input
4 5
11..2
#..22
#.323
.#333
Output
2
Input
1 5
1#2#3
Output
-1
Submitted Solution:
```
z=-1
print(z)
``` | instruction | 0 | 102,488 | 1 | 204,976 |
No | output | 1 | 102,488 | 1 | 204,977 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.