message stringlengths 2 22.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 16 109k | cluster float64 1 1 | __index_level_0__ int64 32 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Helen works in Metropolis airport. She is responsible for creating a departure schedule. There are n flights that must depart today, the i-th of them is planned to depart at the i-th minute of the day.
Metropolis airport is the main transport hub of Metropolia, so it is difficult to keep the schedule intact. This is exactly the case today: because of technical issues, no flights were able to depart during the first k minutes of the day, so now the new departure schedule must be created.
All n scheduled flights must now depart at different minutes between (k + 1)-th and (k + n)-th, inclusive. However, it's not mandatory for the flights to depart in the same order they were initially scheduled to do so — their order in the new schedule can be different. There is only one restriction: no flight is allowed to depart earlier than it was supposed to depart in the initial schedule.
Helen knows that each minute of delay of the i-th flight costs airport ci burles. Help her find the order for flights to depart in the new schedule that minimizes the total cost for the airport.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 300 000), here n is the number of flights, and k is the number of minutes in the beginning of the day that the flights did not depart.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 107), here ci is the cost of delaying the i-th flight for one minute.
Output
The first line must contain the minimum possible total cost of delaying the flights.
The second line must contain n different integers t1, t2, ..., tn (k + 1 ≤ ti ≤ k + n), here ti is the minute when the i-th flight must depart. If there are several optimal schedules, print any of them.
Example
Input
5 2
4 2 1 10 2
Output
20
3 6 7 4 5
Note
Let us consider sample test. If Helen just moves all flights 2 minutes later preserving the order, the total cost of delaying the flights would be (3 - 1)·4 + (4 - 2)·2 + (5 - 3)·1 + (6 - 4)·10 + (7 - 5)·2 = 38 burles.
However, the better schedule is shown in the sample answer, its cost is (3 - 1)·4 + (6 - 2)·2 + (7 - 3)·1 + (4 - 4)·10 + (5 - 5)·2 = 20 burles.
Submitted Solution:
```
# from debug import debug
# from heapq import heappush, heappop, heapify
from heapq import *
n, k = map(int, input().split())
c = list(map(int, input().split()))
q = [(-c[i], i) for i in range(k)]
heapify(q)
ans = 0
lis = [0]*n
for i in range(k, n):
heappush(q, (-c[i], i))
a, p = heappop(q)
ans += a*(i-p)
lis[p] = i+1
for i in range(n, n+k):
a, p = heappop(q)
ans += a*(i-p)
lis[p] = i+1
print(-ans)
print(*lis)
``` | instruction | 0 | 14,702 | 1 | 29,404 |
Yes | output | 1 | 14,702 | 1 | 29,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Helen works in Metropolis airport. She is responsible for creating a departure schedule. There are n flights that must depart today, the i-th of them is planned to depart at the i-th minute of the day.
Metropolis airport is the main transport hub of Metropolia, so it is difficult to keep the schedule intact. This is exactly the case today: because of technical issues, no flights were able to depart during the first k minutes of the day, so now the new departure schedule must be created.
All n scheduled flights must now depart at different minutes between (k + 1)-th and (k + n)-th, inclusive. However, it's not mandatory for the flights to depart in the same order they were initially scheduled to do so — their order in the new schedule can be different. There is only one restriction: no flight is allowed to depart earlier than it was supposed to depart in the initial schedule.
Helen knows that each minute of delay of the i-th flight costs airport ci burles. Help her find the order for flights to depart in the new schedule that minimizes the total cost for the airport.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 300 000), here n is the number of flights, and k is the number of minutes in the beginning of the day that the flights did not depart.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 107), here ci is the cost of delaying the i-th flight for one minute.
Output
The first line must contain the minimum possible total cost of delaying the flights.
The second line must contain n different integers t1, t2, ..., tn (k + 1 ≤ ti ≤ k + n), here ti is the minute when the i-th flight must depart. If there are several optimal schedules, print any of them.
Example
Input
5 2
4 2 1 10 2
Output
20
3 6 7 4 5
Note
Let us consider sample test. If Helen just moves all flights 2 minutes later preserving the order, the total cost of delaying the flights would be (3 - 1)·4 + (4 - 2)·2 + (5 - 3)·1 + (6 - 4)·10 + (7 - 5)·2 = 38 burles.
However, the better schedule is shown in the sample answer, its cost is (3 - 1)·4 + (6 - 2)·2 + (7 - 3)·1 + (4 - 4)·10 + (5 - 5)·2 = 20 burles.
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
from heapq import heappush, heappop, heapify
n, k = map(int, input().split())
a = list(map(int, input().split()))
q = [(-a[i], i) for i in range(k)]
heapify(q)
res, s = [0] * n, 0
for i in range(k, n):
heappush(q, (-a[i], i))
x, j = heappop(q)
s -= x * (i-j)
res[j] = i+1
for i in range(n, n+k):
x, j = heappop(q)
s -= x * (i-j)
res[j] = i+1
print(s)
print(*res)
``` | instruction | 0 | 14,703 | 1 | 29,406 |
Yes | output | 1 | 14,703 | 1 | 29,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Helen works in Metropolis airport. She is responsible for creating a departure schedule. There are n flights that must depart today, the i-th of them is planned to depart at the i-th minute of the day.
Metropolis airport is the main transport hub of Metropolia, so it is difficult to keep the schedule intact. This is exactly the case today: because of technical issues, no flights were able to depart during the first k minutes of the day, so now the new departure schedule must be created.
All n scheduled flights must now depart at different minutes between (k + 1)-th and (k + n)-th, inclusive. However, it's not mandatory for the flights to depart in the same order they were initially scheduled to do so — their order in the new schedule can be different. There is only one restriction: no flight is allowed to depart earlier than it was supposed to depart in the initial schedule.
Helen knows that each minute of delay of the i-th flight costs airport ci burles. Help her find the order for flights to depart in the new schedule that minimizes the total cost for the airport.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 300 000), here n is the number of flights, and k is the number of minutes in the beginning of the day that the flights did not depart.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 107), here ci is the cost of delaying the i-th flight for one minute.
Output
The first line must contain the minimum possible total cost of delaying the flights.
The second line must contain n different integers t1, t2, ..., tn (k + 1 ≤ ti ≤ k + n), here ti is the minute when the i-th flight must depart. If there are several optimal schedules, print any of them.
Example
Input
5 2
4 2 1 10 2
Output
20
3 6 7 4 5
Note
Let us consider sample test. If Helen just moves all flights 2 minutes later preserving the order, the total cost of delaying the flights would be (3 - 1)·4 + (4 - 2)·2 + (5 - 3)·1 + (6 - 4)·10 + (7 - 5)·2 = 38 burles.
However, the better schedule is shown in the sample answer, its cost is (3 - 1)·4 + (6 - 2)·2 + (7 - 3)·1 + (4 - 4)·10 + (5 - 5)·2 = 20 burles.
Submitted Solution:
```
import heapq
n, k = map(int, input().split())
costs = list(map(int, input().split()))
res = 0
heap_cost = 0
h = []
for i in range(k):
res += (k - i) * costs[i]
heapq.heappush(h, (-costs[i], i))
heap_cost += costs[i]
times = [0 for i in range(n)]
for i in range(n):
if k + i < n:
heapq.heappush(h, (-costs[k + i], k + i))
heap_cost += costs[k + i]
flight = heapq.heappop(h)
times[flight[1]] = k + i
heap_cost -= -flight[0]
res += heap_cost
print(res)
for t in times:
print(t, end = ' ')
``` | instruction | 0 | 14,704 | 1 | 29,408 |
No | output | 1 | 14,704 | 1 | 29,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Helen works in Metropolis airport. She is responsible for creating a departure schedule. There are n flights that must depart today, the i-th of them is planned to depart at the i-th minute of the day.
Metropolis airport is the main transport hub of Metropolia, so it is difficult to keep the schedule intact. This is exactly the case today: because of technical issues, no flights were able to depart during the first k minutes of the day, so now the new departure schedule must be created.
All n scheduled flights must now depart at different minutes between (k + 1)-th and (k + n)-th, inclusive. However, it's not mandatory for the flights to depart in the same order they were initially scheduled to do so — their order in the new schedule can be different. There is only one restriction: no flight is allowed to depart earlier than it was supposed to depart in the initial schedule.
Helen knows that each minute of delay of the i-th flight costs airport ci burles. Help her find the order for flights to depart in the new schedule that minimizes the total cost for the airport.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 300 000), here n is the number of flights, and k is the number of minutes in the beginning of the day that the flights did not depart.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 107), here ci is the cost of delaying the i-th flight for one minute.
Output
The first line must contain the minimum possible total cost of delaying the flights.
The second line must contain n different integers t1, t2, ..., tn (k + 1 ≤ ti ≤ k + n), here ti is the minute when the i-th flight must depart. If there are several optimal schedules, print any of them.
Example
Input
5 2
4 2 1 10 2
Output
20
3 6 7 4 5
Note
Let us consider sample test. If Helen just moves all flights 2 minutes later preserving the order, the total cost of delaying the flights would be (3 - 1)·4 + (4 - 2)·2 + (5 - 3)·1 + (6 - 4)·10 + (7 - 5)·2 = 38 burles.
However, the better schedule is shown in the sample answer, its cost is (3 - 1)·4 + (6 - 2)·2 + (7 - 3)·1 + (4 - 4)·10 + (5 - 5)·2 = 20 burles.
Submitted Solution:
```
import re
n,k = map(int,input().split())
cost = [int(i) for i in re.findall("\d+\s",input()+" ")]
COST = 0
plan = [-1 for i in range(n)]
if k < n:
for i in range(0,n-k):
plan[i] = i+k
for i in range(0,min(k,n)):
insert = i
run = True
while run:
inspoint = 0
compare = True
while compare:
if plan[inspoint]==-1:
insert,plan[inspoint] = plan[inspoint],insert
compare = False
elif cost[insert] > cost[plan[inspoint]]:
insert,plan[inspoint] = plan[inspoint],insert
compare = False
else:
inspoint += 1
if insert == -1:
run = False
planning = [plan.index(i)+3 for i in range(0,n)]
for i in range(0,n):
COST += (planning[i]-i-1)*cost[i]
print(COST)
print(" ".join([str(i) for i in planning]))
``` | instruction | 0 | 14,705 | 1 | 29,410 |
No | output | 1 | 14,705 | 1 | 29,411 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Helen works in Metropolis airport. She is responsible for creating a departure schedule. There are n flights that must depart today, the i-th of them is planned to depart at the i-th minute of the day.
Metropolis airport is the main transport hub of Metropolia, so it is difficult to keep the schedule intact. This is exactly the case today: because of technical issues, no flights were able to depart during the first k minutes of the day, so now the new departure schedule must be created.
All n scheduled flights must now depart at different minutes between (k + 1)-th and (k + n)-th, inclusive. However, it's not mandatory for the flights to depart in the same order they were initially scheduled to do so — their order in the new schedule can be different. There is only one restriction: no flight is allowed to depart earlier than it was supposed to depart in the initial schedule.
Helen knows that each minute of delay of the i-th flight costs airport ci burles. Help her find the order for flights to depart in the new schedule that minimizes the total cost for the airport.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 300 000), here n is the number of flights, and k is the number of minutes in the beginning of the day that the flights did not depart.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 107), here ci is the cost of delaying the i-th flight for one minute.
Output
The first line must contain the minimum possible total cost of delaying the flights.
The second line must contain n different integers t1, t2, ..., tn (k + 1 ≤ ti ≤ k + n), here ti is the minute when the i-th flight must depart. If there are several optimal schedules, print any of them.
Example
Input
5 2
4 2 1 10 2
Output
20
3 6 7 4 5
Note
Let us consider sample test. If Helen just moves all flights 2 minutes later preserving the order, the total cost of delaying the flights would be (3 - 1)·4 + (4 - 2)·2 + (5 - 3)·1 + (6 - 4)·10 + (7 - 5)·2 = 38 burles.
However, the better schedule is shown in the sample answer, its cost is (3 - 1)·4 + (6 - 2)·2 + (7 - 3)·1 + (4 - 4)·10 + (5 - 5)·2 = 20 burles.
Submitted Solution:
```
l=[int(x) for x in input().split()]
m=input()
s=[]
c=1
j=[]
for x in m.split():
s.append([int(x),c])
j.append(l[1]+c)
c=c+1
s.sort(key=lambda s: (s[0], -s[1]), reverse=True)
su=0
for i in range(l[0]):
if s[i][1] in j:
j.remove(s[i][1])
else:
su=su+(j[0]-s[i][1])*s[i][0]
j.remove(j[0])
print(su)
``` | instruction | 0 | 14,706 | 1 | 29,412 |
No | output | 1 | 14,706 | 1 | 29,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Helen works in Metropolis airport. She is responsible for creating a departure schedule. There are n flights that must depart today, the i-th of them is planned to depart at the i-th minute of the day.
Metropolis airport is the main transport hub of Metropolia, so it is difficult to keep the schedule intact. This is exactly the case today: because of technical issues, no flights were able to depart during the first k minutes of the day, so now the new departure schedule must be created.
All n scheduled flights must now depart at different minutes between (k + 1)-th and (k + n)-th, inclusive. However, it's not mandatory for the flights to depart in the same order they were initially scheduled to do so — their order in the new schedule can be different. There is only one restriction: no flight is allowed to depart earlier than it was supposed to depart in the initial schedule.
Helen knows that each minute of delay of the i-th flight costs airport ci burles. Help her find the order for flights to depart in the new schedule that minimizes the total cost for the airport.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 300 000), here n is the number of flights, and k is the number of minutes in the beginning of the day that the flights did not depart.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 107), here ci is the cost of delaying the i-th flight for one minute.
Output
The first line must contain the minimum possible total cost of delaying the flights.
The second line must contain n different integers t1, t2, ..., tn (k + 1 ≤ ti ≤ k + n), here ti is the minute when the i-th flight must depart. If there are several optimal schedules, print any of them.
Example
Input
5 2
4 2 1 10 2
Output
20
3 6 7 4 5
Note
Let us consider sample test. If Helen just moves all flights 2 minutes later preserving the order, the total cost of delaying the flights would be (3 - 1)·4 + (4 - 2)·2 + (5 - 3)·1 + (6 - 4)·10 + (7 - 5)·2 = 38 burles.
However, the better schedule is shown in the sample answer, its cost is (3 - 1)·4 + (6 - 2)·2 + (7 - 3)·1 + (4 - 4)·10 + (5 - 5)·2 = 20 burles.
Submitted Solution:
```
from heapq import heappush, heappop
n,k=[int(i) for i in input().split()]
l=[int(i) for i in input().split()]
if (n==1):
print (l[0])
else:
l1=[]
l2=[]
cost=0
if (k<n):
for i in range(k+1):
heappush(l1,(-l[i],i))
else:
for i in range(n):
heappush(l1,(-l[i],i))
for i in range(k,k+n):
a=heappop(l1)
cost+=((a[0]*(i-a[1]))*(-1))
l2.append((i+1,a[1]))
if (i<=n-2):
b=(-l[i+1],i+1)
heappush(l1,b)
l2.sort(key=lambda l2:l2[1])
print (cost,end="\n")
for i in range(n):
print (l2[i][0],end=" ")
``` | instruction | 0 | 14,707 | 1 | 29,414 |
No | output | 1 | 14,707 | 1 | 29,415 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3 | instruction | 0 | 14,908 | 1 | 29,816 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10**6)
n, k = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
if a[0] != 1:
ans += 1
child = [[] for _ in range(n)]
for i in range(1, n):
child[a[i]-1].append(i)
def dfs(x):
global ans
M = 0
for v in child[x]:
M = max(M, (dfs(v)+1)%k)
if M == k-1 and a[x] != 1 and x != 0:
ans += 1
return M
dfs(0)
print(ans)
``` | output | 1 | 14,908 | 1 | 29,817 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3 | instruction | 0 | 14,909 | 1 | 29,818 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(200000)
n,k = map(int,input().split())
a = list(map(int,input().split()))
ans = 0
if a[0] != 1:
a[0] = 1
ans += 1
b = [[]for i in range(n)]
for i in range(n):
b[a[i]-1].append(i)
b[0].remove(0)
huka = 0
kyo = [float("inf")] * n
def dfs(x,y):
kyo[x] = y
for i in b[x]:
dfs(i,y+1)
dfs(0,0)
def dfs2(x,y):
if kyo[x] <=k-y:
return
if y == k-1 and x != 0:
kyo[x] = 0
global ans
ans += 1
return
kyo[x] = 0
dfs2(a[x]-1,y+1)
hukai = []
for i in range(n):
hukai.append([kyo[i],i])
hukai.sort(key = lambda x:-x[0])
for j,i in hukai:
if j <= k:
continue
dfs2(i,0)
print(ans)
``` | output | 1 | 14,909 | 1 | 29,819 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3 | instruction | 0 | 14,910 | 1 | 29,820 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**15
mod = 10**9+7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,k = LI()
a = LI_()
r = 0
if a[0] != 0:
r += 1
e = collections.defaultdict(set)
for i in range(1,n):
e[a[i]].add(i)
def f(i, p):
m = 0
r = 0
for c in e[i]:
ct,cr = f(c, i)
r += cr
if ct > m:
m = ct
if (m == k-1 and p != 0) or (m == k and p == 0):
r += 1
m = -1
return (m+1,r)
for c in e[0]:
m,t = f(c,0)
r += t
return r
print(main())
``` | output | 1 | 14,910 | 1 | 29,821 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3 | instruction | 0 | 14,911 | 1 | 29,822 |
"Correct Solution:
```
def examA():
A, B, C = LI()
ans = min(A*B*(C%2),A*C*(B%2),B*C*(A%2))
print(ans)
return
def examB():
class segment_():
def __init__(self, A, n, segfunc):
#####単位元######要設定0or1orinf
self.ide_ele = inf
####################
self.num = 1 << (n - 1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
self.segfunc = segfunc
# set_val
for i in range(n):
self.seg[i + self.num] = A[i]
# built
for i in range(self.num - 1, 0, -1):
self.seg[i] = self.segfunc(self.seg[2 * i], self.seg[2 * i + 1])
def update(self, k, r):
k += self.num
self.seg[k] = r
while k:
k >>= 1
self.seg[k] = self.segfunc(self.seg[k * 2], self.seg[k * 2 + 1])
# 値xに1加算
def update1(self, k):
k += self.num
self.seg[k] += 1
while k:
k >>= 1
self.seg[k] = self.segfunc(self.seg[k * 2], self.seg[k * 2 + 1])
def updateneg1(self, k):
k += self.num
self.seg[k] -= 1
while k:
k >>= 1
self.seg[k] = self.segfunc(self.seg[k * 2], self.seg[k * 2 + 1])
def query(self, p, q):
if q < p:
return self.ide_ele
p += self.num;
q += self.num
res = self.ide_ele
while p < q:
if p & 1 == 1:
res = self.segfunc(res, self.seg[p])
p += 1
if q & 1 == 1:
q -= 1
res = self.segfunc(res, self.seg[q])
p >>= 1;
q >>= 1
return res
N, x = LI()
A = LI()
Seg_min = segment_(A, N, lambda a, b: min(a,b))
ans = inf
for k in range(N):
cur = 0
for j in range(N):
if j-k>=0:
now = Seg_min.query(j-k,j+1)
else:
now = min(Seg_min.query(0,j+1),Seg_min.query(N-(k-j),N))
# print(now,k,j)
cur += now
ans = min(ans,cur+k*x)
print(ans)
return
def examC():
H, W = LI()
A = [SI()for _ in range(H)]
ans = 0
print(ans)
return
def examD():
N, K = LI()
A = LI()
V = [[]for _ in range(N)]
ans = 0
if A[0]!=1:
ans += 1
A[0] = 1
for i in range(1,N):
V[A[i]-1].append(i)
def dfs(p,s):
depth = 0
cnt = 0
for i in V[s]:
d,c = dfs(s,i)
depth = max(depth,d)
cnt += c
depth += 1
if depth==K and p!=0:
depth = 0
cnt += 1
return depth,cnt
_,cnt = dfs(0,0)
ans += cnt
print(ans)
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LFI(): return list(map(float,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**6)
if __name__ == '__main__':
examD()
"""
"""
``` | output | 1 | 14,911 | 1 | 29,823 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3 | instruction | 0 | 14,912 | 1 | 29,824 |
"Correct Solution:
```
#d tree
#code自体はあっている。ただ、そもそもアルゴリズムが違う。
#下から調べていかないと最適でない。
#Right Answer.
import sys
sys.setrecursionlimit(2 * 10 ** 5 + 10)
n,k = [int(i) for i in input().split()]
a = [int(i)-1 for i in input().split()]
#this is directed tree so every node is not reached yet
#return the depth from its lowest bottom
def dfs(u):
global cnt
depth = 0 #default, this value is used when bottom
for v in edges[u]:
depth = max(depth, (dfs(v)+1)%k) #apply the maximum depth
#because the edge was alerady cut, by the following procedure
if depth==k-1 and u!=0 and a[u] != 0:
cnt += 1
return depth
cnt = 0
if a[0]!=0:
cnt += 1
edges = [[] for _ in range(n)]
for i in range(1,n):
pa = a[i]
edges[a[i]].append(i)
dfs(0)
print(cnt)
``` | output | 1 | 14,912 | 1 | 29,825 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3 | instruction | 0 | 14,913 | 1 | 29,826 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(200000)
n,k = map(int,input().split())
a = list(map(int,input().split()))
ans = 0
if a[0] != 1:
a[0] = 1
ans += 1
b = [[]for i in range(n)]
for i in range(1,n):
b[a[i]-1].append(i)
huka = 0
kyo = [float("inf")] * n
z =[[]for i in range(n)]
def dfs(x,y):
kyo[x] = y
z[y].append(x)
for i in b[x]:
dfs(i,y+1)
dfs(0,0)
def dfs2(x,y):
if kyo[x] <=k-y:
return
if y == k-1 and x != 0:
kyo[x] = 0
global ans
ans += 1
return
kyo[x] = 0
dfs2(a[x]-1,y+1)
for i in range(n-1,k,-1):
for j in z[i]:
dfs2(j,0)
print(ans)
``` | output | 1 | 14,913 | 1 | 29,827 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3 | instruction | 0 | 14,914 | 1 | 29,828 |
"Correct Solution:
```
from heapq import heappop,heappush
n,k = map(int,input().split())
a = [0] + list(map(int,input().split()))
ans = 0
if(a[1] != 1):
ans += 1
links_c = [set() for _ in range(n+1)]
for i,ai in enumerate(a[2:],2):
links_c[ai].add(i)
depth = [-1] * (n+1)
depth[1] = 0
stack = [1]
hq = []
while(stack):
next = []
while(stack):
i = stack.pop()
for j in links_c[i]:
depth[j] = depth[i] + 1
heappush(hq, (depth[j]*-1,j))
next.append(j)
stack = next[::]
while( hq[0][0]*-1 > k ):
di,i = heappop(hq)
if( depth[i] <= k ):
continue
for j in range(k-1):
i = a[i]
ans += 1
links_c[a[i]].remove(i)
stack = [i]
while(stack):
next = []
while(stack):
i = stack.pop()
depth[i] = 1
for j in links_c[i]:
next.append(j)
stack = next[::]
print(ans)
'''
首都の自己ループを除くと、首都を根として、
子→親の有向木になっている。
・首都のテレポート先は首都でないとダメ
→ 長さ2以上の閉路を作るとうまくいかない
・首都以外は、首都までの距離をk以下にできればよい
もっとも根からの距離が遠い頂点xをとる。
xが根からの距離k以下 → 終了してOK
xが根からの距離k以上
→ xからk-1個離れた親を首都につなぎなおす
そして再度最も遠い頂点を探す、を繰り返す。
'''
``` | output | 1 | 14,914 | 1 | 29,829 |
Provide a correct Python 3 solution for this coding contest problem.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3 | instruction | 0 | 14,915 | 1 | 29,830 |
"Correct Solution:
```
from collections import deque
N,K = map(int,input().split())
a = list(map(int,input().split()))
for i in range(N):
a[i] -= 1
ans = 0
if a[0] != 0:
ans += 1
a[0] = 0
dis = [float("-inf")] * N
lnum = [0] * N
for i in range(N):
lnum[a[i]] += 1
q = deque([])
for i in range(N):
if lnum[i] == 0:
q.append(i)
dis[i] = 0
while len(q) > 0:
now = q.popleft()
if a[now] == 0:
continue
elif dis[now] == K-1:
ans += 1
dis[now] = -1
dis[a[now]] = max(dis[a[now]] , dis[now] + 1)
lnum[a[now]] -= 1
if lnum[a[now]] == 0:
q.append(a[now])
#print (dis)
print (ans)
``` | output | 1 | 14,915 | 1 | 29,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3
Submitted Solution:
```
import sys
input = sys.stdin.readline
# import heapq as hp
N, K = map(int, input().split())
A = list(map(int, input().split()))
ans = 0
graph = [[] for _ in range(N)]
Par = [-1]*N
for i, a in enumerate(A):
if i == 0:
if a != 1:
ans += 1
continue
Par[i] = a-1
graph[a-1].append(i)
qs = []
stack = [0]
Depth = [-1]*N
Depth[0] = 0
while stack:
p = stack.pop()
for np in graph[p]:
Depth[np] = Depth[p] + 1
stack.append(np)
qs.append((Depth[p], p))
qs.sort(reverse=True)
checked = [False]*N
for d, s in qs:
if d <= K: break
if checked[s]: continue
for _ in range(K-1):
s = Par[s]
que = [s]
checked[s] = True
while que:
qq = []
for p in que:
for np in graph[p]:
if not checked[np]:
checked[np] = True
qq.append(np)
que = qq
ans += 1
print(ans)
``` | instruction | 0 | 14,916 | 1 | 29,832 |
Yes | output | 1 | 14,916 | 1 | 29,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3
Submitted Solution:
```
#設定
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
#ライブラリインポート
from collections import defaultdict
answer = 0
#入力受け取り
def getlist():
return list(map(int, input().split()))
INF = float("inf")
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
def get_nodes(self):
return self.graph.keys()
def DFS(G, visit, W, Wlist, node, K):
for i in G.graph[node]:
if visit[i] != "Yes":
visit[i] = "Yes"
DFS(G, visit, W, Wlist, i, K)
Wlist[node].append(W[i] + 1)
val = 0
for i in Wlist[node]:
if i == K and node != 0:
global answer
answer += 1
else:
val = max(val, i)
W[node] = val
#処理内容
def main():
N, K = getlist()
a = getlist()
G = Graph()
for i in range(1, N):
G.add_edge(i, a[i] - 1)
G.add_edge(a[i] - 1, i)
ans = 0
if a[0] != 1:
ans += 1
if K == 1:
for i in range(1, N):
if a[i] != 1:
ans += 1
print(ans)
return
#DFS
W = [0] * N
Wlist = [[] for i in range(N)]
visit = ["No"] * N
visit[0] = "Yes"
DFS(G, visit, W, Wlist, 0, K)
print(ans + answer)
if __name__ == '__main__':
main()
``` | instruction | 0 | 14,917 | 1 | 29,834 |
Yes | output | 1 | 14,917 | 1 | 29,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3
Submitted Solution:
```
# coding:utf-8
import sys
from collections import defaultdict
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()
def main():
n, k = LI()
A = LI_()
D = defaultdict(list)
for i in range(1, n):
D[A[i]].append(i)
# 首都は必ず自己ループでなければならない
global res
res = 0 if A[0] == 0 else 1
def DFS(v, par):
global res
h = 0
for to in D[v]:
# print('dfs {} -> {}'.format(v+1, to+1))
# h: 葉からの距離の最大値
h = max(h, DFS(to, v))
# 根が首都ではなく，高さがk - 1の場合は首都につなぎ直す
if h == k - 1 and par != 0:
res += 1
h = -1
# print('Finish {} <- {}'.format(par+1, v+1))
return h + 1
DFS(0, 0)
return res
print(main())
``` | instruction | 0 | 14,918 | 1 | 29,836 |
Yes | output | 1 | 14,918 | 1 | 29,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3
Submitted Solution:
```
def DFS(graph,root,parent):
dist = [-1]*(n+1)
dist[root] = 0
stack = [root]
while stack:
x = stack.pop()
for y in graph[x]:
if dist[y] == -1:
parent[y] = x
dist[y] = dist[x]+1
stack.append(y)
return dist
#親のリスト、頂点v、kが与えられたときに「vのk個上の祖先」を見る
class Doubling:
def __init__(self,graph,root):
self.root = root
n = len(graph)-1
self.ancestor_ls = [[0]*(n+1)]
self.distance = DFS(graph,root,self.ancestor_ls[0])
self.bitn = n.bit_length()
for i in range(1,self.bitn+1):
ancestor_ls_app = [0]*(n+1)
for j in range(1,n+1):
ancestor_ls_app[j] = self.ancestor_ls[i-1][self.ancestor_ls[i-1][j]]
self.ancestor_ls.append(ancestor_ls_app)
def dist(self):
return self.distance
def parent(self):
return self.ancestor_ls[0]
def ancestor(self,v,depth):
if depth == 1:
return self.ancestor_ls[0][v]
if depth == 2:
return self.ancestor_ls[1][v]
if depth == 0:
return v
if n<depth:
return self.root
ret = v
for i in range(self.bitn):
if depth&1<<i:
ret = self.ancestor_ls[i][ret]
return ret
import sys
input = sys.stdin.readline
from collections import deque
n,k = map(int,input().split())
a = list(map(int,input().split()))
ans = 0
if a[0] != 1:
ans += 1
graph = [[] for i in range(n+1)]
for i in range(1,n):
graph[a[i]].append(i+1)
graph[i+1].append(a[i])
if k > n:
print(ans)
exit()
sol = Doubling(graph,1)
dist = sol.dist()
if k == 1:
print(n-dist.count(1)-dist.count(0)+ans)
exit()
dls = []
for i in range(1,n+1):
dls.append((dist[i],i))
vis = [0]*(n+1)
dls.sort()
dlsq = deque(dls)
parent = sol.parent()
while True:
d,x = dlsq.pop()
if d <= k:
break
if vis[x] == 1:
continue
ans += 1
anc = sol.ancestor(x,k-1)
stack = deque([anc])
while stack:
v = stack.pop()
vis[v] = 1
for u in graph[v]:
if parent[u] == v and vis[u] != 1:
stack.append(u)
print(ans)
``` | instruction | 0 | 14,919 | 1 | 29,838 |
Yes | output | 1 | 14,919 | 1 | 29,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3
Submitted Solution:
```
import sys
from collections import defaultdict as dd
from collections import deque as dq
input = sys.stdin.readline
N, K = map(int, input().split())
a = list(map(int, input().split()))
if K >= N - 1:
print(int(a[0] != 1))
exit(0)
res = 0
if a[0] != 1:
a[0] = 1
res += 1
e = dd(set)
for i in range(N):
e[a[i]].add((i + 1, 0))
e[i + 1].add((a[i], 0))
#print(e)
Q = dq([1])
d = [float("inf")] * (N + 1)
d[1] = 0
while len(Q):
p = Q.popleft()
for q, _ in e[p]:
if d[q] > d[p] + 1:
d[q] = d[p] + 1
Q.append(q)
#print(d)
for u in range(1, N + 1):
x = -(-d[u] // K)
t = []
for v, _ in e[u]:
y = -(-d[v] // K)
if x != y:
if u == 1 or (v == 1): continue
t.append((v, 0))
for v, _ in t: e[u].discard((v, 0))
#print(e)
for i in range(1, N + 1):
e[i].add((1, 1))
e[1].add((i, 1))
#print(e)
import heapq
class prim:
def __init__(self, n, e):
self.e = e
self.n = n
def MSTcost(self):
h = []
visited = [0] * (self.n + 1)
ks = list(self.e.keys())
b = pow(10, 10)
for edge in self.e[ks[0]]:
heapq.heappush(h, edge[1] * b + edge[0])
res = 0
visited[ks[0]] = 1
while len(h):
p = heapq.heappop(h)
p0 = p // b
p1 = p % b
if visited[p1]: continue
visited[p1] = 1
for q in self.e[p1]:
if visited[q[0]]:
continue
heapq.heappush(h, q[1] * b + q[0])
res += p0
return res
pri = prim(N, e)
print(pri.MSTcost() + res)
``` | instruction | 0 | 14,920 | 1 | 29,840 |
No | output | 1 | 14,920 | 1 | 29,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3
Submitted Solution:
```
import sys
from collections import defaultdict as dd
from collections import deque as dq
input = sys.stdin.readline
N, K = map(int, input().split())
a = list(map(int, input().split()))
if K >= N - 1:
print(int(a[0] != 1))
exit(0)
res = 0
if a[0] != 1:
a[0] = 1
res += 1
e = dd(set)
for i in range(N):
e[a[i]].add(i + 1)
#print(e)
Q = dq([1])
d = [float("inf")] * (N + 1)
d[1] = 0
while len(Q):
p = Q.popleft()
for q in e[p]:
if d[q] > d[p] + 1:
d[q] = d[p] + 1
Q.append(q)
#print(d)
eulbase = pow(10, 6)
euler = []
depth = [0] * (N + 1)
table = [0] * (N + 1)
def eulerdfs(x, d):
global euler
global depth
global table
table[x] = len(euler)
depth[x] = d
euler.append(d * eulbase + x)
for y in e[x]:
if x == y: continue
eulerdfs(y, d + 1)
euler.append(d * eulbase + x)
for i in range(len(euler) - 1, -1, -1): table[euler[i] % eulbase] = i
eulerdfs(1, 0)
#print(euler)
#print(table)
class minSegTree:
def segfunc(self, x, y):
return min(x, y)
def __init__(self, n, ide_ele, init_val):
#####単位元######
self.ide_ele = ide_ele
#num:n以上の最小の2のべき乗
self.num = 2 ** (n - 1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
#set_val
for i in range(n):
self.seg[i + self.num - 1] = init_val[i]
#built
for i in range(self.num - 2, -1, -1) :
self.seg[i] = self.segfunc(self.seg[2 * i + 1], self.seg[2 * i + 2])
def update(self, k, x):
k += self.num - 1
self.seg[k] = x
while k + 1:
k = (k - 1) // 2
self.seg[k] = self.segfunc(self.seg[k * 2 + 1], self.seg[k * 2 + 2])
def query(self, p, q):
if q <= p:
return self.ide_ele
p += self.num - 1
q += self.num - 2
res = self.ide_ele
while q - p > 1:
if p & 1 == 0:
res = self.segfunc(res, self.seg[p])
if q & 1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
class maxSegTree:
def segfunc(self, x, y):
return max(x, y)
def __init__(self, n, ide_ele, init_val):
#####単位元######
self.ide_ele = ide_ele
#num:n以上の最小の2のべき乗
self.num = 2 ** (n - 1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
#set_val
for i in range(n):
self.seg[i + self.num - 1] = init_val[i]
#built
for i in range(self.num - 2, -1, -1) :
self.seg[i] = self.segfunc(self.seg[2 * i + 1], self.seg[2 * i + 2])
def update(self, k, x):
k += self.num - 1
self.seg[k] = x
while k + 1:
k = (k - 1) // 2
self.seg[k] = self.segfunc(self.seg[k * 2 + 1], self.seg[k * 2 + 2])
def query(self, p, q):
if q <= p:
return self.ide_ele
p += self.num - 1
q += self.num - 2
res = self.ide_ele
while q - p > 1:
if p & 1 == 0:
res = self.segfunc(res, self.seg[p])
if q & 1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
euler.pop()
minseg = minSegTree(len(euler), N * eulbase, euler)
maxseg = maxSegTree(len(euler), 0, euler)
#print(euler)
ex = dd(list)
for i in range(len(euler)):
ok = i + 1
ng = len(euler) + 1
while ng - ok > 1:
m = (ok + ng) // 2
if (maxseg.query(i, m) // eulbase) - (minseg.query(i, m) // eulbase) <= K: ok = m
else: ng = m
ex[i].append((ok, 1))
for i in range(len(euler), 0, -1):
ex[i].append((i - 1, 0))
#print(ex)
import heapq
class dijkstra:
def __init__(self, n, e):
self.e = e
self.n = n
def path(self, s, t):
d = [float("inf")] * (self.n + 1)
vis = set()
d[s] = 0
h = [s]
while not t in vis and len(h):
v = heapq.heappop(h)
v1 = v % (10 ** 6)
v0 = v // (10 ** 6)
if v1 in vis: continue
vis.add(v1)
for p in self.e[v1]:
d[p[0]] = min(d[p[0]], d[v1] + p[1])
if p[0] in vis: continue
heapq.heappush(h, d[p[0]] * (10 ** 6) + p[0])
return d[t]
dij = dijkstra(len(euler), ex)
print(dij.path(0, len(euler)) - 1 + res)
``` | instruction | 0 | 14,921 | 1 | 29,842 |
No | output | 1 | 14,921 | 1 | 29,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3
Submitted Solution:
```
import sys
input = sys.stdin.readline
n, k = map(int, input().split())
A = list(map(int, input().split()))
ans = 0
if A[0] != 1:
ans += 1
T = [[] for _ in range(n+1)]
for i, a in enumerate(A[1:], 2):
T[a].append(i)
dist = [-1]*(n+1)
dist[1] = 0
stack = [1]
while stack:
v = stack.pop()
d = dist[v]+1
for nv in T[v]:
if d > k:
ans += 1
dist[nv] = 1
else:
dist[nv] = d
stack.append(nv)
print(ans)
``` | instruction | 0 | 14,922 | 1 | 29,844 |
No | output | 1 | 14,922 | 1 | 29,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3
Submitted Solution:
```
import sys
sys.setrecursionlimit(10**6)
n,k = map(int,input().split())
a = [int(i)-1 for i in input().split()]
edg = [[] for i in range(n)]
for i in range(n):
edg[a[i]].append(i)
ans = [0] * n
ans[0] = a[0] != 0
c = [1] * n
def dfs(now, rank):
c[now] = 0
for e in edg[now]:
if c[e]:
if rank == k:
ans[e] = 1
dfs(e, 1)
else:
dfs(e, time + 1)
dfs(0, 1)
print(sum(ans))
``` | instruction | 0 | 14,923 | 1 | 29,846 |
No | output | 1 | 14,923 | 1 | 29,847 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
One evening. As usual, when you were watching TV in the living room, my sister in fifth grade offered me a consultation. When I listened to the story, I couldn't understand the math problem that was presented at school today, so I want you to teach me how to solve it.
The question that bothers my sister is, "How many ways are there in the shortest way from home (0, 0) to school (N, M) in a city with grid-like roads?" was. Of course, it's a simpler problem for you than twisting the baby's hand. Immediately, I wrote a figure like the one above and told me, "If you add up in order from the house (0, 0), you can solve it."
However, when I heard that, my sister was still thinking down. You wondered if your explanation was wrong, but apparently it wasn't.
Have you been worried for about 3 minutes? My sister raised her face and said to you:
"But if I were, I'm sure I would make a detour about K times on my way to school ... Hey brother, how many answers would you get?"
It's hard now. I have to answer this question to keep my brother dignified.
The formulation of this problem is as follows.
* Answer how many ways you can go from point (0, 0) to point (N, M) through a grid-like path.
* Basically, go one square to the right or up, but on the way, make a detour just K times.
* To "take a detour" means to go one square to the left or down.
* If you haven't made K detours, continue walking even after you reach point (N, M). It may return to the point (0, 0) on the way.
* The house is built in the corner of the city, so you can't enter a point where the X or Y coordinates are negative.
* However, it is possible to enter a point whose X coordinate is larger than N or whose Y coordinate is larger than M.
Input
NMK
On the first line of input, the integer N (1 ≤ N ≤ 100,000), the integer M (1 ≤ M ≤ 100,000), and the integer K (0 ≤ K ≤ 10,000) are written in this order, separated by blanks. The integer N represents the X coordinate of the school, the integer M represents the Y coordinate of the school, and the integer K represents the number of detours.
Output
How to make K detours from point (0, 0) to point (N, M). Divide the total number by 1,000,000,007 and output the remainder. Note that 1,000,000,007 are prime numbers.
Examples
Input
6 4 0
Output
210
Input
3 3 1
Output
448
Input
124 218 367
Output
817857665 | instruction | 0 | 15,018 | 1 | 30,036 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
MOD = 10**9 + 7
N, M, K = map(int, readline().split())
MOD = 10**9 + 7
L = N+M+2*K
fact = [1]*(L+1)
rfact = [1]*(L+1)
r = 1
for i in range(1, L+1):
fact[i] = r = r * i % MOD
rfact[L] = r = pow(fact[L], MOD-2, MOD)
for i in range(L, 0, -1):
rfact[i-1] = r = r * i % MOD
def C(n, k):
return fact[n] * rfact[n-k] * rfact[k] % MOD
def F(n, k):
return (fact[n+k] * (n-k+1) % MOD) * (rfact[k] * rfact[n+1] % MOD) % MOD
ans = 0
for a in range(K+1):
b = K-a
ans += C(N+2*a+M+2*b, N+2*a) * F(N+a, a) * F(M+b, b) % MOD
ans %= MOD
write("%d\n" % ans)
solve()
``` | output | 1 | 15,018 | 1 | 30,037 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
One evening. As usual, when you were watching TV in the living room, my sister in fifth grade offered me a consultation. When I listened to the story, I couldn't understand the math problem that was presented at school today, so I want you to teach me how to solve it.
The question that bothers my sister is, "How many ways are there in the shortest way from home (0, 0) to school (N, M) in a city with grid-like roads?" was. Of course, it's a simpler problem for you than twisting the baby's hand. Immediately, I wrote a figure like the one above and told me, "If you add up in order from the house (0, 0), you can solve it."
However, when I heard that, my sister was still thinking down. You wondered if your explanation was wrong, but apparently it wasn't.
Have you been worried for about 3 minutes? My sister raised her face and said to you:
"But if I were, I'm sure I would make a detour about K times on my way to school ... Hey brother, how many answers would you get?"
It's hard now. I have to answer this question to keep my brother dignified.
The formulation of this problem is as follows.
* Answer how many ways you can go from point (0, 0) to point (N, M) through a grid-like path.
* Basically, go one square to the right or up, but on the way, make a detour just K times.
* To "take a detour" means to go one square to the left or down.
* If you haven't made K detours, continue walking even after you reach point (N, M). It may return to the point (0, 0) on the way.
* The house is built in the corner of the city, so you can't enter a point where the X or Y coordinates are negative.
* However, it is possible to enter a point whose X coordinate is larger than N or whose Y coordinate is larger than M.
Input
NMK
On the first line of input, the integer N (1 ≤ N ≤ 100,000), the integer M (1 ≤ M ≤ 100,000), and the integer K (0 ≤ K ≤ 10,000) are written in this order, separated by blanks. The integer N represents the X coordinate of the school, the integer M represents the Y coordinate of the school, and the integer K represents the number of detours.
Output
How to make K detours from point (0, 0) to point (N, M). Divide the total number by 1,000,000,007 and output the remainder. Note that 1,000,000,007 are prime numbers.
Examples
Input
6 4 0
Output
210
Input
3 3 1
Output
448
Input
124 218 367
Output
817857665 | instruction | 0 | 15,019 | 1 | 30,038 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def inv(x):
return pow(x, mod - 2, mod)
cms = 10**6
cm = [0] * cms
def comb_init():
cm[0] = 1
for i in range(1, cms):
cm[i] = cm[i-1] * i % mod
def comb(a, b):
return (cm[a] * inv(cm[a-b]) % mod) * inv(cm[b]) % mod
def main():
rr = []
def f(n,m,k):
comb_init()
r = 0
for i in range(k+1):
j = k - i
mt = comb(n+m+k*2, n+i*2)
lk = rk = 1
if i > 0:
lk = (comb(n+i*2, i) - comb(n+i*2, i-1)) % mod
if j > 0:
rk = (comb(m+j*2, j) - comb(m+j*2, j-1)) % mod
r += mt * lk * rk % mod
r %= mod
return r
while 1:
n,m,k = LI()
if n == 0:
break
rr.append(f(n,m,k))
break
return '\n'.join(map(str, rr))
print(main())
``` | output | 1 | 15,019 | 1 | 30,039 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities in Shaazzzland, numbered from 0 to n-1. Ghaazzzland, the immortal enemy of Shaazzzland, is ruled by AaParsa.
As the head of the Ghaazzzland's intelligence agency, AaParsa is carrying out the most important spying mission in Ghaazzzland's history on Shaazzzland.
AaParsa has planted m transport cannons in the cities of Shaazzzland. The i-th cannon is planted in the city a_i and is initially pointing at city b_i.
It is guaranteed that each of the n cities has at least one transport cannon planted inside it, and that no two cannons from the same city are initially pointing at the same city (that is, all pairs (a_i, b_i) are distinct).
AaParsa used very advanced technology to build the cannons, the cannons rotate every second. In other words, if the i-th cannon is pointing towards the city x at some second, it will target the city (x + 1) mod n at the next second.
As their name suggests, transport cannons are for transportation, specifically for human transport. If you use the i-th cannon to launch yourself towards the city that it's currently pointing at, you'll be airborne for c_i seconds before reaching your target destination.
If you still don't get it, using the i-th cannon at the s-th second (using which is only possible if you are currently in the city a_i) will shoot you to the city (b_i + s) mod n and you'll land in there after c_i seconds (so you'll be there in the (s + c_i)-th second). Also note the cannon that you initially launched from will rotate every second but you obviously won't change direction while you are airborne.
AaParsa wants to use the cannons for travelling between Shaazzzland's cities in his grand plan, and he can start travelling at second 0. For him to fully utilize them, he needs to know the minimum number of seconds required to reach city u from city v using the cannons for every pair of cities (u, v).
Note that AaParsa can stay in a city for as long as he wants.
Input
The first line contains two integers n and m (2 ≤ n ≤ 600 , n ≤ m ≤ n^2) — the number of cities and cannons correspondingly.
The i-th line of the following m lines contains three integers a_i, b_i and c_i ( 0 ≤ a_i , b_i ≤ n-1 , 1 ≤ c_i ≤ 10^9), denoting the cannon in the city a_i, which is initially pointing to b_i and travelling by which takes c_i seconds.
It is guaranteed that each of the n cities has at least one transport cannon planted inside it, and that no two cannons from the same city are initially pointing at the same city (that is, all pairs (a_i, b_i) are distinct).
Output
Print n lines, each line should contain n integers.
The j-th integer in the i-th line should be equal to the minimum time required to reach city j from city i.
Examples
Input
3 4
0 1 1
0 2 3
1 0 1
2 0 1
Output
0 1 2
1 0 2
1 2 0
Input
6 6
0 0 1
1 1 1
2 2 1
3 3 1
4 4 1
5 5 1
Output
0 2 3 3 4 4
4 0 2 3 3 4
4 4 0 2 3 3
3 4 4 0 2 3
3 3 4 4 0 2
2 3 3 4 4 0
Input
4 5
0 1 1
1 3 2
2 2 10
3 0 1
0 0 2
Output
0 1 2 3
3 0 3 2
12 13 0 11
1 2 2 0
Note
In the first example one possible path for going from 0 to 2 would be:
1. Stay inside 0 and do nothing for 1 second.
2. Use the first cannon and land at 2 after 1 second.
Note that: we could have used the second cannon in 0-th second but it would have taken us 3 seconds to reach city 2 in that case. | instruction | 0 | 15,321 | 1 | 30,642 |
Tags: constructive algorithms, graphs, shortest paths
Correct Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
def dijkstra(n, E, i0=0):
D = [1 << 30] * n
D[i0] = 0
Q = set([i for i in range(n)])
while Q:
d = 1 << 30
for q in Q:
if D[q] < d:
i = q
d = D[q]
Q.remove(i)
for j, w in enumerate(E[i]):
jj = (j + d) % n
if jj == i: continue
nd = d + w
if D[jj] > nd:
D[jj] = nd
# return D
return " ".join(map(str, D))
N, M = map(int, input().split())
inf = 2 * 10 ** 9
X = [[inf] * N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
X[a][b] = c
Y = [[0] * N for _ in range(N)]
for i, Yi in enumerate(Y):
Xi = X[i]
for j in range(N):
if j and mi < Xi[j] + N - 1:
mi = min(mi + 1, Xi[j])
Yi[j] = mi
continue
mi = inf
for k in range(N):
mi = min(mi, Xi[j-k] + k)
Yi[j] = mi
Z = [dijkstra(N, Y, s) for s in range(N)]
print("\n".join(Z))
``` | output | 1 | 15,321 | 1 | 30,643 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in Shaazzzland, numbered from 0 to n-1. Ghaazzzland, the immortal enemy of Shaazzzland, is ruled by AaParsa.
As the head of the Ghaazzzland's intelligence agency, AaParsa is carrying out the most important spying mission in Ghaazzzland's history on Shaazzzland.
AaParsa has planted m transport cannons in the cities of Shaazzzland. The i-th cannon is planted in the city a_i and is initially pointing at city b_i.
It is guaranteed that each of the n cities has at least one transport cannon planted inside it, and that no two cannons from the same city are initially pointing at the same city (that is, all pairs (a_i, b_i) are distinct).
AaParsa used very advanced technology to build the cannons, the cannons rotate every second. In other words, if the i-th cannon is pointing towards the city x at some second, it will target the city (x + 1) mod n at the next second.
As their name suggests, transport cannons are for transportation, specifically for human transport. If you use the i-th cannon to launch yourself towards the city that it's currently pointing at, you'll be airborne for c_i seconds before reaching your target destination.
If you still don't get it, using the i-th cannon at the s-th second (using which is only possible if you are currently in the city a_i) will shoot you to the city (b_i + s) mod n and you'll land in there after c_i seconds (so you'll be there in the (s + c_i)-th second). Also note the cannon that you initially launched from will rotate every second but you obviously won't change direction while you are airborne.
AaParsa wants to use the cannons for travelling between Shaazzzland's cities in his grand plan, and he can start travelling at second 0. For him to fully utilize them, he needs to know the minimum number of seconds required to reach city u from city v using the cannons for every pair of cities (u, v).
Note that AaParsa can stay in a city for as long as he wants.
Input
The first line contains two integers n and m (2 ≤ n ≤ 600 , n ≤ m ≤ n^2) — the number of cities and cannons correspondingly.
The i-th line of the following m lines contains three integers a_i, b_i and c_i ( 0 ≤ a_i , b_i ≤ n-1 , 1 ≤ c_i ≤ 10^9), denoting the cannon in the city a_i, which is initially pointing to b_i and travelling by which takes c_i seconds.
It is guaranteed that each of the n cities has at least one transport cannon planted inside it, and that no two cannons from the same city are initially pointing at the same city (that is, all pairs (a_i, b_i) are distinct).
Output
Print n lines, each line should contain n integers.
The j-th integer in the i-th line should be equal to the minimum time required to reach city j from city i.
Examples
Input
3 4
0 1 1
0 2 3
1 0 1
2 0 1
Output
0 1 2
1 0 2
1 2 0
Input
6 6
0 0 1
1 1 1
2 2 1
3 3 1
4 4 1
5 5 1
Output
0 2 3 3 4 4
4 0 2 3 3 4
4 4 0 2 3 3
3 4 4 0 2 3
3 3 4 4 0 2
2 3 3 4 4 0
Input
4 5
0 1 1
1 3 2
2 2 10
3 0 1
0 0 2
Output
0 1 2 3
3 0 3 2
12 13 0 11
1 2 2 0
Note
In the first example one possible path for going from 0 to 2 would be:
1. Stay inside 0 and do nothing for 1 second.
2. Use the first cannon and land at 2 after 1 second.
Note that: we could have used the second cannon in 0-th second but it would have taken us 3 seconds to reach city 2 in that case.
Submitted Solution:
```
""" Python 3 compatibility tools. """
from __future__ import division, print_function
import sys
import os
if False:
from typing import List, Set, Dict, Tuple, Text, Optional, Callable, Any
from collections import deque
import collections
from types import GeneratorType
import itertools
import operator
import functools
import random
import copy
import heapq
import math
from atexit import register
from io import BytesIO, IOBase
import __pypy__ # type: ignore
EPS = 10**-12
#########
# INPUT #
#########
class Input(object):
def __init__(self):
if 'CPH' not in os.environ:
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
def rawInput(self):
# type: () -> str
return sys.stdin.readline().rstrip('\r\n')
def readInt(self):
return int(self.rawInput())
##########
# OUTPUT #
##########
class Output(object):
def __init__(self):
self.out = __pypy__.builders.StringBuilder()
def write(self, text):
# type: (str) -> None
self.out.append(str(text))
def writeLine(self, text):
# type: (str) -> None
self.write(str(text) + '\n')
def finalize(self):
if sys.version_info[0] < 3:
os.write(1, self.out.build())
else:
os.write(1, self.out.build().encode())
###########
# LIBRARY #
###########
def bootstrap(f, stack=[]):
# Deep Recursion helper.
# From: https://github.com/cheran-senthil/PyRival/blob/c1972da95d102d95b9fea7c5c8e0474d61a54378/docs/bootstrap.rst
# Usage:
# @bootstrap
# def recur(n):
# if n == 0:
# yield 1
# yield (yield recur(n-1)) * n
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
int_add = __pypy__.intop.int_add
int_sub = __pypy__.intop.int_sub
int_mul = __pypy__.intop.int_mul
def make_mod_mul(mod):
fmod_inv = 1.0 / mod
def mod_mul(a, b, c=0):
res = int_sub(int_add(int_mul(a, b), c), int_mul(
mod, int(fmod_inv * a * b + fmod_inv * c)))
if res >= mod:
return res - mod
elif res < 0:
return res + mod
else:
return res
return mod_mul
#########
# LOGIC #
#########
def main(inp, out):
# type: (Input, Output) -> None
n, m = map(int, inp.rawInput().split())
cannons = [[] for _ in range(n)]
for _ in range(m):
u, v, w = map(int, inp.rawInput().split())
cannons[u].append((v, w))
for i in range(n):
cannons[i].sort(key=lambda x: x[1])
ncan = map(len, cannons)
ndir = []
map(ndir.extend, [map(lambda x: x[0], cannon) for cannon in cannons])
nwei = []
map(nwei.extend, [map(lambda x: x[1], cannon) for cannon in cannons])
nstart = [0] * n
nend = [ncan[0]] * n
for i in range(1, n):
nstart[i] = nend[i-1]
nend[i] = nstart[i] + ncan[i]
def solve(node):
que = [0] * n
neque = [0] * n
que_i = 0
neque_i = 0
visited = [False] * n
best = [1000100000] * n
best[node] = 0
for _ in range(n):
to_use = visited.index(False)
for j in range(to_use, n):
if not visited[j] and best[j] < best[to_use]:
to_use = j
visited[to_use] = True
offset = int(best[to_use]) % n
basic = best[to_use]
done = [False] * n
nwei_i = nstart[to_use]
baseoffset = nwei[nwei_i]
delta = 0
# if basic + baseoffset > 1000100000:
# impossible
# continue
while nwei_i < nend[to_use] and nwei[nwei_i] <= baseoffset:
que[que_i] = nwei_i
que_i += 1
nwei_i += 1
v = basic + baseoffset
while que_i:
for i in range(que_i):
testnode = que[i]
target = (ndir[testnode] + offset + delta -
(nwei[testnode] - baseoffset)) % n
if done[target]:
continue
done[target] = True
if not visited[target] and best[target] > v:
best[target] = v
elif target != to_use:
continue
neque[neque_i] = testnode
neque_i += 1
que, neque = neque, que
que_i = neque_i
neque_i = 0
delta += 1
v += 1
while nwei_i < nend[to_use] and nwei[nwei_i] == baseoffset + delta:
que[que_i] = nwei_i
que_i += 1
nwei_i += 1
return best
for i in range(n):
out.writeLine(' '.join(map(str, solve(i))))
###############
# BOILERPLATE #
###############
output_obj = Output()
main(Input(), output_obj)
output_obj.finalize()
``` | instruction | 0 | 15,322 | 1 | 30,644 |
No | output | 1 | 15,322 | 1 | 30,645 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in Shaazzzland, numbered from 0 to n-1. Ghaazzzland, the immortal enemy of Shaazzzland, is ruled by AaParsa.
As the head of the Ghaazzzland's intelligence agency, AaParsa is carrying out the most important spying mission in Ghaazzzland's history on Shaazzzland.
AaParsa has planted m transport cannons in the cities of Shaazzzland. The i-th cannon is planted in the city a_i and is initially pointing at city b_i.
It is guaranteed that each of the n cities has at least one transport cannon planted inside it, and that no two cannons from the same city are initially pointing at the same city (that is, all pairs (a_i, b_i) are distinct).
AaParsa used very advanced technology to build the cannons, the cannons rotate every second. In other words, if the i-th cannon is pointing towards the city x at some second, it will target the city (x + 1) mod n at the next second.
As their name suggests, transport cannons are for transportation, specifically for human transport. If you use the i-th cannon to launch yourself towards the city that it's currently pointing at, you'll be airborne for c_i seconds before reaching your target destination.
If you still don't get it, using the i-th cannon at the s-th second (using which is only possible if you are currently in the city a_i) will shoot you to the city (b_i + s) mod n and you'll land in there after c_i seconds (so you'll be there in the (s + c_i)-th second). Also note the cannon that you initially launched from will rotate every second but you obviously won't change direction while you are airborne.
AaParsa wants to use the cannons for travelling between Shaazzzland's cities in his grand plan, and he can start travelling at second 0. For him to fully utilize them, he needs to know the minimum number of seconds required to reach city u from city v using the cannons for every pair of cities (u, v).
Note that AaParsa can stay in a city for as long as he wants.
Input
The first line contains two integers n and m (2 ≤ n ≤ 600 , n ≤ m ≤ n^2) — the number of cities and cannons correspondingly.
The i-th line of the following m lines contains three integers a_i, b_i and c_i ( 0 ≤ a_i , b_i ≤ n-1 , 1 ≤ c_i ≤ 10^9), denoting the cannon in the city a_i, which is initially pointing to b_i and travelling by which takes c_i seconds.
It is guaranteed that each of the n cities has at least one transport cannon planted inside it, and that no two cannons from the same city are initially pointing at the same city (that is, all pairs (a_i, b_i) are distinct).
Output
Print n lines, each line should contain n integers.
The j-th integer in the i-th line should be equal to the minimum time required to reach city j from city i.
Examples
Input
3 4
0 1 1
0 2 3
1 0 1
2 0 1
Output
0 1 2
1 0 2
1 2 0
Input
6 6
0 0 1
1 1 1
2 2 1
3 3 1
4 4 1
5 5 1
Output
0 2 3 3 4 4
4 0 2 3 3 4
4 4 0 2 3 3
3 4 4 0 2 3
3 3 4 4 0 2
2 3 3 4 4 0
Input
4 5
0 1 1
1 3 2
2 2 10
3 0 1
0 0 2
Output
0 1 2 3
3 0 3 2
12 13 0 11
1 2 2 0
Note
In the first example one possible path for going from 0 to 2 would be:
1. Stay inside 0 and do nothing for 1 second.
2. Use the first cannon and land at 2 after 1 second.
Note that: we could have used the second cannon in 0-th second but it would have taken us 3 seconds to reach city 2 in that case.
Submitted Solution:
```
""" Python 3 compatibility tools. """
from __future__ import division, print_function
import sys
import os
if False:
from typing import List, Set, Dict, Tuple, Text, Optional, Callable, Any
from collections import deque
import collections
from types import GeneratorType
import itertools
import operator
import functools
import random
import copy
import heapq
import math
from atexit import register
from io import BytesIO, IOBase
import __pypy__ # type: ignore
EPS = 10**-12
#########
# INPUT #
#########
class Input(object):
def __init__(self):
if 'CPH' not in os.environ:
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
def rawInput(self):
# type: () -> str
return sys.stdin.readline().rstrip('\r\n')
def readInt(self):
return int(self.rawInput())
##########
# OUTPUT #
##########
class Output(object):
def __init__(self):
self.out = __pypy__.builders.StringBuilder()
def write(self, text):
# type: (str) -> None
self.out.append(str(text))
def writeLine(self, text):
# type: (str) -> None
self.write(str(text) + '\n')
def finalize(self):
if sys.version_info[0] < 3:
os.write(1, self.out.build())
else:
os.write(1, self.out.build().encode())
###########
# LIBRARY #
###########
def bootstrap(f, stack=[]):
# Deep Recursion helper.
# From: https://github.com/cheran-senthil/PyRival/blob/c1972da95d102d95b9fea7c5c8e0474d61a54378/docs/bootstrap.rst
# Usage:
# @bootstrap
# def recur(n):
# if n == 0:
# yield 1
# yield (yield recur(n-1)) * n
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
int_add = __pypy__.intop.int_add
int_sub = __pypy__.intop.int_sub
int_mul = __pypy__.intop.int_mul
def make_mod_mul(mod):
fmod_inv = 1.0 / mod
def mod_mul(a, b, c=0):
res = int_sub(int_add(int_mul(a, b), c), int_mul(
mod, int(fmod_inv * a * b + fmod_inv * c)))
if res >= mod:
return res - mod
elif res < 0:
return res + mod
else:
return res
return mod_mul
#########
# LOGIC #
#########
def main(inp, out):
# type: (Input, Output) -> None
n, m = map(int, inp.rawInput().split())
cannons = [[] for _ in range(n)]
for _ in range(m):
u, v, w = map(int, inp.rawInput().split())
cannons[u].append((v, w))
for i in range(n):
cannons[i].sort(key=lambda x: x[1])
ncan = map(len, cannons)
ndir = [map(lambda x: x[0], cannon) for cannon in cannons]
nwei = [map(lambda x: x[1], cannon) for cannon in cannons]
def solve(node):
que = [0] * n
neque = [0] * n
que_i = 0
neque_i = 0
visited = [False] * n
best = [1000100000] * n
best[node] = 0
for _ in range(n):
to_use = visited.index(False)
for j in range(to_use, n):
if not visited[j] and best[j] < best[to_use]:
to_use = j
visited[to_use] = True
offset = int(best[to_use]) % n
basic = best[to_use]
done = [False] * n
cdir = ndir[to_use]
cwei = nwei[to_use]
ccan = ncan[to_use]
baseoffset = cwei[0]
if baseoffset + basic > 1000100000:
continue
delta = 0
nwei_i = 0
while nwei_i < ccan and cwei[nwei_i] <= baseoffset:
que[que_i] = nwei_i
que_i += 1
nwei_i += 1
v = basic + baseoffset
while que_i or neque_i:
if delta % 2 == 0:
for i in range(que_i):
testnode = que[i]
target = (cdir[testnode] + offset + delta -
(cwei[testnode] - baseoffset)) % n
if done[target]:
continue
done[target] = True
if not visited[target] and best[target] > v:
best[target] = v
neque[neque_i] = testnode
neque_i += 1
que_i = 0
delta += 1
v += 1
while nwei_i < ccan and cwei[nwei_i] == baseoffset + delta:
que[que_i] = nwei_i
que_i += 1
nwei_i += 1
else:
for i in range(neque_i):
testnode = neque[i]
target = (cdir[testnode] + offset + delta -
(cwei[testnode] - baseoffset)) % n
if done[target]:
continue
done[target] = True
if not visited[target] and best[target] > v:
best[target] = v
que[que_i] = testnode
que_i += 1
neque_i = 0
delta += 1
v += 1
while nwei_i < ccan and cwei[nwei_i] == baseoffset + delta:
neque[neque_i] = nwei_i
neque_i += 1
nwei_i += 1
return best
for i in range(n):
out.writeLine(' '.join(map(str, solve(i))))
###############
# BOILERPLATE #
###############
output_obj = Output()
main(Input(), output_obj)
output_obj.finalize()
``` | instruction | 0 | 15,323 | 1 | 30,646 |
No | output | 1 | 15,323 | 1 | 30,647 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in Shaazzzland, numbered from 0 to n-1. Ghaazzzland, the immortal enemy of Shaazzzland, is ruled by AaParsa.
As the head of the Ghaazzzland's intelligence agency, AaParsa is carrying out the most important spying mission in Ghaazzzland's history on Shaazzzland.
AaParsa has planted m transport cannons in the cities of Shaazzzland. The i-th cannon is planted in the city a_i and is initially pointing at city b_i.
It is guaranteed that each of the n cities has at least one transport cannon planted inside it, and that no two cannons from the same city are initially pointing at the same city (that is, all pairs (a_i, b_i) are distinct).
AaParsa used very advanced technology to build the cannons, the cannons rotate every second. In other words, if the i-th cannon is pointing towards the city x at some second, it will target the city (x + 1) mod n at the next second.
As their name suggests, transport cannons are for transportation, specifically for human transport. If you use the i-th cannon to launch yourself towards the city that it's currently pointing at, you'll be airborne for c_i seconds before reaching your target destination.
If you still don't get it, using the i-th cannon at the s-th second (using which is only possible if you are currently in the city a_i) will shoot you to the city (b_i + s) mod n and you'll land in there after c_i seconds (so you'll be there in the (s + c_i)-th second). Also note the cannon that you initially launched from will rotate every second but you obviously won't change direction while you are airborne.
AaParsa wants to use the cannons for travelling between Shaazzzland's cities in his grand plan, and he can start travelling at second 0. For him to fully utilize them, he needs to know the minimum number of seconds required to reach city u from city v using the cannons for every pair of cities (u, v).
Note that AaParsa can stay in a city for as long as he wants.
Input
The first line contains two integers n and m (2 ≤ n ≤ 600 , n ≤ m ≤ n^2) — the number of cities and cannons correspondingly.
The i-th line of the following m lines contains three integers a_i, b_i and c_i ( 0 ≤ a_i , b_i ≤ n-1 , 1 ≤ c_i ≤ 10^9), denoting the cannon in the city a_i, which is initially pointing to b_i and travelling by which takes c_i seconds.
It is guaranteed that each of the n cities has at least one transport cannon planted inside it, and that no two cannons from the same city are initially pointing at the same city (that is, all pairs (a_i, b_i) are distinct).
Output
Print n lines, each line should contain n integers.
The j-th integer in the i-th line should be equal to the minimum time required to reach city j from city i.
Examples
Input
3 4
0 1 1
0 2 3
1 0 1
2 0 1
Output
0 1 2
1 0 2
1 2 0
Input
6 6
0 0 1
1 1 1
2 2 1
3 3 1
4 4 1
5 5 1
Output
0 2 3 3 4 4
4 0 2 3 3 4
4 4 0 2 3 3
3 4 4 0 2 3
3 3 4 4 0 2
2 3 3 4 4 0
Input
4 5
0 1 1
1 3 2
2 2 10
3 0 1
0 0 2
Output
0 1 2 3
3 0 3 2
12 13 0 11
1 2 2 0
Note
In the first example one possible path for going from 0 to 2 would be:
1. Stay inside 0 and do nothing for 1 second.
2. Use the first cannon and land at 2 after 1 second.
Note that: we could have used the second cannon in 0-th second but it would have taken us 3 seconds to reach city 2 in that case.
Submitted Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
def dijkstra(n, E, i0=0):
D = [1 << 30] * n
D[i0] = 0
Q = set([i for i in range(n)])
while Q:
d = 1 << 30
for q in Q:
if D[q] < d:
i = q
d = D[q]
Q.remove(i)
for j, w in enumerate(E[i]):
jj = (j + d) % n
if jj == i: continue
nd = d + w
if D[jj] > nd:
D[jj] = nd
# return D
return " ".join(map(str, D))
N, M = map(int, input().split())
inf = 2 * 10 ** 9
X = [[inf] * N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
X[a][b] = c
Y = [[0] * N for _ in range(N)]
for i, Yi in enumerate(Y):
Xi = X[i]
for j in range(N):
if j and mi < Xi[j] + N - 1:
mi += 1
Yi[j] = mi
continue
mi = inf
for k in range(N):
mi = min(mi, Xi[j-k] + k)
Yi[j] = mi
Z = [dijkstra(N, Y, s) for s in range(N)]
print("\n".join(Z))
``` | instruction | 0 | 15,324 | 1 | 30,648 |
No | output | 1 | 15,324 | 1 | 30,649 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Berland a bus travels along the main street of the capital. The street begins from the main square and looks like a very long segment. There are n bus stops located along the street, the i-th of them is located at the distance ai from the central square, all distances are distinct, the stops are numbered in the order of increasing distance from the square, that is, ai < ai + 1 for all i from 1 to n - 1. The bus starts its journey from the first stop, it passes stops 2, 3 and so on. It reaches the stop number n, turns around and goes in the opposite direction to stop 1, passing all the intermediate stops in the reverse order. After that, it again starts to move towards stop n. During the day, the bus runs non-stop on this route.
The bus is equipped with the Berland local positioning system. When the bus passes a stop, the system notes down its number.
One of the key features of the system is that it can respond to the queries about the distance covered by the bus for the parts of its path between some pair of stops. A special module of the system takes the input with the information about a set of stops on a segment of the path, a stop number occurs in the set as many times as the bus drove past it. This module returns the length of the traveled segment of the path (or -1 if it is impossible to determine the length uniquely). The operation of the module is complicated by the fact that stop numbers occur in the request not in the order they were visited but in the non-decreasing order.
For example, if the number of stops is 6, and the part of the bus path starts at the bus stop number 5, ends at the stop number 3 and passes the stops as follows: <image>, then the request about this segment of the path will have form: 3, 4, 5, 5, 6. If the bus on the segment of the path from stop 5 to stop 3 has time to drive past the 1-th stop (i.e., if we consider a segment that ends with the second visit to stop 3 on the way from 5), then the request will have form: 1, 2, 2, 3, 3, 4, 5, 5, 6.
You will have to repeat the Berland programmers achievement and implement this function.
Input
The first line contains integer n (2 ≤ n ≤ 2·105) — the number of stops.
The second line contains n integers (1 ≤ ai ≤ 109) — the distance from the i-th stop to the central square. The numbers in the second line go in the increasing order.
The third line contains integer m (1 ≤ m ≤ 4·105) — the number of stops the bus visited on some segment of the path.
The fourth line contains m integers (1 ≤ bi ≤ n) — the sorted list of numbers of the stops visited by the bus on the segment of the path. The number of a stop occurs as many times as it was visited by a bus.
It is guaranteed that the query corresponds to some segment of the path.
Output
In the single line please print the distance covered by a bus. If it is impossible to determine it unambiguously, print - 1.
Examples
Input
6
2 3 5 7 11 13
5
3 4 5 5 6
Output
10
Input
6
2 3 5 7 11 13
9
1 2 2 3 3 4 5 5 6
Output
16
Input
3
10 200 300
4
1 2 2 3
Output
-1
Input
3
1 2 3
4
1 2 2 3
Output
3
Note
The first test from the statement demonstrates the first example shown in the statement of the problem.
The second test from the statement demonstrates the second example shown in the statement of the problem.
In the third sample there are two possible paths that have distinct lengths, consequently, the sought length of the segment isn't defined uniquely.
In the fourth sample, even though two distinct paths correspond to the query, they have the same lengths, so the sought length of the segment is defined uniquely. | instruction | 0 | 15,466 | 1 | 30,932 |
Tags: constructive algorithms, greedy, hashing, implementation
Correct Solution:
```
r = lambda: list(map(int, input().split()))
ri = lambda: int(input())
n, a, m, b = ri(), r(), ri(), r()
c = [0] * n
for e in b: c[e - 1] += 1
c[0] *= 2; c[-1] *= 2
d = 0
df= 0
r = max(e // 2 for e in c)
c = [e - r * 2 for e in c]
if any(c):
for i in range(n - 1):
de = a[i+1] - a[i]
d += min(c[i], c[i+1]) * de
df += de
print(d + r * 2 * df)
else:
de = a[1] - a[0]
for i in range(1, n - 1):
if a[i + 1] - a[i] != de: print(-1); break
else: print(r * de * 2 * (n - 1) - de)
``` | output | 1 | 15,466 | 1 | 30,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Berland a bus travels along the main street of the capital. The street begins from the main square and looks like a very long segment. There are n bus stops located along the street, the i-th of them is located at the distance ai from the central square, all distances are distinct, the stops are numbered in the order of increasing distance from the square, that is, ai < ai + 1 for all i from 1 to n - 1. The bus starts its journey from the first stop, it passes stops 2, 3 and so on. It reaches the stop number n, turns around and goes in the opposite direction to stop 1, passing all the intermediate stops in the reverse order. After that, it again starts to move towards stop n. During the day, the bus runs non-stop on this route.
The bus is equipped with the Berland local positioning system. When the bus passes a stop, the system notes down its number.
One of the key features of the system is that it can respond to the queries about the distance covered by the bus for the parts of its path between some pair of stops. A special module of the system takes the input with the information about a set of stops on a segment of the path, a stop number occurs in the set as many times as the bus drove past it. This module returns the length of the traveled segment of the path (or -1 if it is impossible to determine the length uniquely). The operation of the module is complicated by the fact that stop numbers occur in the request not in the order they were visited but in the non-decreasing order.
For example, if the number of stops is 6, and the part of the bus path starts at the bus stop number 5, ends at the stop number 3 and passes the stops as follows: <image>, then the request about this segment of the path will have form: 3, 4, 5, 5, 6. If the bus on the segment of the path from stop 5 to stop 3 has time to drive past the 1-th stop (i.e., if we consider a segment that ends with the second visit to stop 3 on the way from 5), then the request will have form: 1, 2, 2, 3, 3, 4, 5, 5, 6.
You will have to repeat the Berland programmers achievement and implement this function.
Input
The first line contains integer n (2 ≤ n ≤ 2·105) — the number of stops.
The second line contains n integers (1 ≤ ai ≤ 109) — the distance from the i-th stop to the central square. The numbers in the second line go in the increasing order.
The third line contains integer m (1 ≤ m ≤ 4·105) — the number of stops the bus visited on some segment of the path.
The fourth line contains m integers (1 ≤ bi ≤ n) — the sorted list of numbers of the stops visited by the bus on the segment of the path. The number of a stop occurs as many times as it was visited by a bus.
It is guaranteed that the query corresponds to some segment of the path.
Output
In the single line please print the distance covered by a bus. If it is impossible to determine it unambiguously, print - 1.
Examples
Input
6
2 3 5 7 11 13
5
3 4 5 5 6
Output
10
Input
6
2 3 5 7 11 13
9
1 2 2 3 3 4 5 5 6
Output
16
Input
3
10 200 300
4
1 2 2 3
Output
-1
Input
3
1 2 3
4
1 2 2 3
Output
3
Note
The first test from the statement demonstrates the first example shown in the statement of the problem.
The second test from the statement demonstrates the second example shown in the statement of the problem.
In the third sample there are two possible paths that have distinct lengths, consequently, the sought length of the segment isn't defined uniquely.
In the fourth sample, even though two distinct paths correspond to the query, they have the same lengths, so the sought length of the segment is defined uniquely. | instruction | 0 | 15,467 | 1 | 30,934 |
Tags: constructive algorithms, greedy, hashing, implementation
Correct Solution:
```
n=int(input())
c=[0]*n
a=[int(x) for x in input().split()]
m=int(input())
b=[int(x)-1 for x in input().split()]
for e in b:
c[e]+=1
c[0]*=2
c[-1]*=2
d=0
df=0
r=max([e//2 for e in c])
c=[e-r*2 for e in c]
if not any(c):
de=a[1]-a[0]
for i in range(1,n-1):
if a[i+1]-a[i]!=de:
print(-1)
break
else:
print(r*de*2*(n-1)-de)
else:
for i in range(n-1):
de=a[i+1]-a[i]
d+=min(c[i],c[i+1])*de
df+=de
print(d+r*2*df)
``` | output | 1 | 15,467 | 1 | 30,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Berland a bus travels along the main street of the capital. The street begins from the main square and looks like a very long segment. There are n bus stops located along the street, the i-th of them is located at the distance ai from the central square, all distances are distinct, the stops are numbered in the order of increasing distance from the square, that is, ai < ai + 1 for all i from 1 to n - 1. The bus starts its journey from the first stop, it passes stops 2, 3 and so on. It reaches the stop number n, turns around and goes in the opposite direction to stop 1, passing all the intermediate stops in the reverse order. After that, it again starts to move towards stop n. During the day, the bus runs non-stop on this route.
The bus is equipped with the Berland local positioning system. When the bus passes a stop, the system notes down its number.
One of the key features of the system is that it can respond to the queries about the distance covered by the bus for the parts of its path between some pair of stops. A special module of the system takes the input with the information about a set of stops on a segment of the path, a stop number occurs in the set as many times as the bus drove past it. This module returns the length of the traveled segment of the path (or -1 if it is impossible to determine the length uniquely). The operation of the module is complicated by the fact that stop numbers occur in the request not in the order they were visited but in the non-decreasing order.
For example, if the number of stops is 6, and the part of the bus path starts at the bus stop number 5, ends at the stop number 3 and passes the stops as follows: <image>, then the request about this segment of the path will have form: 3, 4, 5, 5, 6. If the bus on the segment of the path from stop 5 to stop 3 has time to drive past the 1-th stop (i.e., if we consider a segment that ends with the second visit to stop 3 on the way from 5), then the request will have form: 1, 2, 2, 3, 3, 4, 5, 5, 6.
You will have to repeat the Berland programmers achievement and implement this function.
Input
The first line contains integer n (2 ≤ n ≤ 2·105) — the number of stops.
The second line contains n integers (1 ≤ ai ≤ 109) — the distance from the i-th stop to the central square. The numbers in the second line go in the increasing order.
The third line contains integer m (1 ≤ m ≤ 4·105) — the number of stops the bus visited on some segment of the path.
The fourth line contains m integers (1 ≤ bi ≤ n) — the sorted list of numbers of the stops visited by the bus on the segment of the path. The number of a stop occurs as many times as it was visited by a bus.
It is guaranteed that the query corresponds to some segment of the path.
Output
In the single line please print the distance covered by a bus. If it is impossible to determine it unambiguously, print - 1.
Examples
Input
6
2 3 5 7 11 13
5
3 4 5 5 6
Output
10
Input
6
2 3 5 7 11 13
9
1 2 2 3 3 4 5 5 6
Output
16
Input
3
10 200 300
4
1 2 2 3
Output
-1
Input
3
1 2 3
4
1 2 2 3
Output
3
Note
The first test from the statement demonstrates the first example shown in the statement of the problem.
The second test from the statement demonstrates the second example shown in the statement of the problem.
In the third sample there are two possible paths that have distinct lengths, consequently, the sought length of the segment isn't defined uniquely.
In the fourth sample, even though two distinct paths correspond to the query, they have the same lengths, so the sought length of the segment is defined uniquely.
Submitted Solution:
```
n=int(input())
c=[0]*n
a=[int(x) for x in input().split()]
m=int(input())
b=[int(x)-1 for x in input().split()]
for e in b:
c[e]+=1
c[0]*=2
c[-1]*=2
d=0
df=0
r=max([e//2 for e in c])
c=[e-r*2 for e in c]
if not any(c):
de=a[1]-a[0]
for i in range(1,n-1):
if a[i+1]-a[i]!=de:
print(-1)
break
else:
print(r*de*2*(n-1)+de*(2*(n-1)-1))
else:
for i in range(n-1):
de=a[i+1]-a[i]
d+=min(c[i],c[i+1])*de
df+=de
print(d+r*2*df)
``` | instruction | 0 | 15,468 | 1 | 30,936 |
No | output | 1 | 15,468 | 1 | 30,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Berland a bus travels along the main street of the capital. The street begins from the main square and looks like a very long segment. There are n bus stops located along the street, the i-th of them is located at the distance ai from the central square, all distances are distinct, the stops are numbered in the order of increasing distance from the square, that is, ai < ai + 1 for all i from 1 to n - 1. The bus starts its journey from the first stop, it passes stops 2, 3 and so on. It reaches the stop number n, turns around and goes in the opposite direction to stop 1, passing all the intermediate stops in the reverse order. After that, it again starts to move towards stop n. During the day, the bus runs non-stop on this route.
The bus is equipped with the Berland local positioning system. When the bus passes a stop, the system notes down its number.
One of the key features of the system is that it can respond to the queries about the distance covered by the bus for the parts of its path between some pair of stops. A special module of the system takes the input with the information about a set of stops on a segment of the path, a stop number occurs in the set as many times as the bus drove past it. This module returns the length of the traveled segment of the path (or -1 if it is impossible to determine the length uniquely). The operation of the module is complicated by the fact that stop numbers occur in the request not in the order they were visited but in the non-decreasing order.
For example, if the number of stops is 6, and the part of the bus path starts at the bus stop number 5, ends at the stop number 3 and passes the stops as follows: <image>, then the request about this segment of the path will have form: 3, 4, 5, 5, 6. If the bus on the segment of the path from stop 5 to stop 3 has time to drive past the 1-th stop (i.e., if we consider a segment that ends with the second visit to stop 3 on the way from 5), then the request will have form: 1, 2, 2, 3, 3, 4, 5, 5, 6.
You will have to repeat the Berland programmers achievement and implement this function.
Input
The first line contains integer n (2 ≤ n ≤ 2·105) — the number of stops.
The second line contains n integers (1 ≤ ai ≤ 109) — the distance from the i-th stop to the central square. The numbers in the second line go in the increasing order.
The third line contains integer m (1 ≤ m ≤ 4·105) — the number of stops the bus visited on some segment of the path.
The fourth line contains m integers (1 ≤ bi ≤ n) — the sorted list of numbers of the stops visited by the bus on the segment of the path. The number of a stop occurs as many times as it was visited by a bus.
It is guaranteed that the query corresponds to some segment of the path.
Output
In the single line please print the distance covered by a bus. If it is impossible to determine it unambiguously, print - 1.
Examples
Input
6
2 3 5 7 11 13
5
3 4 5 5 6
Output
10
Input
6
2 3 5 7 11 13
9
1 2 2 3 3 4 5 5 6
Output
16
Input
3
10 200 300
4
1 2 2 3
Output
-1
Input
3
1 2 3
4
1 2 2 3
Output
3
Note
The first test from the statement demonstrates the first example shown in the statement of the problem.
The second test from the statement demonstrates the second example shown in the statement of the problem.
In the third sample there are two possible paths that have distinct lengths, consequently, the sought length of the segment isn't defined uniquely.
In the fourth sample, even though two distinct paths correspond to the query, they have the same lengths, so the sought length of the segment is defined uniquely.
Submitted Solution:
```
n=int(input())
c=[0]*n
a=[int(x) for x in input().split()]
m=int(input())
b=[int(x)-1 for x in input().split()]
for e in b:
c[e]+=1
c[0]*=2
c[-1]*=2
d=0
df=0
r=max([e//2 for e in c])
c=[e-r*2 for e in c]
if not any(c):
df=a[1]-a[0]
for i in range(1,n-1):
if a[i+1]-a[i]!=df:
print(-1)
break
else:
print(df*2*(n-1)-1)
else:
for i in range(n-1):
de=a[i+1]-a[i]
d+=min(c[i],c[i+1])*de
df+=de
print(d+r*2*df)
``` | instruction | 0 | 15,469 | 1 | 30,938 |
No | output | 1 | 15,469 | 1 | 30,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image> | instruction | 0 | 15,618 | 1 | 31,236 |
Tags: brute force, geometry, math
Correct Solution:
```
print(2 * int(0.99999 + 2 * int(input()) ** 0.5))
``` | output | 1 | 15,618 | 1 | 31,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image> | instruction | 0 | 15,619 | 1 | 31,238 |
Tags: brute force, geometry, math
Correct Solution:
```
from math import trunc, sqrt
n = int(input())
a = trunc(sqrt(n))
if a * a == n:
print(4*a)
elif a * (a + 1) >= n:
print(2 * (a + a + 1))
else:
print(4 * (a + 1))
``` | output | 1 | 15,619 | 1 | 31,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image> | instruction | 0 | 15,620 | 1 | 31,240 |
Tags: brute force, geometry, math
Correct Solution:
```
from math import ceil,sqrt
x = int(input())
a = ceil(sqrt(x))
r = 2*a + 2*ceil(x/a)
print(r)
``` | output | 1 | 15,620 | 1 | 31,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image> | instruction | 0 | 15,621 | 1 | 31,242 |
Tags: brute force, geometry, math
Correct Solution:
```
n=int(input())
i=1
while i*i<=n:
i+=1
i-=1
k=n-i*i
if k==0:
print(i*4)
elif k<=i:
print(2+4*i)
else:
print(4+4*i)
``` | output | 1 | 15,621 | 1 | 31,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image> | instruction | 0 | 15,622 | 1 | 31,244 |
Tags: brute force, geometry, math
Correct Solution:
```
N = int(input())
Rows = int(N ** 0.5)
Columns = N // Rows
print(2 * (Columns + Rows) if Rows * Columns == N else 2 * (Columns + Rows) + 2)
# UB_CodeForces
# Advice: Limits Exist just in your mind
# Location: Under this beautiful sky
# Caption: So much energy it took me to solve
``` | output | 1 | 15,622 | 1 | 31,245 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image> | instruction | 0 | 15,623 | 1 | 31,246 |
Tags: brute force, geometry, math
Correct Solution:
```
n = int(input())
i = 1
while True:
start, end = i**2 - i + 1, i**2
if start <= n <= end:
print(i*4)
exit()
elif n < start:
print(i*4 - 2)
exit()
i += 1
``` | output | 1 | 15,623 | 1 | 31,247 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image> | instruction | 0 | 15,624 | 1 | 31,248 |
Tags: brute force, geometry, math
Correct Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
N=int(input())
x=int(N**0.5)
if (x*x==N):
print(4*x)
else:
y=x*x
x+=1
z=x*x
if (abs(N-y)>abs(z-N)):
print(4*x)
else:
print(4*x-2)
``` | output | 1 | 15,624 | 1 | 31,249 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image> | instruction | 0 | 15,625 | 1 | 31,250 |
Tags: brute force, geometry, math
Correct Solution:
```
n = int(input())
a = 1
b = 1
while 1:
if (a * b) >= n:
break
if a < b:
a = b
elif a == b:
b = b + 1
print((a+b)*2)
``` | output | 1 | 15,625 | 1 | 31,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image>
Submitted Solution:
```
N = int(input())
import math
a1 = int(math.sqrt(N))
a2 = int(math.ceil(math.sqrt(N)))
if N - a1*a1 <= a1:
if N == a1*a1:
print(4*a1)
else:
print(4*a1 + 2)
else:
print(4*a2)
``` | instruction | 0 | 15,626 | 1 | 31,252 |
Yes | output | 1 | 15,626 | 1 | 31,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image>
Submitted Solution:
```
from sys import stdin, stdout
n = int(stdin.readline())
l, r = 0, n + 1
while r - l > 1:
m = (r + l) >> 1
if m * m > n:
r = m
else:
l = m
if n > 1:
ans = 8 + (l - 2) * 4
else:
ans = 4
n -= l * l
for i in range(l):
if not i:
if n:
ans += 2
n -= 1
else:
if n:
n -= 1
for i in range(l):
if not i:
if n:
ans += 2
n -= 1
else:
if n:
n -= 1
stdout.write(str(ans))
``` | instruction | 0 | 15,627 | 1 | 31,254 |
Yes | output | 1 | 15,627 | 1 | 31,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image>
Submitted Solution:
```
import math
n = int(input())
a = math.ceil(n ** 0.5)
b = math.floor(n ** 0.5)
if (a*b < n):
b += 1
print ((b+a)*2)#
``` | instruction | 0 | 15,628 | 1 | 31,256 |
Yes | output | 1 | 15,628 | 1 | 31,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image>
Submitted Solution:
```
import math
num = int(input())
side = math.ceil(num**0.5)
if (side - 1) * side >= num:
ans = (side*2-1)*2
else:
ans = side * 4
print(ans)
``` | instruction | 0 | 15,629 | 1 | 31,258 |
Yes | output | 1 | 15,629 | 1 | 31,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image>
Submitted Solution:
```
import math
n=int(input())
p=int(math.sqrt(n))
for x in range(p,n):
if(x*p>=n):
print (2*(x+p))
break
``` | instruction | 0 | 15,630 | 1 | 31,260 |
No | output | 1 | 15,630 | 1 | 31,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image>
Submitted Solution:
```
import math
from collections import defaultdict
ml=lambda:map(float,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:list(input())
"""========main code==============="""
t=ii()
k=int(math.sqrt(t))
t-=k*k
ans=k*2
k+=t//k
t%=k
if(t==0):
ans+=k*2
else:
ans+=2*(k+1)
print(ans)
``` | instruction | 0 | 15,631 | 1 | 31,262 |
No | output | 1 | 15,631 | 1 | 31,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image>
Submitted Solution:
```
import math
def Solution(N):
N = math.sqrt(N)
perimeter = 4 * N
return perimeter
N = int(input())
Solution(N)
``` | instruction | 0 | 15,632 | 1 | 31,264 |
No | output | 1 | 15,632 | 1 | 31,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.
Input
Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.
Output
Print the minimum perimeter that can be achieved.
Examples
Input
4
Output
8
Input
11
Output
14
Input
22
Output
20
Note
Here are some possible shapes for the examples:
<image>
Submitted Solution:
```
a = int(input())
b = 1
while b*b<=a:
b += 1
if a==b*b:
print(b*4)
if a-b*b<=b:
print(b*4 + 2)
print(b*4 + 2+2)
``` | instruction | 0 | 15,633 | 1 | 31,266 |
No | output | 1 | 15,633 | 1 | 31,267 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yui loves shopping. She lives in Yamaboshi City and there is a train service in the city. The city can be modelled as a very long number line. Yui's house is at coordinate 0.
There are N shopping centres in the city, located at coordinates x_{1}, x_{2}, ..., x_{N} respectively. There are N + 2 train stations, one located at coordinate 0, one located at coordinate L, and one located at each shopping centre.
At time 0, the train departs from position 0 to the positive direction. The train travels at a constant speed of 1 unit per second. At time L, the train will reach the last station, the station at coordinate L. The train immediately moves in the opposite direction at the same speed. At time 2L, the train will reach the station at coordinate 0 and it immediately moves in the opposite direction again. The process repeats indefinitely.
When the train arrives at a station where Yui is located, Yui can board or leave the train immediately. At time 0, Yui is at the station at coordinate 0.
Yui wants to go shopping in all N shopping centres, in any order, and return home after she finishes her shopping. She needs to shop for t_{i} seconds in the shopping centre at coordinate x_{i}. She must finish her shopping in one shopping centre before moving to the next shopping centre. Yui can immediately start shopping when she reaches a station with a shopping centre and she can immediately board the train when she finishes shopping.
Yui wants to spend the minimum amount of time to finish her shopping. Can you help her determine the minimum number of seconds required to complete her shopping?
Constraints
* 1 \leq N \leq 300000
* 1 \leq L \leq 10^{9}
* 0 < x_{1} < x_{2} < ... < x_{N} < L
* 1 \leq t_{i} \leq 10^{9}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N L
x_{1} x_{2} ... x_{N}
t_{1} t_{2} ... t_{N}
Output
Print the minimum time (in seconds) required for Yui to finish shopping at all N shopping centres and return home.
Examples
Input
2 10
5 8
10 4
Output
40
Input
2 10
5 8
10 5
Output
60
Input
5 100
10 19 28 47 68
200 200 200 200 200
Output
1200
Input
8 1000000000
2018 123456 1719128 1929183 9129198 10100101 77777777 120182018
99999999 1000000000 1000000000 11291341 1 200 1 123812831
Output
14000000000
Submitted Solution:
```
N,L=map(int,input().split())
x=[int(i) for i in input().split()]
t=[int(i) for i in input().split()]
l=[0 for i in range(N)]
for i in range(N):
p=t[i]//L
l[i]+=2*p
if 2*(t[i]-2*p)<=max([2*L-abs(L-2*x[i]),abs(L-2*x[i])]):
l[i]+=1
else:
l[i]+=2
print(int(round(sum(l)+0.5,0))*L)
``` | instruction | 0 | 15,795 | 1 | 31,590 |
No | output | 1 | 15,795 | 1 | 31,591 |
Provide a correct Python 3 solution for this coding contest problem.
Jim is planning to visit one of his best friends in a town in the mountain area. First, he leaves his hometown and goes to the destination town. This is called the go phase. Then, he comes back to his hometown. This is called the return phase. You are expected to write a program to find the minimum total cost of this trip, which is the sum of the costs of the go phase and the return phase.
There is a network of towns including these two towns. Every road in this network is one-way, i.e., can only be used towards the specified direction. Each road requires a certain cost to travel.
In addition to the cost of roads, it is necessary to pay a specified fee to go through each town on the way. However, since this is the visa fee for the town, it is not necessary to pay the fee on the second or later visit to the same town.
The altitude (height) of each town is given. On the go phase, the use of descending roads is inhibited. That is, when going from town a to b, the altitude of a should not be greater than that of b. On the return phase, the use of ascending roads is inhibited in a similar manner. If the altitudes of a and b are equal, the road from a to b can be used on both phases.
Input
The input consists of multiple datasets, each in the following format.
n m
d2 e2
d3 e3
.
.
.
dn-1 en-1
a1 b1 c1
a2 b2 c2
.
.
.
am bm cm
Every input item in a dataset is a non-negative integer. Input items in a line are separated by a space.
n is the number of towns in the network. m is the number of (one-way) roads. You can assume the inequalities 2 ≤ n ≤ 50 and 0 ≤ m ≤ n(n−1) hold. Towns are numbered from 1 to n, inclusive. The town 1 is Jim's hometown, and the town n is the destination town.
di is the visa fee of the town i, and ei is its altitude. You can assume 1 ≤ di ≤ 1000 and 1≤ei ≤ 999 for 2≤i≤n−1. The towns 1 and n do not impose visa fee. The altitude of the town 1 is 0, and that of the town n is 1000. Multiple towns may have the same altitude, but you can assume that there are no more than 10 towns with the same altitude.
The j-th road is from the town aj to bj with the cost cj (1 ≤ j ≤ m). You can assume 1 ≤ aj ≤ n, 1 ≤ bj ≤ n, and 1 ≤ cj ≤ 1000. You can directly go from aj to bj, but not from bj to aj unless a road from bj to aj is separately given. There are no two roads connecting the same pair of towns towards the same direction, that is, for any i and j such that i ≠ j, ai ≠ aj or bi ≠ bj. There are no roads connecting a town to itself, that is, for any j, aj ≠ bj.
The last dataset is followed by a line containing two zeros (separated by a space).
Output
For each dataset in the input, a line containing the minimum total cost, including the visa fees, of the trip should be output. If such a trip is not possible, output "-1".
Example
Input
3 6
3 1
1 2 1
2 3 1
3 2 1
2 1 1
1 3 4
3 1 4
3 6
5 1
1 2 1
2 3 1
3 2 1
2 1 1
1 3 4
3 1 4
4 5
3 1
3 1
1 2 5
2 3 5
3 4 5
4 2 5
3 1 5
2 1
2 1 1
0 0
Output
7
8
36
-1 | instruction | 0 | 15,895 | 1 | 31,790 |
"Correct Solution:
```
from heapq import heappush, heappop
from collections import defaultdict
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N, M = map(int, readline().split())
if N == M == 0:
return False
D = [0]*N; E = [0]*N
B = [0]*N
H = defaultdict(int)
H[0] = 1
H[1000] += 1
E[N-1] = 1000
for i in range(1, N-1):
D[i], e = map(int, readline().split())
E[i] = e
B[i] = H[e]
H[e] += 1
G = [[] for i in range(N)]
RG = [[] for i in range(N)]
for i in range(M):
a, b, c = map(int, readline().split()); a -= 1; b -= 1
if E[a] <= E[b]:
G[a].append((b, c))
if E[b] <= E[a]:
RG[b].append((a, c))
dist = {(0, 0, 1): 0}
que = [(0, 0, 0, 1)]
INF = 10**18
while que:
cost, v0, v1, state = heappop(que)
if dist[v0, v1, state] < cost:
continue
d0 = E[v0]; d1 = E[v1]
if d0 < d1:
for w0, d in G[v0]:
if E[w0] == d1:
if w0 == v1:
de = cost + d
n_state = (1 << B[w0])
else:
de = cost + d + D[w0]
n_state = (1 << B[w0]) | (1 << B[v1])
n_key = (w0, v1, n_state)
if de < dist.get(n_key, INF):
dist[n_key] = de
heappush(que, (de, w0, v1, n_state))
else:
n_key = (w0, v1, 0)
de = cost + d + D[w0]
if de < dist.get(n_key, INF):
dist[n_key] = de
heappush(que, (de, w0, v1, 0))
elif d0 > d1:
for w1, d in RG[v1]:
if E[w1] == d0:
if w1 == v0:
de = cost + d
n_state = (1 << B[w1])
else:
de = cost + d + D[w1]
n_state = (1 << B[w1]) | (1 << B[v0])
n_key = (v0, w1, n_state)
if de < dist.get(n_key, INF):
dist[n_key] = de
heappush(que, (de, v0, w1, n_state))
else:
n_key = (v0, w1, 0)
de = cost + d + D[w1]
if de < dist.get(n_key, INF):
dist[n_key] = de
heappush(que, (de, v0, w1, 0))
else:
ds = d0
for w0, d in G[v0]:
if ds == E[w0]:
b = (1 << B[w0])
if state & b:
de = cost + d
n_state = state
else:
de = cost + d + D[w0]
n_state = state | b
n_key = (w0, v1, n_state)
if de < dist.get(n_key, INF):
dist[n_key] = de
heappush(que, (de, w0, v1, n_state))
else:
n_key = (w0, v1, 0)
de = cost + d + D[w0]
if de < dist.get(n_key, INF):
dist[n_key] = de
heappush(que, (de, w0, v1, 0))
for w1, d in RG[v1]:
if ds == E[w1]:
b = (1 << B[w1])
if state & b:
de = cost + d
n_state = state
else:
de = cost + d + D[w1]
n_state = state | b
n_key = (v0, w1, n_state)
if de < dist.get(n_key, INF):
dist[n_key] = de
heappush(que, (de, v0, w1, n_state))
else:
n_key = (v0, w1, 0)
de = cost + d + D[w1]
if de < dist.get(n_key, INF):
dist[n_key] = de
heappush(que, (de, v0, w1, 0))
g_key = (N-1, N-1, 1)
if g_key in dist:
write("%d\n" % dist[g_key])
else:
write("-1\n")
return True
while solve():
...
``` | output | 1 | 15,895 | 1 | 31,791 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.