message stringlengths 2 22.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 16 109k | cluster float64 1 1 | __index_level_0__ int64 32 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 ≤ i ≤ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 106) — the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 ≤ ti, Ti, xi, costi ≤ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer — the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles. | instruction | 0 | 21,479 | 1 | 42,958 |
Tags: greedy
Correct Solution:
```
import sys
import math
info = [int(x) for x in sys.stdin.readline().split()]
n_stations, n_children = info[0], info[1]
min_sum = 0
for i in range(n_stations):
values = [int(x) for x in sys.stdin.readline().split()]
initial_temp, temp_limit, cost_demanded, bus_price = \
values[0], values[1], values[2], values[3]
if temp_limit - initial_temp > 0:
n_buses_no_penalty = int(math.ceil(n_children / (temp_limit - initial_temp)))
if n_buses_no_penalty * bus_price <= bus_price + n_children * cost_demanded:
min_sum += n_buses_no_penalty * bus_price
#print("No penalty", n_buses_no_penalty, "price", bus_price)
else:
min_sum += bus_price + n_children * cost_demanded
#print("Penalty", bus_price + n_children * cost_demanded)
else:
min_sum += bus_price + n_children * cost_demanded
print(min_sum)
``` | output | 1 | 21,479 | 1 | 42,959 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 ≤ i ≤ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 106) — the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 ≤ ti, Ti, xi, costi ≤ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer — the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles. | instruction | 0 | 21,480 | 1 | 42,960 |
Tags: greedy
Correct Solution:
```
import sys
n, m = map(int, sys.stdin.readline().split())
ans = 0
for _ in range(n):
ti, Ti, xi, ci = map(int, sys.stdin.readline().split())
cost = xi * m * (ti + m > Ti) + ci
if ti < Ti:
cost2 = ci * ((m - 1) // (Ti - ti) + 1)
cost = min(cost, cost2)
ans += cost
print(ans)
``` | output | 1 | 21,480 | 1 | 42,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 ≤ i ≤ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 106) — the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 ≤ ti, Ti, xi, costi ≤ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer — the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles. | instruction | 0 | 21,481 | 1 | 42,962 |
Tags: greedy
Correct Solution:
```
import math;
s = input()
a = s.find(" ")
n = int(s[0:a])
students = int(s[a+1:len(s)])
sum = 0
for i in range(n):
s = input()
a = s.find(" ")
temp = int(s[0:a])
s = s[a+1:len(s)]
a = s.find(" ")
maxTemp = int(s[0:a])
s = s[a+1:len(s)]
a = s.find(" ")
studentsCost = int(s[0:a])
s = s[a+1:len(s)]
busCost = int(s)
if temp + students < maxTemp:
oneBus = busCost
else:
oneBus = busCost + students * studentsCost
if temp < maxTemp:
diffTemp = maxTemp - temp
nBuses = math.ceil(students / diffTemp)
if nBuses != 0:
busesCost = nBuses * busCost
else:
busesCost = oneBus
else:
busesCost = oneBus
sum += min(oneBus, busesCost)
print(sum)
``` | output | 1 | 21,481 | 1 | 42,963 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 ≤ i ≤ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 106) — the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 ≤ ti, Ti, xi, costi ≤ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer — the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles. | instruction | 0 | 21,482 | 1 | 42,964 |
Tags: greedy
Correct Solution:
```
n, m = map(int, input().split())
s = 0
for i in range(n):
t, T, x, c = map(int, input().split())
k = T - t
if k > 0:
l = m // k
if l == 0: s += c
elif m == l * k: s += min(c * l, c + x * m)
else: s += min(c * (l + 1), c * l + x * (m - (l - 1) * k), c + x * m)
else: s += c + x * m
print(s)
``` | output | 1 | 21,482 | 1 | 42,965 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 ≤ i ≤ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 106) — the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 ≤ ti, Ti, xi, costi ≤ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer — the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles. | instruction | 0 | 21,483 | 1 | 42,966 |
Tags: greedy
Correct Solution:
```
import sys
input=sys.stdin.readline
l=input().split()
n=int(l[0])
m=int(l[1])
ans=0
for i in range(n):
l=input().split()
ti=int(l[0])
Ti=int(l[1])
xi=int(l[2])
cost=int(l[3])
if(ti>=Ti):
ans+=(xi*m)
ans+=cost
continue
maxcap=Ti-ti
if(maxcap*xi<=cost):
num1=0
num1+=(xi*m)
num1+=cost
ans+=min(num1,((m+maxcap-1)//maxcap)*cost)
continue
ans+=(((m+maxcap-1)//maxcap)*cost)
print(ans)
``` | output | 1 | 21,483 | 1 | 42,967 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 ≤ i ≤ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 106) — the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 ≤ ti, Ti, xi, costi ≤ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer — the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles. | instruction | 0 | 21,484 | 1 | 42,968 |
Tags: greedy
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz'
M=10**9+7
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n,m=value()
ans=0
for i in range(n):
t,T,x,cost=value()
here1=cost+(x*m)*int(t+m>T)
# print(t,T)
per_bus=T-t
if(per_bus<=0): here2=inf
else:
buses=Ceil(m,per_bus)
here2=cost*buses
ans+=min(here1,here2)
print(ans)
``` | output | 1 | 21,484 | 1 | 42,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 ≤ i ≤ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 106) — the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 ≤ ti, Ti, xi, costi ≤ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer — the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles.
Submitted Solution:
```
import sys
n, m = map(int, sys.stdin.readline().split())
ans = 0
for _ in range(n):
ti, Ti, xi, ci = map(int, sys.stdin.readline().split())
comps = xi * m
if m <= Ti - ti:
comps = 0
buses = 1
if ti + m > Ti and ti < Ti:
buses = m // (Ti - ti)
buses = max(buses, 1)
if comps + ci < buses * ci or ti >= Ti:
ans += comps + ci
else:
ans += buses * ci
print(ans)
``` | instruction | 0 | 21,485 | 1 | 42,970 |
No | output | 1 | 21,485 | 1 | 42,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 ≤ i ≤ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 106) — the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 ≤ ti, Ti, xi, costi ≤ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer — the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles.
Submitted Solution:
```
import sys
n, m = map(int, sys.stdin.readline().split())
ans = 0
for _ in range(n):
ti, Ti, xi, ci = map(int, sys.stdin.readline().split())
comps = xi * m
if ti <= Ti and m <= Ti - ti:
comps = 0
buses = float('inf')
if ti < Ti:
buses = max(1, (m - 1) // (Ti - ti) + 1)
else:
buses = 1
ans += min(buses * ci, comps + ci)
print(ans)
``` | instruction | 0 | 21,486 | 1 | 42,972 |
No | output | 1 | 21,486 | 1 | 42,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 ≤ i ≤ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 106) — the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 ≤ ti, Ti, xi, costi ≤ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer — the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles.
Submitted Solution:
```
import sys
input=sys.stdin.readline
l=input().split()
n=int(l[0])
m=int(l[1])
ans=0
for i in range(n):
l=input().split()
ti=int(l[0])
Ti=int(l[1])
xi=int(l[2])
cost=int(l[3])
if(ti>=Ti):
ans+=(xi*m)
ans+=cost
continue
maxcap=Ti-ti
if(maxcap*xi<=cost):
num1=0
num1+=(xi*m)
num1+=cost
ans+=min(num1,((m+maxcap-1)/maxcap)*cost)
continue
ans+=(((m+maxcap-1)/maxcap)*cost)
print(ans)
``` | instruction | 0 | 21,487 | 1 | 42,974 |
No | output | 1 | 21,487 | 1 | 42,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 ≤ i ≤ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 106) — the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 ≤ ti, Ti, xi, costi ≤ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer — the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles.
Submitted Solution:
```
n, m = [int(x) for x in input().split()]
num = 0
for i in range(n):
t, T, x, cost = [int(x) for x in input().split()]
if T >= (t + m):
num += cost
else:
k = T - t
#print(m//n)
#print(x * m + cost, k)
if (k == 0) or (m // k == 0):
num += x * m + cost
else:
num += min(x * m + cost, cost * (m // k))
print(num)
#print(t, T, x, cost)
``` | instruction | 0 | 21,488 | 1 | 42,976 |
No | output | 1 | 21,488 | 1 | 42,977 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Volodya has recently visited a very odd town. There are N tourist attractions in the town and every two of them are connected by a bidirectional road. Each road has some travel price (natural number) assigned to it and all prices are distinct. But the most striking thing about this town is that each city sightseeing tour has the same total price! That is, if we choose any city sightseeing tour — a cycle which visits every attraction exactly once — the sum of the costs of the tour roads is independent of the tour. Volodya is curious if you can find such price system with all road prices not greater than 1000.
Input
Input contains just one natural number (3 ≤ N ≤ 20) — the number of town attractions.
Output
Output should contain N rows containing N positive integer numbers each — the adjacency matrix of the prices graph (thus, j-th number in i-th row should be equal to the price of the road between the j-th and the i-th attraction). Diagonal numbers should be equal to zero. All numbers should not be greater than 1000. All prices should be positive and pairwise distinct. If there are several solutions, output any of them.
Examples
Input
3
Output
0 3 4
3 0 5
4 5 0 | instruction | 0 | 21,552 | 1 | 43,104 |
Tags: constructive algorithms, math
Correct Solution:
```
#codeforces 42d: strange town: math, constructive algorithm
def readGen(trans):
while 1:
for x in input().split():
yield(trans(x))
readint=readGen(int)
n=next(readint)
def constructRow(n):
can=[1 for i in range(1001)]
b=[0 for i in range(n+1)]
b[2]=1
b[3]=2
can[1]=0
can[2]=0
for k in range(4,n+1):
b[k]=b[k-1]+1
while (not can[b[k]]): b[k]+=1
can[b[k]]=0
for i in range(2,k):
for p in range(2,k):
can[b[k]+b[p]-b[i]]=0
return b
def constructMatrix(b,n):
can=[1 for i in range(1001)]
for i in range(2,n+1):
for j in range(2,n+1):
for p in range(2,n+1):
can[b[2]+b[3]+b[p]-b[i]-b[j]]=0
x=1
while (not can[x]): x+=1
a=[[0 for j in range(n+1)] for i in range(n+1)]
for i in range(n+1):
a[1][i]=a[i][1]=b[i]
for i in range(2,n+1):
for j in range(i+1,n+1):
a[i][j]=a[j][i]=b[i]+b[j]+x-b[2]-b[3]
return a
b=constructRow(n)
#print(b)
a=constructMatrix(b,n)
for i in range(1,n+1):
for j in range(1,n+1):
print("{:4}".format(a[i][j]),end='')
print()
``` | output | 1 | 21,552 | 1 | 43,105 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Volodya has recently visited a very odd town. There are N tourist attractions in the town and every two of them are connected by a bidirectional road. Each road has some travel price (natural number) assigned to it and all prices are distinct. But the most striking thing about this town is that each city sightseeing tour has the same total price! That is, if we choose any city sightseeing tour — a cycle which visits every attraction exactly once — the sum of the costs of the tour roads is independent of the tour. Volodya is curious if you can find such price system with all road prices not greater than 1000.
Input
Input contains just one natural number (3 ≤ N ≤ 20) — the number of town attractions.
Output
Output should contain N rows containing N positive integer numbers each — the adjacency matrix of the prices graph (thus, j-th number in i-th row should be equal to the price of the road between the j-th and the i-th attraction). Diagonal numbers should be equal to zero. All numbers should not be greater than 1000. All prices should be positive and pairwise distinct. If there are several solutions, output any of them.
Examples
Input
3
Output
0 3 4
3 0 5
4 5 0 | instruction | 0 | 21,553 | 1 | 43,106 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
massa = [1]
i = 2
d = set()
while( len(massa) != n ):
test = True
for el in massa:
if(el + i in d):
test = False
break
if(test == True):
for el in massa:
d.add(el+i)
massa.append(i)
i=i+1
for b in massa:
ans=""
for el in massa:
ans+="0 " if b==el else str(b+el)+" "
print ( ans )
``` | output | 1 | 21,553 | 1 | 43,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one kingdom there are n cities and m two-way roads. Each road connects a pair of cities, and for each road we know the level of drivers dissatisfaction — the value wi.
For each road we know the value ci — how many lamziks we should spend to reduce the level of dissatisfaction with this road by one. Thus, to reduce the dissatisfaction with the i-th road by k, we should spend k·ci lamziks. And it is allowed for the dissatisfaction to become zero or even negative.
In accordance with the king's order, we need to choose n - 1 roads and make them the main roads. An important condition must hold: it should be possible to travel from any city to any other by the main roads.
The road ministry has a budget of S lamziks for the reform. The ministry is going to spend this budget for repair of some roads (to reduce the dissatisfaction with them), and then to choose the n - 1 main roads.
Help to spend the budget in such a way and then to choose the main roads so that the total dissatisfaction with the main roads will be as small as possible. The dissatisfaction with some roads can become negative. It is not necessary to spend whole budget S.
It is guaranteed that it is possible to travel from any city to any other using existing roads. Each road in the kingdom is a two-way road.
Input
The first line contains two integers n and m (2 ≤ n ≤ 2·105, n - 1 ≤ m ≤ 2·105) — the number of cities and the number of roads in the kingdom, respectively.
The second line contains m integers w1, w2, ..., wm (1 ≤ wi ≤ 109), where wi is the drivers dissatisfaction with the i-th road.
The third line contains m integers c1, c2, ..., cm (1 ≤ ci ≤ 109), where ci is the cost (in lamziks) of reducing the dissatisfaction with the i-th road by one.
The next m lines contain the description of the roads. The i-th of this lines contain a pair of integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) which mean that the i-th road connects cities ai and bi. All roads are two-way oriented so it is possible to move by the i-th road from ai to bi, and vice versa. It is allowed that a pair of cities is connected by more than one road.
The last line contains one integer S (0 ≤ S ≤ 109) — the number of lamziks which we can spend for reforms.
Output
In the first line print K — the minimum possible total dissatisfaction with main roads.
In each of the next n - 1 lines print two integers x, vx, which mean that the road x is among main roads and the road x, after the reform, has the level of dissatisfaction vx.
Consider that roads are numbered from 1 to m in the order as they are given in the input data. The edges can be printed in arbitrary order. If there are several answers, print any of them.
Examples
Input
6 9
1 3 1 1 3 1 2 2 2
4 1 4 2 2 5 3 1 6
1 2
1 3
2 3
2 4
2 5
3 5
3 6
4 5
5 6
7
Output
0
1 1
3 1
6 1
7 2
8 -5
Input
3 3
9 5 1
7 7 2
2 1
3 1
3 2
2
Output
5
3 0
2 5
Submitted Solution:
```
# Solution to Drivers Dissatisfaction, problem F of Round 378 Div 2.
# http://codeforces.com/contest/733/problem/F
from collections import namedtuple
from math import sqrt, ceil, log
# Read input.
num_cities, num_roads = [int(i) for i in input().split()]
dissatisfaction = [int(i) for i in input().split()]
cost = [int(i) for i in input().split()]
roads = []
for road in range(num_roads):
src, end = [int(node) for node in input().split()]
roads.append((src, end))
money = int(input())
# Find a MST reducing dissatisfaction.
def prims_algorithm(roads, num_cities, num_roads):
covered = [False for i in range(num_cities+1)]
covered[0] = True # dummy city
covered[1] = True # choose random city
result = []
while not all(covered):
min_dissatisfaction = float('inf')
min_road_idx = -1
for i in range(num_roads):
src, end = roads[i]
if covered[src] and covered[end]:
continue
if not covered[src] and not covered[end]:
continue
if dissatisfaction[i] < min_dissatisfaction:
min_dissatisfaction = dissatisfaction[i]
min_road_idx = i
result.append(min_road_idx)
covered[roads[min_road_idx][0]] = True
covered[roads[min_road_idx][1]] = True
return result
def bfs(node, mst, roads):
result = set()
vertices = { node }
while True:
prev_len = len(result)
for edge in mst:
src, end = roads[edge]
if src in vertices or end in vertices:
result.add(edge)
vertices.add(src)
vertices.add(end)
if len(result) == prev_len:
break
return result
InternalNode = namedtuple('InternalNode', ('id', 'diss', 'level', 'parent'))
LeafNode = namedtuple('LeafNode', ('id', 'level', 'parent'))
reverse_leaves = dict()
def prepare_for_lca(parent, root, mst, roads, dissatisfaction, cost,
money, level, info):
max_idx = -1
max_dissatisfaction = float('-inf')
mst = set(mst)
for edge in mst:
d = dissatisfaction[edge] - money // cost[edge]
if d > max_dissatisfaction:
max_dissatisfaction = d
max_idx = edge
src, end = roads[max_idx]
info[root] = InternalNode(max_idx, max_dissatisfaction, level, parent)
edges = []
vertices = [root]
mst = mst - { max_idx }
left_mst = bfs(src, mst, roads)
if len(left_mst) > 0:
left_root, left_edges, left_verts = prepare_for_lca(root,
root+1, left_mst,
roads,
dissatisfaction,
cost, money,
level+1, info)
edges.append((root, left_root))
edges.extend(left_edges)
vertices.extend(left_verts)
else:
info[root+1] = LeafNode(src, level+1, root)
reverse_leaves[src] = root+1
edges.append((root, root+1))
vertices.append(root+1)
right_mst = mst - left_mst
if len(right_mst) > 0:
right_root, right_edges, right_verts = \
prepare_for_lca(root,
len(vertices)+root,
right_mst,
roads,
dissatisfaction,
cost, money,
level+1, info)
edges.append((root, right_root))
edges.extend(right_edges)
vertices.extend(right_verts)
else:
info[len(vertices)+root] = LeafNode(end, level+1, root)
reverse_leaves[end] = len(vertices)+root
edges.append((root, len(vertices)+root))
vertices.append(len(vertices)+root)
return root, edges, vertices
def compute_pow_ancestor(root, edges, vertices, info):
sqrt_len = int(sqrt(len(vertices))) + 3
pow_ancestor = [[0 for i in range(sqrt_len)]
for node in vertices]
for vertex in vertices:
pow_ancestor[vertex][0] = info[vertex].parent
for i in range(1, sqrt_len):
for vertex in vertices:
prev = pow_ancestor[vertex][i-1]
pow_ancestor[vertex][i] = pow_ancestor[prev][i-1]
return pow_ancestor
def lca(u, v, pow_ancestor, info):
if info[v].level > info[u].level:
u, v = v, u
k = ceil(log(u, 2))
for i in range(k, -1, -1):
new_u = pow_ancestor[u][i]
if info[new_u].level >= info[v].level:
u = new_u
if u == v:
return u
for i in range(k, -1, -1):
if pow_ancestor[u][i] != pow_ancestor[v][i]:
u = pow_ancestor[u][i]
v = pow_ancestor[v][i]
else:
break
while info[u].parent != info[v].parent:
u = info[u].parent
v = info[v].parent
return info[u].parent
mst = prims_algorithm(roads, num_cities, num_roads)
info = dict()
root, edges, vertices = prepare_for_lca(0, 0, mst, roads, dissatisfaction,
cost, money, 1, info)
#print("Tree: ", root, edges, vertices)
#print("info: ", info)
pow_ancestor = compute_pow_ancestor(root, edges, vertices, info)
#print("Pow_ancestor: ", pow_ancestor)
#print("Lca of {} and {}: {}".format(10, 4, lca(10, 4, pow_ancestor, info)))
#print(reverse_leaves)
min_tot_dissatisfaction = sum([dissatisfaction[idx] for idx in mst])
main_roads = [roads[idx] for idx in mst]
#print(mst)
#print(main_roads)
#print(min_tot_dissatisfaction)
edge_to_delete = -1
max_saved = 0
new_edge = None
new_edge_diss = 0
for edge in range(num_roads):
if edge not in mst:
src, end = roads[edge]
test_diss = dissatisfaction[edge] - money // cost[edge]
old_edge = lca(reverse_leaves[src], reverse_leaves[end],
pow_ancestor, info)
id, diss, level, parent = info[old_edge]
if test_diss < diss:
saved = diss - test_diss
if max_saved < saved:
max_saved = saved
edge_to_delete = info[old_edge].id
new_edge = edge
new_edge_diss = test_diss
#print("edge to delete: ", roads[edge_to_delete])
#print("new edge: ", roads[new_edge])
# OUTPUT
if new_edge is not None:
print(min_tot_dissatisfaction + new_edge_diss
- dissatisfaction[edge_to_delete])
mst = set(mst) | {new_edge}
mst = mst - {edge_to_delete}
dissatisfaction[new_edge] = new_edge_diss
else:
new_edge = mst[0]
new_edge_diss = dissatisfaction[0] - money // cost[0]
for edge in mst:
test_diss = dissatisfaction[edge] - money // cost[edge]
if test_diss < new_edge_diss:
new_edge_diss = test_diss
new_edge = edge
print(min_tot_dissatisfaction + new_edge_diss
- dissatisfaction[new_edge])
dissatisfaction[new_edge] = new_edge_diss
for edge in mst:
print(edge+1, dissatisfaction[edge])
``` | instruction | 0 | 21,656 | 1 | 43,312 |
No | output | 1 | 21,656 | 1 | 43,313 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one kingdom there are n cities and m two-way roads. Each road connects a pair of cities, and for each road we know the level of drivers dissatisfaction — the value wi.
For each road we know the value ci — how many lamziks we should spend to reduce the level of dissatisfaction with this road by one. Thus, to reduce the dissatisfaction with the i-th road by k, we should spend k·ci lamziks. And it is allowed for the dissatisfaction to become zero or even negative.
In accordance with the king's order, we need to choose n - 1 roads and make them the main roads. An important condition must hold: it should be possible to travel from any city to any other by the main roads.
The road ministry has a budget of S lamziks for the reform. The ministry is going to spend this budget for repair of some roads (to reduce the dissatisfaction with them), and then to choose the n - 1 main roads.
Help to spend the budget in such a way and then to choose the main roads so that the total dissatisfaction with the main roads will be as small as possible. The dissatisfaction with some roads can become negative. It is not necessary to spend whole budget S.
It is guaranteed that it is possible to travel from any city to any other using existing roads. Each road in the kingdom is a two-way road.
Input
The first line contains two integers n and m (2 ≤ n ≤ 2·105, n - 1 ≤ m ≤ 2·105) — the number of cities and the number of roads in the kingdom, respectively.
The second line contains m integers w1, w2, ..., wm (1 ≤ wi ≤ 109), where wi is the drivers dissatisfaction with the i-th road.
The third line contains m integers c1, c2, ..., cm (1 ≤ ci ≤ 109), where ci is the cost (in lamziks) of reducing the dissatisfaction with the i-th road by one.
The next m lines contain the description of the roads. The i-th of this lines contain a pair of integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) which mean that the i-th road connects cities ai and bi. All roads are two-way oriented so it is possible to move by the i-th road from ai to bi, and vice versa. It is allowed that a pair of cities is connected by more than one road.
The last line contains one integer S (0 ≤ S ≤ 109) — the number of lamziks which we can spend for reforms.
Output
In the first line print K — the minimum possible total dissatisfaction with main roads.
In each of the next n - 1 lines print two integers x, vx, which mean that the road x is among main roads and the road x, after the reform, has the level of dissatisfaction vx.
Consider that roads are numbered from 1 to m in the order as they are given in the input data. The edges can be printed in arbitrary order. If there are several answers, print any of them.
Examples
Input
6 9
1 3 1 1 3 1 2 2 2
4 1 4 2 2 5 3 1 6
1 2
1 3
2 3
2 4
2 5
3 5
3 6
4 5
5 6
7
Output
0
1 1
3 1
6 1
7 2
8 -5
Input
3 3
9 5 1
7 7 2
2 1
3 1
3 2
2
Output
5
3 0
2 5
Submitted Solution:
```
x,y = [int(x) for x in input().split()]
if x == 6:
print('''0
1 1
3 1
6 1
7 2
8 -5''')
elif x == 7:
print('''38
3 4
5 4
6 4
1 8
4 8
2 10''')
else:
print('''5
3 0
2 5''')
``` | instruction | 0 | 21,657 | 1 | 43,314 |
No | output | 1 | 21,657 | 1 | 43,315 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one kingdom there are n cities and m two-way roads. Each road connects a pair of cities, and for each road we know the level of drivers dissatisfaction — the value wi.
For each road we know the value ci — how many lamziks we should spend to reduce the level of dissatisfaction with this road by one. Thus, to reduce the dissatisfaction with the i-th road by k, we should spend k·ci lamziks. And it is allowed for the dissatisfaction to become zero or even negative.
In accordance with the king's order, we need to choose n - 1 roads and make them the main roads. An important condition must hold: it should be possible to travel from any city to any other by the main roads.
The road ministry has a budget of S lamziks for the reform. The ministry is going to spend this budget for repair of some roads (to reduce the dissatisfaction with them), and then to choose the n - 1 main roads.
Help to spend the budget in such a way and then to choose the main roads so that the total dissatisfaction with the main roads will be as small as possible. The dissatisfaction with some roads can become negative. It is not necessary to spend whole budget S.
It is guaranteed that it is possible to travel from any city to any other using existing roads. Each road in the kingdom is a two-way road.
Input
The first line contains two integers n and m (2 ≤ n ≤ 2·105, n - 1 ≤ m ≤ 2·105) — the number of cities and the number of roads in the kingdom, respectively.
The second line contains m integers w1, w2, ..., wm (1 ≤ wi ≤ 109), where wi is the drivers dissatisfaction with the i-th road.
The third line contains m integers c1, c2, ..., cm (1 ≤ ci ≤ 109), where ci is the cost (in lamziks) of reducing the dissatisfaction with the i-th road by one.
The next m lines contain the description of the roads. The i-th of this lines contain a pair of integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) which mean that the i-th road connects cities ai and bi. All roads are two-way oriented so it is possible to move by the i-th road from ai to bi, and vice versa. It is allowed that a pair of cities is connected by more than one road.
The last line contains one integer S (0 ≤ S ≤ 109) — the number of lamziks which we can spend for reforms.
Output
In the first line print K — the minimum possible total dissatisfaction with main roads.
In each of the next n - 1 lines print two integers x, vx, which mean that the road x is among main roads and the road x, after the reform, has the level of dissatisfaction vx.
Consider that roads are numbered from 1 to m in the order as they are given in the input data. The edges can be printed in arbitrary order. If there are several answers, print any of them.
Examples
Input
6 9
1 3 1 1 3 1 2 2 2
4 1 4 2 2 5 3 1 6
1 2
1 3
2 3
2 4
2 5
3 5
3 6
4 5
5 6
7
Output
0
1 1
3 1
6 1
7 2
8 -5
Input
3 3
9 5 1
7 7 2
2 1
3 1
3 2
2
Output
5
3 0
2 5
Submitted Solution:
```
class MyList:
def __init__(self):
self.length = 0
self.head = None
self.tail = None
def push(self, new_node):
new_node.prev = self
if self.head is None:
self.head = new_node
else:
self.tail.next = new_node
self.tail = new_node
self.length += 1
def print_forward(self):
node = self.head
while node:
print(node)
node = node.next
class Node:
def __init__(self, cargo=None, prev=None, next=None):
self.cargo = cargo
self.prev = prev
self.next = next
def __str__(self):
return str(self.cargo)
def make_set(x):
l = MyList()
l.push(x)
return l
def union(x, y):
if x.prev.length > y.prev.length:
node = y.prev.head
while node:
x.prev.push(node)
node = node.next
else:
node = x.prev.head
while node:
y.prev.push(node)
node = node.next
def find_set(x):
return x.prev
def kruskal(nodes, edges, s):
result = []
tot = 0
for v in nodes.values():
make_set(v)
while edges:
(u, v, d, c, i) = min(edges.values(), key=lambda e: e[2] - s // e[3])
if find_set(u) != find_set(v):
j = s // c
result.append((u.cargo, v.cargo, d - j, i))
tot += d - j
s -= c * j
union(u, v)
del edges[(u.cargo, v.cargo)]
return tot, result
n, m = [int(i) for i in input().split()]
d = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
nodes = set()
edges = []
for i in range(m):
u, v = [int(j) for j in input().split()]
edges.append((u, v, d[i], c[i], i+1))
nodes.add(u)
nodes.add(v)
s = int(input())
nodes = { n:Node(n) for n in nodes }
edges = { (u, v):(nodes[u], nodes[v], d, c, i) for (u, v, d, c, i) in edges }
tot, result = kruskal(nodes, edges, s)
print(tot)
for (u, v, d, i) in result:
print(i, d)
``` | instruction | 0 | 21,658 | 1 | 43,316 |
No | output | 1 | 21,658 | 1 | 43,317 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In one kingdom there are n cities and m two-way roads. Each road connects a pair of cities, and for each road we know the level of drivers dissatisfaction — the value wi.
For each road we know the value ci — how many lamziks we should spend to reduce the level of dissatisfaction with this road by one. Thus, to reduce the dissatisfaction with the i-th road by k, we should spend k·ci lamziks. And it is allowed for the dissatisfaction to become zero or even negative.
In accordance with the king's order, we need to choose n - 1 roads and make them the main roads. An important condition must hold: it should be possible to travel from any city to any other by the main roads.
The road ministry has a budget of S lamziks for the reform. The ministry is going to spend this budget for repair of some roads (to reduce the dissatisfaction with them), and then to choose the n - 1 main roads.
Help to spend the budget in such a way and then to choose the main roads so that the total dissatisfaction with the main roads will be as small as possible. The dissatisfaction with some roads can become negative. It is not necessary to spend whole budget S.
It is guaranteed that it is possible to travel from any city to any other using existing roads. Each road in the kingdom is a two-way road.
Input
The first line contains two integers n and m (2 ≤ n ≤ 2·105, n - 1 ≤ m ≤ 2·105) — the number of cities and the number of roads in the kingdom, respectively.
The second line contains m integers w1, w2, ..., wm (1 ≤ wi ≤ 109), where wi is the drivers dissatisfaction with the i-th road.
The third line contains m integers c1, c2, ..., cm (1 ≤ ci ≤ 109), where ci is the cost (in lamziks) of reducing the dissatisfaction with the i-th road by one.
The next m lines contain the description of the roads. The i-th of this lines contain a pair of integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) which mean that the i-th road connects cities ai and bi. All roads are two-way oriented so it is possible to move by the i-th road from ai to bi, and vice versa. It is allowed that a pair of cities is connected by more than one road.
The last line contains one integer S (0 ≤ S ≤ 109) — the number of lamziks which we can spend for reforms.
Output
In the first line print K — the minimum possible total dissatisfaction with main roads.
In each of the next n - 1 lines print two integers x, vx, which mean that the road x is among main roads and the road x, after the reform, has the level of dissatisfaction vx.
Consider that roads are numbered from 1 to m in the order as they are given in the input data. The edges can be printed in arbitrary order. If there are several answers, print any of them.
Examples
Input
6 9
1 3 1 1 3 1 2 2 2
4 1 4 2 2 5 3 1 6
1 2
1 3
2 3
2 4
2 5
3 5
3 6
4 5
5 6
7
Output
0
1 1
3 1
6 1
7 2
8 -5
Input
3 3
9 5 1
7 7 2
2 1
3 1
3 2
2
Output
5
3 0
2 5
Submitted Solution:
```
class MyList:
def __init__(self):
self.length = 0
self.head = None
self.tail = None
def push(self, new_node):
new_node.prev = self
if self.head is None:
self.head = new_node
else:
self.tail.next = new_node
self.tail = new_node
self.length += 1
def print_forward(self):
node = self.head
while node:
print(node)
node = node.next
class Node:
def __init__(self, cargo=None, prev=None, next=None):
self.cargo = cargo
self.prev = prev
self.next = next
def __str__(self):
return str(self.cargo)
def make_set(x):
l = MyList()
l.push(x)
return l
def union(x, y):
if x.prev.length > y.prev.length:
node = y.prev.head
while node:
x.prev.push(node)
node = node.next
else:
node = x.prev.head
while node:
y.prev.push(node)
node = node.next
def find_set(x):
return x.prev
def kruskal(nodes, edges, s):
result = []
tot = 0
for v in nodes.values():
make_set(v)
while edges:
if s > 0:
(u, v, d, c, i) = min(edges.values(), key=lambda e: e[2] - s // e[3])
else:
(u, v, d, c, i) = min(edges.values(), key=lambda e: e[2])
if find_set(u) != find_set(v):
if s > 0:
j = s // c
result.append((u.cargo, v.cargo, d - j, i))
tot += d - j
s -= c * j
union(u, v)
else:
result.append((u.cargo, v.cargo, d, i))
tot += d
union(u, v)
del edges[(u.cargo, v.cargo)]
return tot, result
n, m = [int(i) for i in input().split()]
d = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
nodes = set()
edges = []
for i in range(m):
u, v = [int(j) for j in input().split()]
edges.append((u, v, d[i], c[i], i+1))
nodes.add(u)
nodes.add(v)
s = int(input())
nodes = { n:Node(n) for n in nodes }
edges = { (u, v):(nodes[u], nodes[v], d, c, i) for (u, v, d, c, i) in edges }
tot, result = kruskal(nodes, edges, s)
print(tot)
for (u, v, d, i) in result:
print(i, d)
``` | instruction | 0 | 21,659 | 1 | 43,318 |
No | output | 1 | 21,659 | 1 | 43,319 |
Provide a correct Python 3 solution for this coding contest problem.
JOI Park
In preparation for the Olympic Games in IOI in 20XX, the JOI Park in IOI will be developed. There are N squares in JOI Park, and the squares are numbered from 1 to N. There are M roads connecting the squares, and the roads are numbered from 1 to M. The road i (1 ≤ i ≤ M) connects the square Ai and the square Bi in both directions, and the length is Di. You can follow several paths from any square to any square.
In the maintenance plan, first select an integer X of 0 or more, and connect all the squares (including square 1) whose distance from square 1 is X or less to each other by an underpass. However, the distance between the square i and the square j is the minimum value of the sum of the lengths of the roads taken when going from the square i to the square j. In the maintenance plan, the integer C for the maintenance cost of the underpass is fixed. The cost of developing an underpass is C x X.
Next, remove all the roads connecting the plazas connected by the underpass. There is no cost to remove the road. Finally, repair all the roads that remained unremoved. The cost of repairing a road of length d is d. There is no underpass in JOI Park before the implementation of the maintenance plan. Find the minimum sum of the costs of developing the JOI Park.
Task
Given the information on the JOI Park Square and an integer for the underpass maintenance cost, create a program to find the minimum sum of the costs for the JOI Park maintenance.
input
Read the following data from standard input.
* On the first line, the integers N, M, and C are written with blanks as delimiters. This means that there are N squares, M roads, and the integer for the underpass maintenance cost is C.
* On the i-th line (1 ≤ i ≤ M) of the following M lines, the integers Ai, Bi, and Di are written separated by blanks. This means that the road i connects the square Ai and the square Bi, and the length is Di.
output
Output an integer representing the minimum sum of the costs of developing the JOI park to the standard output on one line.
Limits
All input data satisfy the following conditions.
* 2 ≤ N ≤ 100 000.
* 1 ≤ M ≤ 200 000.
* 1 ≤ C ≤ 100 000.
* 1 ≤ Ai ≤ N (1 ≤ i ≤ M).
* 1 ≤ Bi ≤ N (1 ≤ i ≤ M).
* Ai ≠ Bi (1 ≤ i ≤ M).
* (Ai, Bi) ≠ (Aj, Bj) and (Ai, Bi) ≠ (Bj, Aj) (1 ≤ i <j ≤ M).
* 1 ≤ Di ≤ 100 000 (1 ≤ i ≤ M).
* With the input data given, it is guaranteed that you can go from any square to any square by following several paths.
Input / output example
Input example 1
5 5 2
2 3 1
3 1 2
2 4 3
1 2 4
2 5 5
Output example 1
14
In this input example, when X = 3, the sum of the maintenance costs when all the squares (square 1, square 2, square 3) whose distance from square 1 is 3 or less are connected to each other by an underpass. Is 2 × 3 + 3 + 5 = 14. This is the minimum value.
Input example 2
5 4 10
one two Three
2 3 4
3 4 3
4 5 5
Output example 2
15
In this input example, the sum of maintenance costs is minimized when X = 0.
Input example 3
6 5 2
1 2 2
1 3 4
1 4 3
1 5 1
1 6 5
Output example 3
Ten
In this input example, when all the squares are connected to each other by an underpass with X = 5, the sum of the maintenance costs is minimized.
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
5 5 2
2 3 1
3 1 2
2 4 3
1 2 4
2 5 5
Output
14 | instruction | 0 | 21,956 | 1 | 43,912 |
"Correct Solution:
```
from heapq import heappush, heappop
INF = 10 ** 20
n, m, c = map(int, input().split())
edges = [[] for _ in range(n)]
edges_dict = {}
d_cost = 0
for _ in range(m):
a, b, d = map(int, input().split())
a -= 1
b -= 1
edges[a].append((b, d))
edges[b].append((a, d))
edges_dict[(a, b)] = d
d_cost += d
dist = [INF] * n
dist[0] = 0
que = []
heappush(que, (0, 0))
while que:
total, node = heappop(que)
for to, d in edges[node]:
if dist[to] > total + d:
dist[to] = total + d
heappush(que, (total + d, to))
removal = {}
for t, d in edges_dict.items():
max_d = max(dist[t[0]], dist[t[1]])
if max_d in removal:
removal[max_d] += d
else:
removal[max_d] = d
ans = d_cost
for k, v in sorted(removal.items()):
d_cost -= v
if d_cost + k * c < ans:
ans = d_cost + k * c
print(ans)
``` | output | 1 | 21,956 | 1 | 43,913 |
Provide a correct Python 3 solution for this coding contest problem.
JOI Park
In preparation for the Olympic Games in IOI in 20XX, the JOI Park in IOI will be developed. There are N squares in JOI Park, and the squares are numbered from 1 to N. There are M roads connecting the squares, and the roads are numbered from 1 to M. The road i (1 ≤ i ≤ M) connects the square Ai and the square Bi in both directions, and the length is Di. You can follow several paths from any square to any square.
In the maintenance plan, first select an integer X of 0 or more, and connect all the squares (including square 1) whose distance from square 1 is X or less to each other by an underpass. However, the distance between the square i and the square j is the minimum value of the sum of the lengths of the roads taken when going from the square i to the square j. In the maintenance plan, the integer C for the maintenance cost of the underpass is fixed. The cost of developing an underpass is C x X.
Next, remove all the roads connecting the plazas connected by the underpass. There is no cost to remove the road. Finally, repair all the roads that remained unremoved. The cost of repairing a road of length d is d. There is no underpass in JOI Park before the implementation of the maintenance plan. Find the minimum sum of the costs of developing the JOI Park.
Task
Given the information on the JOI Park Square and an integer for the underpass maintenance cost, create a program to find the minimum sum of the costs for the JOI Park maintenance.
input
Read the following data from standard input.
* On the first line, the integers N, M, and C are written with blanks as delimiters. This means that there are N squares, M roads, and the integer for the underpass maintenance cost is C.
* On the i-th line (1 ≤ i ≤ M) of the following M lines, the integers Ai, Bi, and Di are written separated by blanks. This means that the road i connects the square Ai and the square Bi, and the length is Di.
output
Output an integer representing the minimum sum of the costs of developing the JOI park to the standard output on one line.
Limits
All input data satisfy the following conditions.
* 2 ≤ N ≤ 100 000.
* 1 ≤ M ≤ 200 000.
* 1 ≤ C ≤ 100 000.
* 1 ≤ Ai ≤ N (1 ≤ i ≤ M).
* 1 ≤ Bi ≤ N (1 ≤ i ≤ M).
* Ai ≠ Bi (1 ≤ i ≤ M).
* (Ai, Bi) ≠ (Aj, Bj) and (Ai, Bi) ≠ (Bj, Aj) (1 ≤ i <j ≤ M).
* 1 ≤ Di ≤ 100 000 (1 ≤ i ≤ M).
* With the input data given, it is guaranteed that you can go from any square to any square by following several paths.
Input / output example
Input example 1
5 5 2
2 3 1
3 1 2
2 4 3
1 2 4
2 5 5
Output example 1
14
In this input example, when X = 3, the sum of the maintenance costs when all the squares (square 1, square 2, square 3) whose distance from square 1 is 3 or less are connected to each other by an underpass. Is 2 × 3 + 3 + 5 = 14. This is the minimum value.
Input example 2
5 4 10
one two Three
2 3 4
3 4 3
4 5 5
Output example 2
15
In this input example, the sum of maintenance costs is minimized when X = 0.
Input example 3
6 5 2
1 2 2
1 3 4
1 4 3
1 5 1
1 6 5
Output example 3
Ten
In this input example, when all the squares are connected to each other by an underpass with X = 5, the sum of the maintenance costs is minimized.
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
5 5 2
2 3 1
3 1 2
2 4 3
1 2 4
2 5 5
Output
14 | instruction | 0 | 21,957 | 1 | 43,914 |
"Correct Solution:
```
from heapq import heappush, heappop
N, M, C = map(int, input().split())
G = [[] for i in range(N)]
E = []
for i in range(M):
a, b, d = map(int, input().split()); a -= 1; b -= 1
G[a].append((b, d))
G[b].append((a, d))
E.append((a, b, d))
INF = 10**18
dist = [INF]*N
dist[0] = 0
que = [(0, 0)]
while que:
cost, v = heappop(que)
if dist[v] < cost:
continue
for w, d in G[v]:
if cost + d < dist[w]:
dist[w] = cost + d
heappush(que, (cost + d, w))
*I, = range(N)
I.sort(key = dist.__getitem__)
K = [0]*N
for i, e in enumerate(I):
K[e] = i
Q = [0]*N
su = 0
for a, b, d in E:
if K[a] < K[b]:
Q[b] += d
else:
Q[a] += d
su += d
ans = 10**18
cu = 0
for v in I:
x = dist[v]
cu += Q[v]
ans = min(ans, C*x + (su - cu))
print(ans)
``` | output | 1 | 21,957 | 1 | 43,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C. | instruction | 0 | 22,068 | 1 | 44,136 |
Tags: binary search, brute force, two pointers
Correct Solution:
```
from bisect import bisect_left as lb
n, m, x, y, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
mx=0
if(k>=n or k>=m):
exit(print(-1))
for i in range(k+1):
pos=lb(b,a[i]+x)
if(m-pos<=k-i):
exit(print(-1))
mx=max(mx,b[pos+(k-i)]+y)
print(mx)
``` | output | 1 | 22,068 | 1 | 44,137 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C. | instruction | 0 | 22,069 | 1 | 44,138 |
Tags: binary search, brute force, two pointers
Correct Solution:
```
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
from bisect import bisect_left as lower_bound, bisect_right as upper_bound
def so(): return int(input())
def st(): return input()
def mj(): return map(int,input().strip().split(" "))
def msj(): return map(str,input().strip().split(" "))
def le(): return list(map(int,input().split()))
def dmain():
sys.setrecursionlimit(1000000)
threading.stack_size(1024000)
thread = threading.Thread(target=main)
thread.start()
def decimalToBinary(n): return bin(n).replace("0b","")
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def tr(n):
return n*(n+1)//2
def main():
for i in range(1):
a,b,c,d,e=mj()
L=le()
P=le()
if(a>=b):
h=b
else:
h=a
if(h>e):
p=0
q=0
for u in range(1+e):
while(b>p and P[p]<L[u]+c):
p=p+1
if(p+e>=u+b):
print(-1)
exit()
q=max(d+P[p-u+e],q)
print(q)
else:
print(-1)
# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
main()
#dmain()
# Comment Read()
``` | output | 1 | 22,069 | 1 | 44,139 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C. | instruction | 0 | 22,070 | 1 | 44,140 |
Tags: binary search, brute force, two pointers
Correct Solution:
```
n, m, ta, tb, k = map(int, input().split())
a = [*map(int, input().split())]
b = [*map(int, input().split())]
a = [i + ta for i in a]
from bisect import bisect_left
ans = 0
if k >= min(n, m):
print(-1)
exit()
for i in range(k + 1):
t = bisect_left(b, a[i])
if t + k - i < m:
ans = max(ans, b[t + k - i] + tb)
else:
ans = -1
break
print(ans)
``` | output | 1 | 22,070 | 1 | 44,141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C. | instruction | 0 | 22,071 | 1 | 44,142 |
Tags: binary search, brute force, two pointers
Correct Solution:
```
from bisect import*
i=lambda:[*map(int,input().split())]
try:_,_,t,u,k=i();a=i();b=i();print(max(u+b[bisect_left(b,a[x]+t)+k-x]for x in range(k+1)))
except:print(-1)
``` | output | 1 | 22,071 | 1 | 44,143 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C. | instruction | 0 | 22,072 | 1 | 44,144 |
Tags: binary search, brute force, two pointers
Correct Solution:
```
from sys import stdin
import math
from collections import defaultdict
import bisect
#stdin = open('input.txt','r')
def upper(arr,x,n):
start = 0
end = n
while(start<end):
mid = (start+end)//2
if(x>arr[mid]):
start = mid+1
else:
end = mid
return start
I = stdin.readline
n,m,ta,tb,k = map(int,I().split())
a = [int(x)+ta for x in I().split()]
b = [int(x) for x in I().split()]
#print(a)
#rint(b)
if(k>=n or k>=m): print(-1)
else:
ans=-1
for i in range(k+1):
x = upper(b,a[i],m)
ind = x+k-i
if(ind>=m):
ans=-1
break
else:
ans = max(ans,b[ind]+tb)
print(ans)
``` | output | 1 | 22,072 | 1 | 44,145 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C. | instruction | 0 | 22,073 | 1 | 44,146 |
Tags: binary search, brute force, two pointers
Correct Solution:
```
import sys,math
def read_int():
return int(sys.stdin.readline().strip())
def read_int_list():
return list(map(int,sys.stdin.readline().strip().split()))
def read_string():
return sys.stdin.readline().strip()
def read_string_list(delim=" "):
return sys.stdin.readline().strip().split(delim)
###### Author : Samir Vyas #######
###### Write Code Below #######
from bisect import bisect_left
n,m,ta,tb,k = read_int_list()
arr = read_int_list()
for i in range(n):
arr[i] += ta
dep = read_int_list()
dep.append(float("inf"))
#chop
if k >= min(m,n) or arr[0] > dep[-1]:
print(-1)
sys.exit()
ans = -1
for i in range(0,k+1):
#chop first i flights of arr
start_pos = min(i,n-1)
end_pos = min(bisect_left(dep, arr[start_pos]) + k-i, m)
if dep[end_pos] == float("inf"):
print(-1)
sys.exit()
ans = max(ans, dep[end_pos] + tb)
print(ans)
``` | output | 1 | 22,073 | 1 | 44,147 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C. | instruction | 0 | 22,074 | 1 | 44,148 |
Tags: binary search, brute force, two pointers
Correct Solution:
```
import bisect
import sys
input = sys.stdin.readline
n, m, ta, tb, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a = [i+ta for i in a]
ans = 0
for i in range(n):
cancel = k-i
if cancel >= 0:
if cancel+bisect.bisect_left(b, a[i]) >= m:
ans = -1
break
else:
ans = max(b[cancel+bisect.bisect_left(b, a[i])], ans)
else:
break
if k >= min(n, m):
ans = -1
if ans == -1:
print(-1)
else:
print(ans+tb)
``` | output | 1 | 22,074 | 1 | 44,149 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C. | instruction | 0 | 22,075 | 1 | 44,150 |
Tags: binary search, brute force, two pointers
Correct Solution:
```
import bisect
n,m,ta,tb,k=map(int,input().split(" "))
a=list(map(int,input().split(" ")))
b=list(map(int,input().split(" ")))
ans=0
try:
for i in range(0,k+1):
l=bisect.bisect_left(b,a[i]+ta)
t=l+k-i
ans= max(ans,b[t]+tb)
print(ans)
except:
print(-1)
``` | output | 1 | 22,075 | 1 | 44,151 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C.
Submitted Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
from bisect import *
def main():
n,m,ta,tb,k=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
if k>=n:
print(-1)
else:
ma=0
for i in range(k,-1,-1):
z=bisect_left(b,a[i]+ta)
z+=(k-i)
if z>=m:
ma=-1
break
ma=max(ma,b[z]+tb)
print(ma)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | instruction | 0 | 22,076 | 1 | 44,152 |
Yes | output | 1 | 22,076 | 1 | 44,153 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C.
Submitted Solution:
```
import bisect
n, m, ta, tb, k = map(int, input().split())
*a, = map(int, input().split())
*b, = map(int, input().split())
ans = -1
for ki in range(k+1):
if ki < n:
bi = bisect.bisect_left(b, a[ki] + ta) + k - ki
if bi < m:
ans = max(ans, b[bi]+tb)
else:
ans = -1
break
else:
ans = -1
break
print(ans)
``` | instruction | 0 | 22,077 | 1 | 44,154 |
Yes | output | 1 | 22,077 | 1 | 44,155 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C.
Submitted Solution:
```
n,m,ta,tb,k = map(int,input().split())
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
res = -1
j = 0
if k < len(A):
for i in range(k+1):
if i < len(A):
t = A[i] + ta
while j < len(B) and B[j] < t:
j += 1
togo = k - i
jj = j + togo
if jj < len(B):
res = max(res, B[jj] + tb)
else:
res = -1
break
print(res)
``` | instruction | 0 | 22,078 | 1 | 44,156 |
Yes | output | 1 | 22,078 | 1 | 44,157 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C.
Submitted Solution:
```
#------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
import sys
def countGreater(arr, n, k):
l = 0
r = n - 1
leftGreater = n
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
else:
l = m + 1
return (n - leftGreater)
ans=0
n,m,ta,tb,k=map(int,input().split())
l=list(map(int,input().split()))
l1=list(map(int,input().split()))
if k>=n or k>=m:
print(-1)
sys.exit()
for i in range(k+1):
ind=countGreater(l1,m,l[i]+ta)
#print(ind)
ind=m-ind
ind+=(k-i)
#print(ind,"i")
if ind>=m:
print(-1)
sys.exit()
else:
ans=max(ans,l1[ind]+tb)
print(ans)
``` | instruction | 0 | 22,079 | 1 | 44,158 |
Yes | output | 1 | 22,079 | 1 | 44,159 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
##########################################################
def prime_factors(x):
s=set()
n=x
i=2
while i*i<=n:
if n%i==0:
while n%i==0:
n//=i
s.add(i)
i+=1
if n>1:
s.add(n)
return s
from collections import Counter
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
import heapq
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
# n = int(input())
# ls = list(map(int, input().split()))
# n, k = map(int, input().split())
# n =int(input())
#arr=[(i,x) for i,x in enum]
#arr.sort(key=lambda x:x[0])
#print(arr)
#import math
# e=list(map(int, input().split()))
from collections import Counter
#print("\n".join(ls))
#print(os.path.commonprefix(ls[0:2]))
#n=int(input())
from bisect import bisect_right
#d=sorted(d,key=lambda x:(len(d[x]),-x)) d=dictionary d={x:set() for x in arr}
#n=int(input())
#n,m,k= map(int, input().split())
import heapq
#for _ in range(int(input())):
#n,k=map(int, input().split())
#input=sys.stdin.buffer.readline
#for _ in range(int(input())):
#n=int(input())
n,m,t1,t2,k = map(int, input().split())
arr = list(map(int, input().split()))
ls= list(map(int, input().split()))
tt=k
i=0
j=0
ans=-1
while i<n and j<m:
while j<m and arr[i]+t1>ls[j]:
j+=1
if k>0:
if i+1<n and j<m and arr[i+1]+t1<=ls[j]:
j+=1
else:
i+=1
k-=1
else:
ans=ls[j]
break
if ans==-1 or n<=tt or m<=tt:
print(-1)
else:
print(ans+t2)
import bisect
``` | instruction | 0 | 22,080 | 1 | 44,160 |
No | output | 1 | 22,080 | 1 | 44,161 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C.
Submitted Solution:
```
n,m,ta,tb,k=map(int,input().split())
an=list(map(int,input().split()))
bn=list(map(int,input().split()))
if n<=k:
print(-1)
else:
an=[i+ta for i in an]
start=0
end=m
mta=[]
obn=bn[:]
bn.append(float('inf'))
bn=[-float('inf')]+bn
for i in range(k,-1,-1):
if i>0:
start=0
s=an[i-1]
while start<=end:
mid=(start+end)//2
if bn[mid]<s and s<=bn[mid]:
break
elif bn[mid]>=s:
end=mid-1
else:
start=mid+1
if (mid+k-i)>=m:
print(-1)
break
else:
mta.append(obn[mid+k-i]+tb)
else:
if k>=m:
print(-1)
break
else:
mta.append(obn[k]+tb)
else:
print(max(mta))
``` | instruction | 0 | 22,081 | 1 | 44,162 |
No | output | 1 | 22,081 | 1 | 44,163 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C.
Submitted Solution:
```
from collections import *
from math import *
import array
import bisect
cin = lambda : [*map(int, input().split())]
def upper_bound(a, x):
l = 0
r = len(a) - 1
while l < r:
m = int((l + r + 1) / 2)
if a[m] <= x:
l = m
else:
r = m - 1
return l
if __name__ == '__main__':
n, m, ta, tb, k = cin()
a = array.array('i', cin())
b = array.array('i', cin())
if k >= min(n, m):
print('-1')
exit()
ans = 0
try:
for i in range(k + 1):
# l = upper_bound(b, a[i] + ta)
l = bisect.bisect_left(b, a[i] + ta)
if b[l] < a[i] + ta:
l += 1
j = k - i
l += j
if l > len(b):
print('-1')
exit()
ans = max(ans, b[l] + tb)
print(ans)
except:
print('-1')
exit()
``` | instruction | 0 | 22,082 | 1 | 44,164 |
No | output | 1 | 22,082 | 1 | 44,165 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j ≥ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ n + m, 1 ≤ t_a, t_b ≤ 10^9) — the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 ≤ a_1 < a_2 < … < a_n ≤ 10^9) — the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 ≤ b_1 < b_2 < … < b_m ≤ 10^9) — the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C.
Submitted Solution:
```
n,m,ta,tb,k = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
if min(n,m)<=k:
print(-1)
else:
i=j=0
ans=0
c=0
while i<n and j<m:
while j<m and b[j]<a[i]+ta:
j+=1
if j==m:
ans=-1
break
ans=max(ans,b[j]+tb)
c+=1
if c==k+1:
break
if a[i+1]-a[i]>b[j+1]-b[j] and a[i+1]+ta >b[j+1]:
i+=1
else:
j+=1
print(ans)
``` | instruction | 0 | 22,083 | 1 | 44,166 |
No | output | 1 | 22,083 | 1 | 44,167 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In some country there are exactly n cities and m bidirectional roads connecting the cities. Cities are numbered with integers from 1 to n. If cities a and b are connected by a road, then in an hour you can go along this road either from city a to city b, or from city b to city a. The road network is such that from any city you can get to any other one by moving along the roads.
You want to destroy the largest possible number of roads in the country so that the remaining roads would allow you to get from city s1 to city t1 in at most l1 hours and get from city s2 to city t2 in at most l2 hours.
Determine what maximum number of roads you need to destroy in order to meet the condition of your plan. If it is impossible to reach the desired result, print -1.
Input
The first line contains two integers n, m (1 ≤ n ≤ 3000, <image>) — the number of cities and roads in the country, respectively.
Next m lines contain the descriptions of the roads as pairs of integers ai, bi (1 ≤ ai, bi ≤ n, ai ≠ bi). It is guaranteed that the roads that are given in the description can transport you from any city to any other one. It is guaranteed that each pair of cities has at most one road between them.
The last two lines contains three integers each, s1, t1, l1 and s2, t2, l2, respectively (1 ≤ si, ti ≤ n, 0 ≤ li ≤ n).
Output
Print a single number — the answer to the problem. If the it is impossible to meet the conditions, print -1.
Examples
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 2
Output
0
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
2 4 2
Output
1
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 1
Output
-1 | instruction | 0 | 22,476 | 1 | 44,952 |
Tags: constructive algorithms, graphs, shortest paths
Correct Solution:
```
from itertools import combinations_with_replacement
from collections import deque
#sys.stdin = open("input_py.txt","r")
n, m = map(int, input().split())
G = [ [] for i in range(n)]
for i in range(m):
x, y = map(int, input().split())
x-=1; y-=1
G[x].append(y)
G[y].append(x)
def BFS(s):
dist = [-1 for i in range(n)]
dist[s] = 0
Q = deque()
Q.append(s)
while len(Q) > 0:
v = Q.popleft()
for to in G[v]:
if dist[to] < 0:
dist[to] = dist[v] + 1
Q.append(to)
return dist
Dist = [BFS(i) for i in range(n)]
s1, t1, l1 = map(int, input(). split())
s2, t2, l2 = map(int, input(). split())
s1-=1; t1-=1; s2-=1; t2-=1
if Dist[s1][t1] > l1 or Dist[s2][t2] > l2:
print(-1)
exit(0)
rest = Dist[s1][t1] + Dist[s2][t2]
for i in range(n):
for j in range(n):
if Dist[i][s1] + Dist[i][j] + Dist[j][t1] <= l1 and Dist[i][s2] + Dist[i][j] + Dist[j][t2] <= l2 :
rest = min(rest, Dist[i][j] + Dist[i][s1] + Dist[i][s2] + Dist[j][t1] + Dist[j][t2])
if Dist[i][s1] + Dist[i][j] + Dist[j][t1] <= l1 and Dist[j][s2] + Dist[i][j] + Dist[i][t2] <= l2 :
rest = min(rest, Dist[i][j] + Dist[j][t1] + Dist[j][s2] + Dist[i][s1] + Dist[i][t2])
print(m-rest)
``` | output | 1 | 22,476 | 1 | 44,953 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In some country there are exactly n cities and m bidirectional roads connecting the cities. Cities are numbered with integers from 1 to n. If cities a and b are connected by a road, then in an hour you can go along this road either from city a to city b, or from city b to city a. The road network is such that from any city you can get to any other one by moving along the roads.
You want to destroy the largest possible number of roads in the country so that the remaining roads would allow you to get from city s1 to city t1 in at most l1 hours and get from city s2 to city t2 in at most l2 hours.
Determine what maximum number of roads you need to destroy in order to meet the condition of your plan. If it is impossible to reach the desired result, print -1.
Input
The first line contains two integers n, m (1 ≤ n ≤ 3000, <image>) — the number of cities and roads in the country, respectively.
Next m lines contain the descriptions of the roads as pairs of integers ai, bi (1 ≤ ai, bi ≤ n, ai ≠ bi). It is guaranteed that the roads that are given in the description can transport you from any city to any other one. It is guaranteed that each pair of cities has at most one road between them.
The last two lines contains three integers each, s1, t1, l1 and s2, t2, l2, respectively (1 ≤ si, ti ≤ n, 0 ≤ li ≤ n).
Output
Print a single number — the answer to the problem. If the it is impossible to meet the conditions, print -1.
Examples
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 2
Output
0
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
2 4 2
Output
1
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 1
Output
-1 | instruction | 0 | 22,477 | 1 | 44,954 |
Tags: constructive algorithms, graphs, shortest paths
Correct Solution:
```
import sys
from collections import deque
n, m = [int(i) for i in sys.stdin.readline().split()]
neighbors = [set() for _ in range(n)]
for i in range(m):
m1, m2 = [int(i) for i in sys.stdin.readline().split()]
neighbors[m1-1].add(m2-1)
neighbors[m2-1].add(m1-1)
s1, t1, l1 = [int(i) for i in sys.stdin.readline().split()]
s2, t2, l2 = [int(i) for i in sys.stdin.readline().split()]
s1 -= 1
s2 -= 1
t1 -= 1
t2 -= 1
# compute all pairs distance
dists = [[0 for _ in range(n)] for _ in range(n)]
for i in range(n):
# bfs
q = deque([(i, 0)])
visited = [False for _ in range(n)]
visited[i] = True
while len(q) != 0:
v, dist = q.popleft()
dists[i][v] = dist
for neighbor in neighbors[v]:
if not visited[neighbor]:
q.append((neighbor, dist+1))
visited[neighbor] = True
best_found = m+1
# first case: 2 paths don't share edge
if dists[s1][t1] <= l1 and dists[s2][t2] <= l2:
best_found = min(best_found, dists[s1][t1] + dists[s2][t2])
# second case: there are points u, v such that they share path along u-v
for u in range(n):
for v in range(n):
if u == v:
continue
# case 1: s1-u-v-t1, s2-u-v-t2
path1_length = dists[s1][u] + dists[u][v] + dists[v][t1]
path2_length = dists[s2][u] + dists[u][v] + dists[v][t2]
if path1_length <= l1 and path2_length <= l2:
total_length = path1_length + path2_length - dists[u][v]
best_found = min(best_found, total_length)
# case 2: s1-u-v-t1, s2-v-u-t2
path1_length = dists[s1][u] + dists[u][v] + dists[v][t1]
path2_length = dists[s2][v] + dists[v][u] + dists[u][t2]
if path1_length <= l1 and path2_length <= l2:
total_length = path1_length + path2_length - dists[u][v]
best_found = min(best_found, total_length)
# case 3: s1-v-u-t1, s2-u-v-t2
path1_length = dists[s1][v] + dists[v][u] + dists[u][t1]
path2_length = dists[s2][u] + dists[u][v] + dists[v][t2]
if path1_length <= l1 and path2_length <= l2:
total_length = path1_length + path2_length - dists[u][v]
best_found = min(best_found, total_length)
# case 4: s1-v-u-t1, s2-v-u-t2
path1_length = dists[s1][v] + dists[v][u] + dists[u][t1]
path2_length = dists[s2][v] + dists[v][u] + dists[u][t2]
if path1_length <= l1 and path2_length <= l2:
total_length = path1_length + path2_length - dists[u][v]
best_found = min(best_found, total_length)
print(m - best_found)
``` | output | 1 | 22,477 | 1 | 44,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In some country there are exactly n cities and m bidirectional roads connecting the cities. Cities are numbered with integers from 1 to n. If cities a and b are connected by a road, then in an hour you can go along this road either from city a to city b, or from city b to city a. The road network is such that from any city you can get to any other one by moving along the roads.
You want to destroy the largest possible number of roads in the country so that the remaining roads would allow you to get from city s1 to city t1 in at most l1 hours and get from city s2 to city t2 in at most l2 hours.
Determine what maximum number of roads you need to destroy in order to meet the condition of your plan. If it is impossible to reach the desired result, print -1.
Input
The first line contains two integers n, m (1 ≤ n ≤ 3000, <image>) — the number of cities and roads in the country, respectively.
Next m lines contain the descriptions of the roads as pairs of integers ai, bi (1 ≤ ai, bi ≤ n, ai ≠ bi). It is guaranteed that the roads that are given in the description can transport you from any city to any other one. It is guaranteed that each pair of cities has at most one road between them.
The last two lines contains three integers each, s1, t1, l1 and s2, t2, l2, respectively (1 ≤ si, ti ≤ n, 0 ≤ li ≤ n).
Output
Print a single number — the answer to the problem. If the it is impossible to meet the conditions, print -1.
Examples
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 2
Output
0
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
2 4 2
Output
1
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 1
Output
-1
Submitted Solution:
```
import sys
from collections import deque
n, m = [int(i) for i in sys.stdin.readline().split()]
neighbors = [set() for _ in range(n)]
for i in range(m):
m1, m2 = [int(i) for i in sys.stdin.readline().split()]
neighbors[m1-1].add(m2-1)
neighbors[m2-1].add(m1-1)
s1, t1, l1 = [int(i) for i in sys.stdin.readline().split()]
s2, t2, l2 = [int(i) for i in sys.stdin.readline().split()]
s1 -= 1
s2 -= 1
t1 -= 1
t2 -= 1
# compute all pairs distance
dists = [[0 for _ in range(n)] for _ in range(n)]
for i in range(n):
# bfs
q = deque([(i, 0)])
visited = [False for _ in range(n)]
while len(q) != 0:
v, dist = q.popleft()
dists[i][v] = dist
visited[v] = True
for neighbor in neighbors[v]:
if not visited[neighbor]:
q.append((neighbor, dist+1))
best_found = m+1
# first case: 2 paths don't share edge
if dists[s1][t1] <= l1 and dists[s2][t2] <= l2:
best_found = min(best_found, dists[s1][t1] + dists[s2][t2])
# second case: there are points u, v such that they share path along u-v
for u in range(n):
for v in range(n):
if u == v:
continue
# case 1: s1-u-v-t1, s2-u-v-t2
path1_length = dists[s1][u] + dists[u][v] + dists[v][t1]
path2_length = dists[s2][u] + dists[u][v] + dists[v][t2]
if path1_length <= l1 and path2_length <= l2:
total_length = path1_length + path2_length - dists[u][v]
best_found = min(best_found, total_length)
# case 2: s1-u-v-t1, s2-v-u-t2
path1_length = dists[s1][u] + dists[u][v] + dists[v][t1]
path2_length = dists[s2][v] + dists[v][u] + dists[u][t2]
if path1_length <= l1 and path2_length <= l2:
total_length = path1_length + path2_length - dists[u][v]
best_found = min(best_found, total_length)
# case 3: s1-v-u-t1, s2-u-v-t2
path1_length = dists[s1][v] + dists[v][u] + dists[u][t1]
path2_length = dists[s2][u] + dists[u][v] + dists[v][t2]
if path1_length <= l1 and path2_length <= l2:
total_length = path1_length + path2_length - dists[u][v]
best_found = min(best_found, total_length)
# case 4: s1-v-u-t1, s2-v-u-t2
path1_length = dists[s1][v] + dists[v][u] + dists[u][t1]
path2_length = dists[s2][v] + dists[v][u] + dists[u][t2]
if path1_length <= l1 and path2_length <= l2:
total_length = path1_length + path2_length - dists[u][v]
best_found = min(best_found, total_length)
print(m - best_found)
``` | instruction | 0 | 22,478 | 1 | 44,956 |
No | output | 1 | 22,478 | 1 | 44,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In some country there are exactly n cities and m bidirectional roads connecting the cities. Cities are numbered with integers from 1 to n. If cities a and b are connected by a road, then in an hour you can go along this road either from city a to city b, or from city b to city a. The road network is such that from any city you can get to any other one by moving along the roads.
You want to destroy the largest possible number of roads in the country so that the remaining roads would allow you to get from city s1 to city t1 in at most l1 hours and get from city s2 to city t2 in at most l2 hours.
Determine what maximum number of roads you need to destroy in order to meet the condition of your plan. If it is impossible to reach the desired result, print -1.
Input
The first line contains two integers n, m (1 ≤ n ≤ 3000, <image>) — the number of cities and roads in the country, respectively.
Next m lines contain the descriptions of the roads as pairs of integers ai, bi (1 ≤ ai, bi ≤ n, ai ≠ bi). It is guaranteed that the roads that are given in the description can transport you from any city to any other one. It is guaranteed that each pair of cities has at most one road between them.
The last two lines contains three integers each, s1, t1, l1 and s2, t2, l2, respectively (1 ≤ si, ti ≤ n, 0 ≤ li ≤ n).
Output
Print a single number — the answer to the problem. If the it is impossible to meet the conditions, print -1.
Examples
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 2
Output
0
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
2 4 2
Output
1
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 1
Output
-1
Submitted Solution:
```
from itertools import combinations_with_replacement
from collections import deque
#sys.stdin = open("input_py.txt","r")
n, m = map(int, input().split())
G = [ [] for i in range(n)]
for i in range(m):
x, y = map(int, input().split())
x-=1; y-=1
G[x].append(y)
G[y].append(x)
def BFS(s):
dist = [-1 for i in range(n)]
dist[s] = 0
Q = deque()
Q.append(s)
while len(Q) > 0:
v = Q.popleft()
for to in G[v]:
if dist[to] < 0:
dist[to] = dist[v] + 1
Q.append(to)
return dist
Dist = [BFS(i) for i in range(n)]
s1, t1, l1 = map(int, input(). split())
s2, t2, l2 = map(int, input(). split())
s1-=1; t1-=1; s2-=1; t2-=1
if Dist[s1][t1] > l1 or Dist[s2][t2] > l2:
print(-1)
exit(0)
rest = Dist[s1][t1] + Dist[s2][t2]
for i in range(n):
for j in range(i,n):
if Dist[s1][i] + Dist[i][j] + Dist[j][t1] <= l1 and Dist[s2][i] + Dist[i][j] + Dist[j][t2] <= l2:
rest = min(rest, Dist[s1][i] + Dist[i][j] + Dist[j][t1] + Dist[s2][i] + Dist[j][t2])
print(m-rest)
``` | instruction | 0 | 22,479 | 1 | 44,958 |
No | output | 1 | 22,479 | 1 | 44,959 |
Provide a correct Python 3 solution for this coding contest problem.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000 | instruction | 0 | 22,703 | 1 | 45,406 |
"Correct Solution:
```
def warshall_floyd(G, n):
global c
for i in range(n):
for j in range(n):
b = 1
for k in range(n):
if j == k or i == k:
continue
if G[i][j] == G[i][k] + G[k][j]:
b = 0
elif G[i][j] > G[i][k] + G[k][j]:
print(-1)
exit()
if b == 1:
c += G[i][j]
n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
c = 0
warshall_floyd(a, n)
print(c // 2)
``` | output | 1 | 22,703 | 1 | 45,407 |
Provide a correct Python 3 solution for this coding contest problem.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000 | instruction | 0 | 22,704 | 1 | 45,408 |
"Correct Solution:
```
N = int(input())
A = [list(map(int, input().split())) for _ in range(N)]
flg_list = [[True] * N for _ in range(N)]
for k in range(N):
for i in range(N):
for j in range(N):
if A[i][j] > A[i][k] + A[k][j]:
print(-1)
exit()
if A[i][j] == A[i][k] + A[k][j] and i != k and k != j:
flg_list[i][j] = flg_list[j][i] = False
ans = 0
for i in range(N):
for j in range(N):
if flg_list[i][j]:
ans += A[i][j]
print(ans//2)
``` | output | 1 | 22,704 | 1 | 45,409 |
Provide a correct Python 3 solution for this coding contest problem.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000 | instruction | 0 | 22,705 | 1 | 45,410 |
"Correct Solution:
```
n=int(input())
a=[list(map(int,input().split())) for _ in [0]*n]
for i in range(n):
for j in range(n):
for k in range(n):
if a[i][j] > a[i][k] + a[k][j]:
print(-1)
exit()
ans=0
for i in range(n):
for j in range(i+1,n):
for k in range(n):
if i != k and j != k and a[i][j] == a[i][k] + a[k][j]:
break
else:
ans += a[i][j]
print(ans)
``` | output | 1 | 22,705 | 1 | 45,411 |
Provide a correct Python 3 solution for this coding contest problem.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000 | instruction | 0 | 22,706 | 1 | 45,412 |
"Correct Solution:
```
import heapq
import sys
N = int(input())
r = [[1]*N for _ in range(N)]
g = [[]*N for _ in range(N)]
all = 0
for i in range(N):
temp = list(map(int,(input().split())))
g[i] = temp
all += sum(temp)
#print(g,all)
for k in range(N):
for i in range(N):
for j in range(N):
if g[i][j] > g[i][k] + g[k][j]:
print("-1")
sys.exit()
elif g[i][j] == g[i][k] + g[k][j] and i != j and j != k and k != i:
r[i][j] = 0
ans = 0
for i in range(N):
for j in range(N):
ans += g[i][j]*r[i][j]
ans = ans//2
print(ans)
``` | output | 1 | 22,706 | 1 | 45,413 |
Provide a correct Python 3 solution for this coding contest problem.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000 | instruction | 0 | 22,707 | 1 | 45,414 |
"Correct Solution:
```
import sys
from copy import deepcopy
N = int(input())
A = [[int(x) for x in input().split()] for _ in range(N)]
B = deepcopy(A)
for k in range(N):
for i in range(N):
for j in range(N):
if i == j or j == k or k == i:
continue
if A[i][k] + A[k][j] < A[i][j]:
print(-1)
sys.exit()
elif A[i][k] + A[k][j] == A[i][j]:
B[i][j] = 0
ans = sum(sum(B[i][j] for j in range(N)) for i in range(N)) // 2
print(ans)
``` | output | 1 | 22,707 | 1 | 45,415 |
Provide a correct Python 3 solution for this coding contest problem.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000 | instruction | 0 | 22,708 | 1 | 45,416 |
"Correct Solution:
```
import copy
N = int(input())
graph = []
for i in range(N):
graph.append( list(map(int,input().split())) )
dp = copy.deepcopy(graph)
for k in range(N):
for i in range(N):
for j in range(N):
dp[i][j] = min(dp[i][j], dp[i][k]+dp[k][j])
res = 0
for i in range(N):
for j in range(N):
if dp[i][j] < graph[i][j]:
print(-1)
exit()
elif dp[i][j] == graph[i][j]:
flg = True
for k in range(N):
if k!=i and k!=j and dp[i][j] == dp[i][k]+dp[k][j]:
flg = False
if flg:
res += dp[i][j]
print(res//2)
``` | output | 1 | 22,708 | 1 | 45,417 |
Provide a correct Python 3 solution for this coding contest problem.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000 | instruction | 0 | 22,709 | 1 | 45,418 |
"Correct Solution:
```
N = int(input())
A = [list(map(int, input().split())) for _ in range(N)]
for k in range(N):
for i in range(N):
for j in range(N):
#
if A[i][j] > A[i][k] + A[k][j]:
print(-1)
exit()
ans = 0
for i in range(N):
for j in range(i+1,N):
f = True
for k in range(N):
if k == i or k == j:
continue
if A[i][j] == A[i][k] + A[k][j]:
f = False
break
if f:
#辺i->jを足す
ans += A[i][j]
print(ans)
``` | output | 1 | 22,709 | 1 | 45,419 |
Provide a correct Python 3 solution for this coding contest problem.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000 | instruction | 0 | 22,710 | 1 | 45,420 |
"Correct Solution:
```
import copy
n=int(input())
a=[]
ans=0
for _ in range(n):
b=list(map(int,input().split()))
ans+=sum(b)
a.append(b)
c=copy.deepcopy(a)
for i in range(n):
for j in range(n):
ch=0
for k in range(n):
if c[i][j]==c[i][k]+c[k][j] and ch==0 and i!=k and j!=k:
ans-=c[i][j]
ch+=1
c[i][j]=min(c[i][j],c[i][k]+c[k][j])
if a==c:
print(ans//2)
else:
print(-1)
``` | output | 1 | 22,710 | 1 | 45,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000
Submitted Solution:
```
from copy import deepcopy
INF=10**18
n=int(input())
a=[list(map(int,input().split())) for _ in range(n)]
c=deepcopy(a)
for k in range(n):
for i in range(n):
for j in range(n):
c[i][j]=min(c[i][j],c[i][k]+c[k][j])
for i in range(n):
for j in range(n):
if a[i][j]!=c[i][j]:
print(-1)
exit()
ans=0
for i in range(n):
for j in range(n):
for k in range(n):
if k==j or k==i:continue
if c[i][j]==c[i][k]+c[k][j]:break
else:ans+=c[i][j]
print(ans//2)
``` | instruction | 0 | 22,711 | 1 | 45,422 |
Yes | output | 1 | 22,711 | 1 | 45,423 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000
Submitted Solution:
```
n = int(input())
a = [list(map(int, input().split())) for i in range(n)]
b = [[1]*n for i in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
if a[i][k] + a[k][j] < a[i][j]:
print(-1)
exit()
elif a[i][k] + a[k][j] == a[i][j] and i!=k!=j:
b[i][j] = 0
ans = 0
for i in range(n):
for j in range(n):
if b[i][j]:
ans += a[i][j]
print(ans//2)
``` | instruction | 0 | 22,712 | 1 | 45,424 |
Yes | output | 1 | 22,712 | 1 | 45,425 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000
Submitted Solution:
```
n = int(input())
a = [list(map(int,input().split())) for _ in range(n)]
ans = 0
for i in range(n):
for j in range(i,n):
if i==j:
continue
dp = 10**9+1
for k in range(n):
if k==j or k==i:
continue
dp = min(dp,a[i][k]+a[k][j])
if a[i][j]<dp:
ans += a[i][j]
elif a[i][j]>dp:
print(-1)
exit()
print(ans)
``` | instruction | 0 | 22,713 | 1 | 45,426 |
Yes | output | 1 | 22,713 | 1 | 45,427 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i ≠ j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000
Submitted Solution:
```
def main():
n = int(input())
m = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n - 1):
for j in range(i + 1, n):
d = m[i][j]
t = min(m[i][k] + m[k][j] if k != i and k != j else d + 1 for k in range(n))
if t < d:
print(-1)
exit()
if d < t:
ans += d
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 22,714 | 1 | 45,428 |
Yes | output | 1 | 22,714 | 1 | 45,429 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.