message stringlengths 2 22.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 16 109k | cluster float64 1 1 | __index_level_0__ int64 32 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image> | instruction | 0 | 100,339 | 1 | 200,678 |
Tags: data structures, dp, trees
Correct Solution:
```
import sys
readline = sys.stdin.readline
from collections import Counter
def parorder(Edge, p):
N = len(Edge)
par = [0]*N
par[p] = -1
stack = [p]
visited = set([p])
order = []
while stack:
vn = stack.pop()
order.append(vn)
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
stack.append(vf)
return par, order
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N = int(readline())
We = list(map(int, readline().split()))
Edge = [[] for _ in range(N)]
Cost = Counter()
geta = N+1
for _ in range(N-1):
a, b, c = map(int, readline().split())
a -= 1
b -= 1
Edge[a].append(b)
Edge[b].append(a)
Cost[b*geta+a] = c
Cost[a*geta+b] = c
P, L = parorder(Edge, 0)
#C = getcld(P)
dp = [0]*N
candi = [[0, 0] for _ in range(N)]
ans = 0
for l in L[::-1][:-1]:
dp[l] += We[l]
p = P[l]
k = dp[l] - Cost[l*geta + p]
if k > 0:
dp[p] = max(dp[p], k)
candi[p].append(k)
res = max(candi[l])
candi[l].remove(res)
ans = max(ans, We[l] + res + max(candi[l]))
res = max(candi[0])
candi[0].remove(res)
ans = max(ans, We[0] + res + max(candi[0]))
print(ans)
``` | output | 1 | 100,339 | 1 | 200,679 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image> | instruction | 0 | 100,340 | 1 | 200,680 |
Tags: data structures, dp, trees
Correct Solution:
```
from sys import stdin
input=lambda : stdin.readline().strip()
from math import ceil,sqrt,factorial,gcd
from collections import deque
n=int(input())
l=list(map(int,input().split()))
visited=set()
graph={i:set() for i in range(1,n+1)}
d={}
papa=[0 for i in range(n+1)]
level=[[] for i in range(n+1)]
z=[[0] for i in range(n+1)]
for i in range(n-1):
a,b,c=map(int,input().split())
graph[a].add(b)
graph[b].add(a)
d[(a,b)]=c
stack=deque()
# print(graph)
for i in graph:
if len(graph[i])==1:
stack.append([i,0])
m=0
while stack:
# print(stack)
x,y=stack.popleft()
if len(graph[x])>=1:
for i in graph[x]:
t=i
break
if (t,x) in d:
q=d[(t,x)]
else:
q=d[(x,t)]
z[t].append(y+l[x-1]-q)
graph[t].remove(x)
if len(graph[t])==1:
stack.append([t,max(z[t])])
for i in range(1,n+1):
z[i].sort()
if len(z[i])>=3:
m=max(m,l[i-1]+z[i][-2]+z[i][-1])
m=max(m,z[i][-1]+l[i-1])
print(m)
``` | output | 1 | 100,340 | 1 | 200,681 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image> | instruction | 0 | 100,341 | 1 | 200,682 |
Tags: data structures, dp, trees
Correct Solution:
```
from sys import stdin, setrecursionlimit
import threading
n = int(stdin.readline())
w = [int(x) for x in stdin.readline().split()]
graph = [{} for x in range(n)]
for road in range(n-1):
u,v,c = [int(x) for x in stdin.readline().split()]
u -= 1
v -= 1
if v in graph[u]:
graph[u][v] = min(graph[u][v], c)
else:
graph[u][v] = c
if u in graph[v]:
graph[v][u] = min(graph[v][u], c)
else:
graph[v][u] = c
gas = [{} for x in range(n)]
highs = [[0,0] for x in range(n)]
path = [(0,0)]
ind = 0
while ind < len(path):
cur, par = path[ind]
edges = graph[cur]
for x in edges:
if x != par:
path.append((x,cur))
ind += 1
def mostGas(node,parent):
edges = graph[node]
high = w[node]
high2 = w[node]
for x in edges:
if x != parent:
gas[node][x] = highs[x][0] + w[node] - edges[x]
if gas[node][x] > high:
high,high2 = gas[node][x], high
elif gas[node][x] > high2:
high2 = gas[node][x]
highs[node] = [high,high2]
return high
'''def fillIn(node,parent):
edges = graph[node]
high,high2 = highs[node]
for x in edges:
if x != parent:
if gas[node][x] == high:
gas[x][node] = high2 - edges[x]
else:
gas[x][node] = high - edges[x]
if gas[x][node] > highs[x][0]:
highs[x] = [gas[x][node], highs[x][0]]
elif gas[x][node] > highs[x][1]:
highs[x][1] = gas[x][node]
fillIn(x,node)'''
for x,y in path[::-1]:
mostGas(x,y)
#fillIn(0,0)
high = 0
for x in range(n):
high = max(high, highs[x][0]+highs[x][1]-w[x])
print(high)
``` | output | 1 | 100,341 | 1 | 200,683 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image> | instruction | 0 | 100,342 | 1 | 200,684 |
Tags: data structures, dp, trees
Correct Solution:
```
import sys
readline = sys.stdin.readline
from collections import Counter
def parorder(Edge, p):
N = len(Edge)
par = [0]*N
par[p] = -1
stack = [p]
order = []
visited = set([p])
ast = stack.append
apo = order.append
while stack:
vn = stack.pop()
apo(vn)
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
ast(vf)
return par, order
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N = int(readline())
We = list(map(int, readline().split()))
Edge = [[] for _ in range(N)]
Cost = Counter()
geta = N+1
for _ in range(N-1):
a, b, c = map(int, readline().split())
a -= 1
b -= 1
Edge[a].append(b)
Edge[b].append(a)
Cost[b*geta+a] = c
Cost[a*geta+b] = c
P, L = parorder(Edge, 0)
#C = getcld(P)
dp = [0]*N
candi = [[0, 0] for _ in range(N)]
ans = 0
for l in L[::-1][:-1]:
dp[l] += We[l]
p = P[l]
k = dp[l] - Cost[l*geta + p]
if k > 0:
dp[p] = max(dp[p], k)
candi[p].append(k)
res = max(candi[l])
candi[l].remove(res)
ans = max(ans, We[l] + res + max(candi[l]))
res = max(candi[0])
candi[0].remove(res)
ans = max(ans, We[0] + res + max(candi[0]))
print(ans)
``` | output | 1 | 100,342 | 1 | 200,685 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image> | instruction | 0 | 100,343 | 1 | 200,686 |
Tags: data structures, dp, trees
Correct Solution:
```
import sys
import io, os
#input = sys.stdin.buffer.readline
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n = int(input())
W = list(map(int, input().split()))
g = [[] for i in range(n)]
edge = []
for i in range(n-1):
u, v, c = map(int, input().split())
u, v = u-1, v-1
g[u].append((c, v))
g[v].append((c, u))
edge.append((u, v, c))
s = []
s.append(0)
par = [-1]*n
order = []
while s:
v = s.pop()
order.append(v)
for c, u in g[v]:
if u == par[v]:
continue
s.append(u)
par[u] = v
C = [0]*n
for u, v, c in edge:
if u == par[v]:
C[v] = c
else:
C[u] = c
order.reverse()
import heapq
hq = []
for i in range(n):
q = []
heapq.heapify(q)
hq.append(q)
ans = [0]*n
dp = [0]*n
for v in order:
if not hq[v]:
ans[v] = W[v]
dp[v] = W[v]
elif len(hq[v]) == 1:
temp = W[v]
x = heapq.heappop(hq[v])
x = -x
ans[v] = W[v]+x
dp[v] = W[v]+x
else:
temp = W[v]
x = heapq.heappop(hq[v])
x = -x
ans[v] = W[v]+x
dp[v] = W[v]+x
x = heapq.heappop(hq[v])
x = -x
ans[v] += x
if par[v] != -1:
heapq.heappush(hq[par[v]], -max(0, dp[v]-C[v]))
print(max(ans))
``` | output | 1 | 100,343 | 1 | 200,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image>
Submitted Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
adj = [[] for i in range(n)]
for i in range(n-1):
u, v, w = map(int, input().split())
u -= 1
v -= 1
adj[u].append((v, w))
adj[v].append((u, w))
best = [0] * n
ans = 0
def dfs(u):
stack = list()
visit = [False] * n
stack.append((u, -1))
while stack:
u, par = stack[-1]
if not visit[u]:
visit[u] = True
for v, w in adj[u]:
if v != par:
stack.append((v, u))
else:
cand = []
for v, w in adj[u]:
if v != par:
cand.append(best[v] + a[v] - w)
cand.sort(reverse=True)
cur = a[u]
for i in range(2):
if i < len(cand) and cand[i] > 0:
cur += cand[i]
global ans
ans = max(ans, cur)
best[u] = cand[0] if len(cand) > 0 and cand[0] > 0 else 0
stack.pop()
dfs(0)
print(ans)
``` | instruction | 0 | 100,344 | 1 | 200,688 |
Yes | output | 1 | 100,344 | 1 | 200,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image>
Submitted Solution:
```
# if there >=2 branches u have the option to take the best in ur path
# also u need to change the node good shit with the best 1 or
from collections import defaultdict
from sys import stdin,setrecursionlimit
input=stdin.readline
#first dfs i can do for best 1 ? this works i think
ans=0
from types import GeneratorType
def bootstrap(f, stack=[]):
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
# *************************************************************************************#
@bootstrap
def dfs(node,parent,wt,g,dp):
global ans
l=wt[node]
t=[]
for i,w in g[node]:
if i!=parent:
yield dfs(i,node,wt,g,dp)
l=max(dp[i]+wt[node]-w,l)
t.append(dp[i]+wt[node]-w)
dp[node]=l
t=sorted(t,reverse=True)
ans=max(ans,l)
if len(t)>=2:
ans=max(ans,t[0]+t[1]-wt[node])
yield l
def main():
global ans
n=int(input())
wt=list(map(int,input().strip().split()))
g=defaultdict(list)
for _ in range(n-1):
x,y,w=map(int,input().strip().split())
g[x-1].append((y-1,w))
g[y-1].append((x-1,w))
dp=[0]*(n)
dfs(0,-1,wt,g,dp)
print(ans)
main()
``` | instruction | 0 | 100,345 | 1 | 200,690 |
Yes | output | 1 | 100,345 | 1 | 200,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image>
Submitted Solution:
```
from collections import deque
def recurse(x,d,w,parent,v,vb):
best = 0
bestt = 0
ans = 0
for t in d[x]:
node = t[0]
if node == parent:
continue
weight = int(w[node-1])-t[1]
ans = max(ans,v[node])
tot = weight+vb[node]
if tot > best:
bestt = best
best = tot
elif tot > bestt:
bestt = tot
ans = max(ans,best+bestt+int(w[x-1]))
v[x] = ans
vb[x] = best
return (ans,best)
n = int(input())
w = input().split()
dic = {}
for i in range(1,n+1):
dic[i] = []
for i in range(n-1):
u,v,c = map(int,input().split())
dic[u].append((v,c))
dic[v].append((u,c))
dq = deque()
dq.append(1)
visit = set()
l = []
l.append((1,0))
while len(dq) > 0:
cur = dq.pop()
visit.add(cur)
for t in dic[cur]:
node = t[0]
if node not in visit:
l.append((node,cur))
dq.append(node)
val = [0]*(n+1)
valb = [0]*(n+1)
for i in range(len(l)-1,-1,-1):
recurse(l[i][0],dic,w,l[i][1],val,valb)
print(val[1])
``` | instruction | 0 | 100,346 | 1 | 200,692 |
Yes | output | 1 | 100,346 | 1 | 200,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image>
Submitted Solution:
```
import sys
readline = sys.stdin.readline
from collections import Counter
def getpar(Edge, p):
N = len(Edge)
par = [0]*N
par[0] = -1
par[p] -1
stack = [p]
visited = set([p])
while stack:
vn = stack.pop()
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
stack.append(vf)
return par
def topological_sort_tree(E, r):
Q = [r]
L = []
visited = set([r])
while Q:
vn = Q.pop()
L.append(vn)
for vf in E[vn]:
if vf not in visited:
visited.add(vf)
Q.append(vf)
return L
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N = int(readline())
We = list(map(int, readline().split()))
Edge = [[] for _ in range(N)]
Cost = Counter()
geta = N+1
for _ in range(N-1):
a, b, c = map(int, readline().split())
a -= 1
b -= 1
Edge[a].append(b)
Edge[b].append(a)
Cost[b*geta+a] = c
Cost[a*geta+b] = c
P = getpar(Edge, 0)
L = topological_sort_tree(Edge, 0)
C = getcld(P)
dp = [0]*N
candi = [[0, 0] for _ in range(N)]
ans = 0
for l in L[::-1][:-1]:
dp[l] += We[l]
p = P[l]
k = dp[l] - Cost[l*geta + p]
if k > 0:
dp[p] = max(dp[p], k)
candi[p].append(k)
res = max(candi[l])
candi[l].remove(res)
ans = max(ans, We[l] + res + max(candi[l]))
res = max(candi[0])
candi[0].remove(res)
ans = max(ans, We[0] + res + max(candi[0]))
print(ans)
``` | instruction | 0 | 100,347 | 1 | 200,694 |
Yes | output | 1 | 100,347 | 1 | 200,695 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image>
Submitted Solution:
```
def ii():
return int(input())
def mi():
return map(int, input().split())
def li():
return list(mi())
import sys
sys.setrecursionlimit(10 ** 7)
# A. The Fair Nut and the Best Path
n = ii()
a = [None] + li()
g = [[] for i in range(n + 1)]
for i in range(n - 1):
u, v, c = mi()
g[u].append((v, c))
g[v].append((u, c))
ans = -1
def dfs(u, p):
global ans
difs = []
for v, w in g[u]:
if v == p: continue
dif = dfs(v, u)
difs.append(dif - w)
if len(difs) >= 2:
ans = max(ans, difs[-1] + difs[-2] + a[u])
mx = 0
if len(difs) >= 1:
ans = max(ans, difs[-1] + a[u])
mx = max(mx, difs[-1])
return mx + a[u]
dfs(1, 1)
print(max(0, ans))
``` | instruction | 0 | 100,348 | 1 | 200,696 |
No | output | 1 | 100,348 | 1 | 200,697 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image>
Submitted Solution:
```
n=int(input())
w=list(map(int,input().split()))
def findshit(nweights,tree,memo,vertex):
if vertex in memo:
return memo[vertex]
childs=[]
for child in tree[vertex]:
childs.append(findshit(nweights,tree,memo,child[0])-child[1])
childs.sort()
childs+=[0,0]
memo[vertex]=nweights[vertex]+max((childs[0],0))+max((childs[1],0))
return nweights[vertex]+max((childs[0],0))+max((childs[1],0))
nweights={}
tree={}
memo={}
for i in range(n):
tree[i+1]=[]
for i in range(n):
nweights[i+1]=w[i]
for i in range(n-1):
a,b,c=map(int,input().split())
tree[a].append((b,c))
tree[b].append((a,c))
visited=[1]
lastlayer=[1]
while len(visited)<n:
newlayer=[]
for vert in lastlayer:
for guy in tree[vert]:
tree[guy[0]].remove((vert,guy[1]))
newlayer.append(guy[0])
lastlayer=newlayer
visited+=newlayer
findshit(nweights,tree,memo,1)
best=0
for guy in memo:
best=max((memo[guy],best))
print(best)
``` | instruction | 0 | 100,349 | 1 | 200,698 |
No | output | 1 | 100,349 | 1 | 200,699 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image>
Submitted Solution:
```
import sys
import math
from collections import defaultdict,deque
tree=defaultdict(list)
n=int(sys.stdin.readline())
gas=list(map(int,sys.stdin.readline().split()))
dist=defaultdict(int)
for i in range(n-1):
u,v,w=map(int,sys.stdin.readline().split())
tree[u].append([v,w])
tree[v].append([u,w])
dist[(min(u,v),max(u,v))]=w
leaves=deque()
dp=[0 for _ in range(n+1)]
for i in tree:
if len(tree[i])==1:
leaves.append([i,gas[i-1]])
dp[i]=gas[i-1]
#print(leaves,'leaves')
vis=defaultdict(int)
for i in range(1,n+1):
dp[i]=gas[i-1]
while leaves:
a,g=leaves.popleft()
for j,w in tree[a]:
if vis[(min(j,a),max(j,a))]==0:
vis[(min(j,a),max(j,a))]=1
if g>=w:
val=g-w+gas[j-1]
dp[j]=max(dp[j]+g-w,g-w+gas[j-1],gas[j-1])
leaves.append([j,val])
#print(dp,'dp')
#print(vis,'vis')
if n==1:
print(gas[0])
sys.exit()
print(max(dp))
``` | instruction | 0 | 100,350 | 1 | 200,700 |
No | output | 1 | 100,350 | 1 | 200,701 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of cities.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_{i} ≤ 10^9) — the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 ≤ u, v ≤ n, 1 ≤ c ≤ 10^9, u ≠ v), where u and v — cities that are connected by this road and c — its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number — the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 → 1 → 3.
<image>
The optimal way in the second example is 2 → 4.
<image>
Submitted Solution:
```
o = []
oGraph = []
#print("Enter Number of oil station")
n=int(input())
#print("Enter Number of roads")
oGraph = [[-1]*n for i in range(n)]
o=[0]*n
oil = []
a=[]
b=[]
dist = []
maxO=[]
track = []
#print("Enter amount of oil in each station")
o=[int(x) for x in input().split()]
# for i in range(n):
# oil = int(input())
# o[i]=oil
#print("Enter roads distance with connected roads")
for j in range(n-1):
# a=int(input())
# b=int(input())
# dist = int(input())
gg=[int(x) for x in input().split()]
if((o[gg[0]-1]>(o[gg[0]-1]+o[gg[1]-1])-gg[2]) or (o[gg[1]-1]>(o[gg[0]-1]+o[gg[1]-1])-gg[2])):
oGraph[gg[0]-1][gg[1]-1]=-1
else:
oGraph[gg[0]-1][gg[1]-1]=gg[2]
stk = []
visited = [0]*n
amax=-1
for e in range(n):
if(visited[e]==0):
stk.append(e)
visited[e]=1
maxO=o[e]
track.append(e)
while stk:
v = stk.pop()
visited[v]=2
for j in range(n):
if ((oGraph[v][j]>-1) and (visited[j]==0)):
if(maxO<((maxO+o[j])-oGraph[v][j])):
maxO=((maxO+o[j])-oGraph[v][j])
track.append(j)
if(o[j]>maxO):
#maxO=o[j]
track = []
track.append(j)
#print("----------------")
visited[j]=1
stk.append(j)
#print(maxO)
if(maxO>amax):
amax=maxO
print(amax)
#print(track)
``` | instruction | 0 | 100,351 | 1 | 200,702 |
No | output | 1 | 100,351 | 1 | 200,703 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the capital city of Berland, Bertown, demonstrations are against the recent election of the King of Berland. Berland opposition, led by Mr. Ovalny, believes that the elections were not fair enough and wants to organize a demonstration at one of the squares.
Bertown has n squares, numbered from 1 to n, they are numbered in the order of increasing distance between them and the city center. That is, square number 1 is central, and square number n is the farthest from the center. Naturally, the opposition wants to hold a meeting as close to the city center as possible (that is, they want an square with the minimum number).
There are exactly k (k < n) days left before the demonstration. Now all squares are free. But the Bertown city administration never sleeps, and the approval of an application for the demonstration threatens to become a very complex process. The process of approval lasts several days, but every day the following procedure takes place:
* The opposition shall apply to hold a demonstration at a free square (the one which isn't used by the administration).
* The administration tries to move the demonstration to the worst free square left. To do this, the administration organizes some long-term activities on the square, which is specified in the application of opposition. In other words, the administration starts using the square and it is no longer free. Then the administration proposes to move the opposition demonstration to the worst free square. If the opposition has applied for the worst free square then request is accepted and administration doesn't spend money. If the administration does not have enough money to organize an event on the square in question, the opposition's application is accepted. If administration doesn't have enough money to organize activity, then rest of administration's money spends and application is accepted
* If the application is not accepted, then the opposition can agree to the administration's proposal (that is, take the worst free square), or withdraw the current application and submit another one the next day. If there are no more days left before the meeting, the opposition has no choice but to agree to the proposal of City Hall. If application is accepted opposition can reject it. It means than opposition still can submit more applications later, but square remains free.
In order to organize an event on the square i, the administration needs to spend ai bourles. Because of the crisis the administration has only b bourles to confront the opposition. What is the best square that the opposition can take, if the administration will keep trying to occupy the square in question each time? Note that the administration's actions always depend only on the actions of the opposition.
Input
The first line contains two integers n and k — the number of squares and days left before the meeting, correspondingly (1 ≤ k < n ≤ 105).
The second line contains a single integer b — the number of bourles the administration has (1 ≤ b ≤ 1018).
The third line contains n space-separated integers ai — the sum of money, needed to organise an event on square i (1 ≤ ai ≤ 109).
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number — the minimum number of the square where the opposition can organize the demonstration.
Examples
Input
5 2
8
2 4 5 3 1
Output
2
Input
5 2
8
3 2 4 1 5
Output
5
Input
5 4
1000000000000000
5 4 3 2 1
Output
5
Note
In the first sample the opposition can act like this. On day one it applies for square 3. The administration has to organize an event there and end up with 3 bourles. If on the second day the opposition applies for square 2, the administration won't have the money to intervene.
In the second sample the opposition has only the chance for the last square. If its first move occupies one of the first four squares, the administration is left with at least 4 bourles, which means that next day it can use its next move to move the opposition from any square to the last one.
In the third sample administration has a lot of money, so opposition can occupy only last square. | instruction | 0 | 100,606 | 1 | 201,212 |
Tags: greedy
Correct Solution:
```
from sys import stdin, stdout
n, k = map(int, stdin.readline().split())
value = int(stdin.readline())
prices = list(map(int, stdin.readline().split()))
used = {}
challengers = prices[:-1]
for i in range(n - 1):
challengers[i] = (challengers[i], i)
challengers.sort(reverse = True)
ind = challengers[k - 1][1]
cnt = 0
for i in range(k):
used[challengers[i][1]] = challengers[i][0]
cnt += challengers[i][0]
for i in range(n - 1):
if not i in used and value < cnt - used[ind] + prices[i]:
stdout.write(str(i + 1))
break
elif i in used and value < cnt:
stdout.write(str(i + 1))
break
else:
stdout.write(str(n))
``` | output | 1 | 100,606 | 1 | 201,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the capital city of Berland, Bertown, demonstrations are against the recent election of the King of Berland. Berland opposition, led by Mr. Ovalny, believes that the elections were not fair enough and wants to organize a demonstration at one of the squares.
Bertown has n squares, numbered from 1 to n, they are numbered in the order of increasing distance between them and the city center. That is, square number 1 is central, and square number n is the farthest from the center. Naturally, the opposition wants to hold a meeting as close to the city center as possible (that is, they want an square with the minimum number).
There are exactly k (k < n) days left before the demonstration. Now all squares are free. But the Bertown city administration never sleeps, and the approval of an application for the demonstration threatens to become a very complex process. The process of approval lasts several days, but every day the following procedure takes place:
* The opposition shall apply to hold a demonstration at a free square (the one which isn't used by the administration).
* The administration tries to move the demonstration to the worst free square left. To do this, the administration organizes some long-term activities on the square, which is specified in the application of opposition. In other words, the administration starts using the square and it is no longer free. Then the administration proposes to move the opposition demonstration to the worst free square. If the opposition has applied for the worst free square then request is accepted and administration doesn't spend money. If the administration does not have enough money to organize an event on the square in question, the opposition's application is accepted. If administration doesn't have enough money to organize activity, then rest of administration's money spends and application is accepted
* If the application is not accepted, then the opposition can agree to the administration's proposal (that is, take the worst free square), or withdraw the current application and submit another one the next day. If there are no more days left before the meeting, the opposition has no choice but to agree to the proposal of City Hall. If application is accepted opposition can reject it. It means than opposition still can submit more applications later, but square remains free.
In order to organize an event on the square i, the administration needs to spend ai bourles. Because of the crisis the administration has only b bourles to confront the opposition. What is the best square that the opposition can take, if the administration will keep trying to occupy the square in question each time? Note that the administration's actions always depend only on the actions of the opposition.
Input
The first line contains two integers n and k — the number of squares and days left before the meeting, correspondingly (1 ≤ k < n ≤ 105).
The second line contains a single integer b — the number of bourles the administration has (1 ≤ b ≤ 1018).
The third line contains n space-separated integers ai — the sum of money, needed to organise an event on square i (1 ≤ ai ≤ 109).
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number — the minimum number of the square where the opposition can organize the demonstration.
Examples
Input
5 2
8
2 4 5 3 1
Output
2
Input
5 2
8
3 2 4 1 5
Output
5
Input
5 4
1000000000000000
5 4 3 2 1
Output
5
Note
In the first sample the opposition can act like this. On day one it applies for square 3. The administration has to organize an event there and end up with 3 bourles. If on the second day the opposition applies for square 2, the administration won't have the money to intervene.
In the second sample the opposition has only the chance for the last square. If its first move occupies one of the first four squares, the administration is left with at least 4 bourles, which means that next day it can use its next move to move the opposition from any square to the last one.
In the third sample administration has a lot of money, so opposition can occupy only last square.
Submitted Solution:
```
w=list(map(int,input().split(' ')))
n=w[0]
k=w[1]
m=int(input())
c=list(map(int,input().split(' ')))
while k>1 and m>0:
k=k-1
m=m-max(c[0:(len(c)-1)])
if k>1:
print('1')
else:
if m>=max(c[0:(len(c)-1)]):
print(n)
else:
a=max(c[0:(len(c)-1)])
b=c.index(a) +1
print(b)
``` | instruction | 0 | 100,607 | 1 | 201,214 |
No | output | 1 | 100,607 | 1 | 201,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the capital city of Berland, Bertown, demonstrations are against the recent election of the King of Berland. Berland opposition, led by Mr. Ovalny, believes that the elections were not fair enough and wants to organize a demonstration at one of the squares.
Bertown has n squares, numbered from 1 to n, they are numbered in the order of increasing distance between them and the city center. That is, square number 1 is central, and square number n is the farthest from the center. Naturally, the opposition wants to hold a meeting as close to the city center as possible (that is, they want an square with the minimum number).
There are exactly k (k < n) days left before the demonstration. Now all squares are free. But the Bertown city administration never sleeps, and the approval of an application for the demonstration threatens to become a very complex process. The process of approval lasts several days, but every day the following procedure takes place:
* The opposition shall apply to hold a demonstration at a free square (the one which isn't used by the administration).
* The administration tries to move the demonstration to the worst free square left. To do this, the administration organizes some long-term activities on the square, which is specified in the application of opposition. In other words, the administration starts using the square and it is no longer free. Then the administration proposes to move the opposition demonstration to the worst free square. If the opposition has applied for the worst free square then request is accepted and administration doesn't spend money. If the administration does not have enough money to organize an event on the square in question, the opposition's application is accepted. If administration doesn't have enough money to organize activity, then rest of administration's money spends and application is accepted
* If the application is not accepted, then the opposition can agree to the administration's proposal (that is, take the worst free square), or withdraw the current application and submit another one the next day. If there are no more days left before the meeting, the opposition has no choice but to agree to the proposal of City Hall. If application is accepted opposition can reject it. It means than opposition still can submit more applications later, but square remains free.
In order to organize an event on the square i, the administration needs to spend ai bourles. Because of the crisis the administration has only b bourles to confront the opposition. What is the best square that the opposition can take, if the administration will keep trying to occupy the square in question each time? Note that the administration's actions always depend only on the actions of the opposition.
Input
The first line contains two integers n and k — the number of squares and days left before the meeting, correspondingly (1 ≤ k < n ≤ 105).
The second line contains a single integer b — the number of bourles the administration has (1 ≤ b ≤ 1018).
The third line contains n space-separated integers ai — the sum of money, needed to organise an event on square i (1 ≤ ai ≤ 109).
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number — the minimum number of the square where the opposition can organize the demonstration.
Examples
Input
5 2
8
2 4 5 3 1
Output
2
Input
5 2
8
3 2 4 1 5
Output
5
Input
5 4
1000000000000000
5 4 3 2 1
Output
5
Note
In the first sample the opposition can act like this. On day one it applies for square 3. The administration has to organize an event there and end up with 3 bourles. If on the second day the opposition applies for square 2, the administration won't have the money to intervene.
In the second sample the opposition has only the chance for the last square. If its first move occupies one of the first four squares, the administration is left with at least 4 bourles, which means that next day it can use its next move to move the opposition from any square to the last one.
In the third sample administration has a lot of money, so opposition can occupy only last square.
Submitted Solution:
```
from sys import stdin, stdout
n, k = map(int, stdin.readline().split())
values = int(stdin.readline())
prices = list(map(int, stdin.readline().split()))
m = max(prices[:-1])
for i in range(k - 1):
values -= min(values, m)
for i in range(n):
if prices[i] > values:
stdout.write(str(i + 1))
break
else:
stdout.write(str(n))
``` | instruction | 0 | 100,608 | 1 | 201,216 |
No | output | 1 | 100,608 | 1 | 201,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the capital city of Berland, Bertown, demonstrations are against the recent election of the King of Berland. Berland opposition, led by Mr. Ovalny, believes that the elections were not fair enough and wants to organize a demonstration at one of the squares.
Bertown has n squares, numbered from 1 to n, they are numbered in the order of increasing distance between them and the city center. That is, square number 1 is central, and square number n is the farthest from the center. Naturally, the opposition wants to hold a meeting as close to the city center as possible (that is, they want an square with the minimum number).
There are exactly k (k < n) days left before the demonstration. Now all squares are free. But the Bertown city administration never sleeps, and the approval of an application for the demonstration threatens to become a very complex process. The process of approval lasts several days, but every day the following procedure takes place:
* The opposition shall apply to hold a demonstration at a free square (the one which isn't used by the administration).
* The administration tries to move the demonstration to the worst free square left. To do this, the administration organizes some long-term activities on the square, which is specified in the application of opposition. In other words, the administration starts using the square and it is no longer free. Then the administration proposes to move the opposition demonstration to the worst free square. If the opposition has applied for the worst free square then request is accepted and administration doesn't spend money. If the administration does not have enough money to organize an event on the square in question, the opposition's application is accepted. If administration doesn't have enough money to organize activity, then rest of administration's money spends and application is accepted
* If the application is not accepted, then the opposition can agree to the administration's proposal (that is, take the worst free square), or withdraw the current application and submit another one the next day. If there are no more days left before the meeting, the opposition has no choice but to agree to the proposal of City Hall. If application is accepted opposition can reject it. It means than opposition still can submit more applications later, but square remains free.
In order to organize an event on the square i, the administration needs to spend ai bourles. Because of the crisis the administration has only b bourles to confront the opposition. What is the best square that the opposition can take, if the administration will keep trying to occupy the square in question each time? Note that the administration's actions always depend only on the actions of the opposition.
Input
The first line contains two integers n and k — the number of squares and days left before the meeting, correspondingly (1 ≤ k < n ≤ 105).
The second line contains a single integer b — the number of bourles the administration has (1 ≤ b ≤ 1018).
The third line contains n space-separated integers ai — the sum of money, needed to organise an event on square i (1 ≤ ai ≤ 109).
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number — the minimum number of the square where the opposition can organize the demonstration.
Examples
Input
5 2
8
2 4 5 3 1
Output
2
Input
5 2
8
3 2 4 1 5
Output
5
Input
5 4
1000000000000000
5 4 3 2 1
Output
5
Note
In the first sample the opposition can act like this. On day one it applies for square 3. The administration has to organize an event there and end up with 3 bourles. If on the second day the opposition applies for square 2, the administration won't have the money to intervene.
In the second sample the opposition has only the chance for the last square. If its first move occupies one of the first four squares, the administration is left with at least 4 bourles, which means that next day it can use its next move to move the opposition from any square to the last one.
In the third sample administration has a lot of money, so opposition can occupy only last square.
Submitted Solution:
```
w=list(map(int,input().split(' ')))
n=w[0]
k=w[1]
m=int(input())
c=list(map(int,input().split(' ')))
while k>1 and m>0:
k=k-1
m=m-max(c[0:(len(c)-1)])
if k>1:
print('1')
else:
if m>=max(c[0:(len(c)-1)]):
print(n)
else:
for i in range(n-1):
a=i+1
if c[i]>m:
break
print(a)
``` | instruction | 0 | 100,609 | 1 | 201,218 |
No | output | 1 | 100,609 | 1 | 201,219 |
Provide a correct Python 3 solution for this coding contest problem.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21 | instruction | 0 | 101,000 | 1 | 202,000 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
def is_bipartite(graph, s):
"""二部グラフ判定する"""
n = len(graph)
col = [-1] * n
col[s] = 0
stack = [s]
used[s] = True
while stack:
v = stack.pop()
for nxt_v in graph[v]:
used[nxt_v] = True
if col[nxt_v] == -1:
col[nxt_v] = col[v] ^ 1
stack.append(nxt_v)
elif col[nxt_v] ^ col[v] == 0:
return False
return True
def color_bipartite(graph, s):
"""二部グラフを彩色する"""
n = len(graph)
col = [-1] * n
col[s] = 0
stack = [s]
while stack:
v = stack.pop()
for nxt_v in graph[v]:
if col[nxt_v] == -1:
col[nxt_v] = col[v] ^ 1
stack.append(nxt_v)
return col
n, m = map(int, input().split())
info = [list(map(int, input().split())) for i in range(m)]
graph = [set() for i in range(n)]
for a, b in info:
a -= 1
b -= 1
graph[a].add(b)
graph[b].add(a)
comp_graph = [[] for i in range(n)]
for a in range(n):
for b in range(n):
if b in graph[a] or a == b:
continue
comp_graph[a].append(b)
cnt0 = []
cnt1 = []
used = [False] * n
for i in range(n):
if used[i]:
continue
used[i] = True
if not is_bipartite(comp_graph, i):
print(-1)
exit()
col = color_bipartite(comp_graph, i)
cnt0.append(col.count(0))
cnt1.append(col.count(1))
dp = [[False] * (n + 1) for i in range(len(cnt0) + 1)]
dp[0][0] = True
for i in range(len(cnt0)):
wei0 = cnt0[i]
wei1 = cnt1[i]
for w in range(n + 1):
if w + wei0 < n + 1:
dp[i + 1][w + wei0] = (dp[i][w] or dp[i + 1][w + wei0])
if w + wei1 < n + 1:
dp[i + 1][w + wei1] = (dp[i][w] or dp[i + 1][w + wei1])
ans = 10 ** 18
for num in range(n + 1):
if dp[-1][num]:
c0 = num
c1 = n - num
res = c0 * (c0 - 1) // 2 + c1 * (c1 - 1) // 2
ans = min(ans, res)
print(ans)
``` | output | 1 | 101,000 | 1 | 202,001 |
Provide a correct Python 3 solution for this coding contest problem.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21 | instruction | 0 | 101,001 | 1 | 202,002 |
"Correct Solution:
```
N,M = map(int,input().split())
E = [[False]*N for _ in range(N)]
for n in range(N):
E[n][n] = True
for _ in range(M):
a,b = map(int,input().split())
a,b = a-1,b-1
E[a][b] = True
E[b][a] = True
unvisited = set(range(N))
color = [None]*N
components = []
while unvisited:
v0 = next(iter(unvisited))
count = [0,0]
stack = [(v0,False)]
while stack:
v,c = stack.pop()
if color[v] is None:
color[v] = c
unvisited.discard(v)
count[c] += 1
for u,f in enumerate(E[v]):
if not f:
stack.append((u, not c))
elif color[v] != c:
print(-1)
exit()
components.append(count)
# DP
L = N//2+1
dp = [False]*L
dp[0] = True
for a,b in components:
ndp = [False]*L
for i,f in enumerate(dp):
if f:
if i+a < L:
ndp[i+a] = True
if i+b < L:
ndp[i+b] = True
dp = ndp
for i,f in zip(reversed(range(L)), reversed(dp)):
if f:
break
j = N - i
print(i*(i-1)//2 + j*(j-1)//2)
``` | output | 1 | 101,001 | 1 | 202,003 |
Provide a correct Python 3 solution for this coding contest problem.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21 | instruction | 0 | 101,002 | 1 | 202,004 |
"Correct Solution:
```
from collections import defaultdict, deque
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
edges = [list(range(N)) for i in range(N)]
for i in range(N):
edges[i].remove(i)
for _ in range(M):
a, b = map(int, input().split())
edges[a-1].remove(b-1)
edges[b-1].remove(a-1)
size = defaultdict(lambda: [0, 0])
color = [-1]*N
def set_color(root):
que = deque([root])
color[root] = 0
size[root][0]+=1
while que:
v = que.pop()
for nv in edges[v]:
if color[nv]<0:
c = 1- color[v]
color[nv] = c
size[root][c]+=1
que.append(nv)
elif color[nv] == color[v]:
print(-1)
sys.exit()
for i in range(N):
if color[i]<0:
set_color(i)
S = set([0])
for a, b in size.values():
S = set(s+b for s in S)|set(s+a for s in S)
ans = min(x*(x-1)//2+(N-x)*(N-x-1)//2 for x in S)
print(ans)
``` | output | 1 | 101,002 | 1 | 202,005 |
Provide a correct Python 3 solution for this coding contest problem.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21 | instruction | 0 | 101,003 | 1 | 202,006 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10**7)
N,M = map(int,input().split())
es = [tuple(map(lambda x:int(x)-1,input().split())) for i in range(M)]
gr = [[0 for j in range(N)] for i in range(N)]
for a,b in es:
gr[a][b] = gr[b][a] = 1
compgr = [[] for i in range(N)]
for i in range(N-1):
for j in range(i+1,N):
if gr[i][j]: continue
compgr[i].append(j)
compgr[j].append(i)
colors = [0] * N
def dfs(v,color):
colors[v] = color
b,w = (1,0) if color==1 else (0,1)
for to in compgr[v]:
if colors[to] == color:
print(-1)
exit()
elif colors[to] == 0:
db,dw = dfs(to, -color)
b += db
w += dw
return [b,w]
dp = set([0])
for i in range(N):
if colors[i] != 0: continue
b,w = dfs(i,1)
dp2 = set()
for n in dp:
dp2.add(n+b)
dp2.add(n+w)
dp = dp2
ans = N*N
for a in dp:
b = N-a
tmp = a*(a-1)//2 + b*(b-1)//2
ans = min(ans, tmp)
print(ans)
``` | output | 1 | 101,003 | 1 | 202,007 |
Provide a correct Python 3 solution for this coding contest problem.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21 | instruction | 0 | 101,004 | 1 | 202,008 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
from collections import defaultdict
# 切り離す必要があるものを辺として、二部グラフの判定
N,M = map(int,input().split())
# 補グラフ
graph = [set(x for x in range(N) if x != y) for y in range(N)]
for _ in range(M):
a,b = map(lambda x: int(x) - 1,input().split())
graph[a].remove(b)
graph[b].remove(a)
color = [None] * N
size = defaultdict(lambda: [0,0])
def set_color(root,x,c):
size[root][c] += 1
color[x] = c
for y in graph[x]:
if color[y] is None:
set_color(root,y,1-c)
elif color[y] == color[x]:
print(-1)
exit()
for x in range(N):
if color[x] is None:
set_color(x,x,0)
# 二部グラフになるべく平均的に分けたい
# 可能なサイズの集合を持つ
se = {0}
for x,y in size.values():
se = set(s + x for s in se) | set(s + y for s in se)
answer = min(x*(x-1)//2+(N-x)*(N-x-1)//2 for x in se)
print(answer)
``` | output | 1 | 101,004 | 1 | 202,009 |
Provide a correct Python 3 solution for this coding contest problem.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21 | instruction | 0 | 101,005 | 1 | 202,010 |
"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**10
mod = 998244353
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-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 main():
n,m = LI()
a = [LI_() for _ in range(m)]
ss = [set() for _ in range(n)]
for b,c in a:
ss[b].add(c)
ss[c].add(b)
ts = [set(list(range(n))) - set([_]) for _ in range(n)]
for i in range(n):
ts[i] -= ss[i]
d = []
u = set()
for i in range(n):
if i in u:
continue
ab = set([i])
nb = set([i])
ac = set()
nc = set()
f = True
while f:
f = False
k = set()
nc = set()
for j in nb:
nc |= ts[j]
nc -= ac
ac |= nc
nb = set()
for j in nc:
nb |= ts[j]
nb -= ab
ab |= nb
if nb:
f = True
if ab & ac:
return -1
d.append((len(ab),len(ac)))
u |= ab
u |= ac
r = set([0])
for b,c in d:
t = set()
for k in r:
t.add(k+b)
t.add(k+c)
r = t
rr = inf
for t in r:
nt = n - t
if t == 0 or nt == 0:
continue
tr = t * (t-1) // 2
tr += nt * (nt-1) // 2
if rr > tr:
rr = tr
return rr
print(main())
``` | output | 1 | 101,005 | 1 | 202,011 |
Provide a correct Python 3 solution for this coding contest problem.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21 | instruction | 0 | 101,006 | 1 | 202,012 |
"Correct Solution:
```
"""
Writer:SPD_9X2
https://atcoder.jp/contests/arc099/tasks/arc099_c
なるべく均等に分けるのが正解
制約を受けるのはv-uの辺が存在しない場合
補グラフで考えると、辺がある2点は同じ側に属してはいけない、という問題になる
→2部グラフにならない連結成分がある場合-1
あとは、連結成分ごとにどちらに属すかを決め、その差を最小化すればよい
→dpで見つけられる！
"""
import sys
N,M = map(int,input().split())
AB = []
olis = [ [1] * N for i in range(N) ]
for i in range(N):
olis[i][i] = 0
for i in range(M):
A,B = map(int,input().split())
A -= 1
B -= 1
olis[A][B] = 0
olis[B][A] = 0
non_visit = [True] * N
state = [None] * N
dif = []
ns = [0,0]
#2部グラフ探索
def dfs(p,nst):
if non_visit[p]:
non_visit[p] = False
state[p] = nst
ns[nst] += 1
for j in range(N):
if p!=j and olis[p][j] == 1:
dfs(j,nst^1)
elif nst != state[p]:
print (-1)
sys.exit()
return;
for i in range(N):
ns = [0,0]
if non_visit[i]:
dfs(i,0)
#print (i)
dif.append(abs(ns[0]-ns[1]))
dp = [False] * 1500
dp[0] = True
for i in dif:
ndp = [False] * 1500
for j in range(1500):
if dp[j]:
ndp[(j-i)%1500] = True
ndp[(j+i)%1500] = True
dp = ndp
for i in range(N):
if dp[i] or dp[-1*i]:
for j in range(N):
if abs(N-j - j) == i:
x = j
y = N-j
print (x*(x-1)//2 + y*(y-1)//2)
sys.exit()
``` | output | 1 | 101,006 | 1 | 202,013 |
Provide a correct Python 3 solution for this coding contest problem.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21 | instruction | 0 | 101,007 | 1 | 202,014 |
"Correct Solution:
```
# 問題の趣旨：できるだけ辺が少なくなるように2つの完全グラフに分けたい
# まず、2つの完全グラフに分けられるのかを調べる必要がある。
# これが不可能であれば-1を出力して即座に終了。
# 分けられる場合は、できるだけ街の数を均等にしたい。
# 以下のアルゴリズムを考える。
# まずお互い繋がっていない都市の組A,Bを選ぶ。
# すると、Aにしか繋がっていない街、Bにしか繋がっていない街、
# 両方に繋がっている街の3グループに分かれる。
# 最初の2グループについてはグループのサイズを保存しておく。
# 最後のグループが空でない場合は、このグループに対してまた同様の処理を行う。
# 街がなくなるか、両方に繋がっている街のグループが
# 完全グラフになった時点で終了。
# 上記のアルゴリズムにより、グループのサイズの列と最後に残った街の数が求められる。
# これをもとに、動的計画法で考えられる街の振り分け方を全て洗い出す。
# 最も均等に近く振り分けた場合について、完全グラフの辺数を計算して
# 出力すれば問題が解ける。
def main():
from sys import stdin
input = stdin.readline
n, m = map(int, input().split())
ab = [list(map(int, input().split())) for _ in [0]*m]
rest = n # 残りの辺
g = [set() for _ in [0]*n]
[g[a-1].add(b-1) for a, b in ab]
[g[b-1].add(a-1) for a, b in ab]
s = set([i for i in range(n)])
a_list, b_list = [], []
while True:
if m == rest*(rest-1)//2:
break
a = [-1, 10**10]
for i in s:
length = len(g[i])
if length < a[1]:
a = [i, length]
a = a[0]
b = [-1, 10**10]
for i in s-g[a]-{a}:
length = len(g[i])
if length < b[1]:
b = [i, length]
b = b[0]
a_set, b_set = {a}, {b}
s.remove(a)
s.remove(b)
rest -= 2
remain = set() # 最後のグループ
for i in s:
flag_a = True
for j in a_set:
if j not in g[i]:
flag_a = False
else:
g[i].remove(j)
g[j].remove(i)
m -= 1
flag_b = True
for j in b_set:
if j not in g[i]:
flag_b = False
else:
g[i].remove(j)
g[j].remove(i)
m -= 1
if flag_a+flag_b == 0:
print(-1)
return
elif flag_a*flag_b == 0:
q = {i}
flag = flag_a # True→A、False→B
while q:
qq = set()
while q:
i = q.pop()
if flag:
a_set.add(i)
else:
b_set.add(i)
for j in remain:
if j not in g[i]:
qq.add(j)
else:
g[i].remove(j)
g[j].remove(i)
m -= 1
for j in q:
g[i].remove(j)
g[j].remove(i)
m -= 1
for i in qq:
remain.remove(i)
flag ^= True
q = qq
else:
remain.add(i)
for i in (a_set | b_set)-{a}-{b}:
s.remove(i)
rest -= 1
a_list.append(len(a_set))
b_list.append(len(b_set))
k = len(a_list)
dp = [False]*(n+1)
dp[0] = True
for i in range(k):
a, b = a_list[i], b_list[i]
dp2 = [False]*(n+1)
for j in range(n-max(a, b)+1):
dp2[j+a] |= dp[j]
dp2[j+b] |= dp[j]
dp = dp2
ans = 10**10
for j in range(rest+1):
for i in range(n-j+1):
if dp[i]:
p = i+j
q = n-p
ans = min(ans, p*(p-1)//2+q*(q-1)//2)
print(ans)
main()
``` | output | 1 | 101,007 | 1 | 202,015 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21
Submitted Solution:
```
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
n,m = map(int, input().split())
G = [[1]*n for i in range(n)]
for i in range(n):
G[i][i] = 0
for i in range(m):
a,b = map(int, input().split())
a,b = a-1,b-1
G[a][b] = 0
G[b][a] = 0
from collections import deque
used = [0]*n
tmp = []
def bfs(start):
if used[start]:
return True
d = {-1:0, 1:0}
que = deque()
que.append((start, 1))
while que:
cur, flag = que.popleft()
if used[cur] == flag:
continue
elif used[cur]:
return False
used[cur] = flag
d[flag] += 1
for to in range(n):
if G[cur][to] and used[to] == 0:
que.append((to, -flag))
tmp.append(list(d.values()))
return True
if not all(bfs(i) for i in range(n)):
print(-1)
else:
s = set([0])
target = (n+1)//2
for l in tmp:
t = set()
for a in l:
for b in s:
if a+b <= target:
t.add(a+b)
s = t
k = max(s)
l = n-k
ans = k*(k-1)//2 + l*(l-1)//2
print(ans)
``` | instruction | 0 | 101,008 | 1 | 202,016 |
Yes | output | 1 | 101,008 | 1 | 202,017 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21
Submitted Solution:
```
from collections import deque
N, M = map(int, input().split())
G0 = [set([i]) for i in range(N)]
A = set(range(N))
for i in range(M):
a, b = map(int, input().split())
G0[a-1].add(b-1)
G0[b-1].add(a-1)
G = [A - g for g in G0]
b = 1
c = [-1]*N
for i in range(N):
if c[i] != -1:
continue
p = 0; s = 0
que = deque([i])
c[i] = 0
while que:
v = que.popleft()
s += 1
if c[v] == 0:
p += 1
for w in G[v]:
if c[w] == -1:
c[w] = c[v]^1
que.append(w)
elif c[w] == c[v]:
print(-1)
exit(0)
b = (b << p) | (b << (s-p))
ans = 10**18
for i in range(N+1):
if (b >> i) & 1:
ans = min(ans, i*(i-1)//2 + (N-i)*(N-i-1)//2)
print(ans)
``` | instruction | 0 | 101,009 | 1 | 202,018 |
Yes | output | 1 | 101,009 | 1 | 202,019 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21
Submitted Solution:
```
from collections import deque
N, M = map(int, input().split())
adjL = [set(range(N)) for _ in range(N)]
for v in range(N):
adjL[v].remove(v)
for _ in range(M):
A, B = map(int, input().split())
A, B = A-1, B-1
adjL[A].remove(B)
adjL[B].remove(A)
def getSizes(adjList):
def bfs(vSt):
colors[vSt] = 1
nums[1] += 1
Q = deque([vSt])
while Q:
vNow = Q.popleft()
color = colors[vNow]
for v2 in adjList[vNow]:
if colors[v2] == color:
return False
elif colors[v2] == 0:
colors[v2] = -color
nums[-color] += 1
Q.append(v2)
return True
numV = len(adjList)
colors = [0] * numV
anss = []
for vSt in range(numV):
if colors[vSt] != 0: continue
nums = {-1: 0, 1: 0}
if not bfs(vSt):
return []
anss.append((nums[-1], nums[1]))
return anss
sizes = getSizes(adjL)
if not sizes:
print(-1)
else:
bitset = 1<<N
for A, B in sizes:
bitset = (bitset>>A) | (bitset>>B)
minDiff = N
iMinDiff = -1
for i in reversed(range(N+1)):
if bitset & 1:
diff = abs(i-N/2)
if diff < minDiff:
minDiff = diff
iMinDiff = i
bitset >>= 1
print(iMinDiff*(iMinDiff-1)//2 + (N-iMinDiff)*(N-iMinDiff-1)//2)
``` | instruction | 0 | 101,010 | 1 | 202,020 |
Yes | output | 1 | 101,010 | 1 | 202,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21
Submitted Solution:
```
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from operator import mul
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
G = [set(range(n)) for _ in range(n)]
for i in range(n):
G[i].remove(i)
for _ in range(m):
a, b = LI()
G[a - 1].remove(b - 1)
G[b - 1].remove(a - 1)
color = [0] * n
def bipartite_or_not(s):
color[s] = 1
dq = deque([s])
b = 1
w = 0
while dq:
u = dq.popleft()
for v in G[u]:
if color[v] and color[u] != color[v]:
continue
elif color[v] and color[u] == color[v]:
print(-1)
exit()
color[v] = -color[u]
if color[v] == 1:
b += 1
else:
w += 1
dq += [v]
return b, w
bit = 1 << n
for i in range(n):
if color[i]:
continue
x = bipartite_or_not(i)
p, q = x
d = abs(p - q)
bit = bit << d | bit >> d
for j in range(n):
if bit >> (n - j) & 1:
y, z = (n + j) // 2, (n - j) // 2
print(y * (y - 1) // 2 + z * (z - 1) // 2)
break
``` | instruction | 0 | 101,011 | 1 | 202,022 |
Yes | output | 1 | 101,011 | 1 | 202,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21
Submitted Solution:
```
import numpy as np
def ii():
return int(input())
def lii():
return list(map(int, input().split(' ')))
def lvi(N):
l = []
for _ in range(N):
l.append(ii())
return l
def lv(N):
l = []
for _ in range(N):
l.append(input())
return l
# def graph_coloring(G, color):
# N = len(G)
# c = 1
# color[0] = c
# c += 1
# # 彩色
# for ix in range(N):
# if color[ix] == 0:
# color[ix] = c
# c += 1
#
# for n in range(ix, N):
# if G[ix, n] == 1:
# if color[n] == 0:
# color[n] = color[ix] * -1
# # G, color = graph_coloring(G, n, color)
# elif color[ix] == color[n]:
# return G, None # impossible to coloring
# else:
# pass
#
# return G, color
def graph_coloring(G, color):
N = len(G)
def dfs(v, c):
"""
:param v: node
:param c: color (1 or -1)
:return:
"""
color[v] = c
for j in range(N):
if G[v, j] == 1:
if color[j] == c:
# 隣が同じ色
return False
elif color[j] == 0:
# まだ塗ってなければ塗る
if not dfs(j, c * -1):
return False
# 全ての頂点を塗れた
return True
# グラフが連結でない
c = 1
for i in range(N):
if color[i] == 0:
if not dfs(i, c):
return G, None # impossible
c += 1
return G, color
def c2(n):
return n * (n-1) // 2
def partial_sum(integer_list, target_sum, i=0, sum_=0):
if target_sum < sum_:
return False
if i == len(integer_list):
return sum_ == target_sum
if partial_sum(integer_list, target_sum, i + 1, sum_):
return True
if partial_sum(integer_list, target_sum, i + 1, sum_ + integer_list[i]):
return True
return False
def main():
N, M = lii()
G = np.eye(N)
for _ in range(M):
x, y = lii()
G[x-1, y-1] = 1
G[y-1, x-1] = 1
G = 1 - G # 補グラフ
color = np.array([0 for _ in range(N)])
G, color = graph_coloring(G, color=color)
if color is None:
return -1
# print(G, color)
c = 1
base = 0
int_list = []
while True:
p = len(color[color == c])
q = len(color[color == -c])
if p == 0 and q == 0:
break
base += min(p, q)
diff = max(p, q) - min(p, q)
if diff > 0:
int_list.append(diff)
c += 1
# print(base, int_list)
for s in range((N - base) // 2, N - base):
if partial_sum(int_list, target_sum=s):
return c2(base + s) + c2(N - base - s)
# print(color)
#
# p = len(color[color == 1])
# q = len(color[color == -1])
# m = len(color[color == 0])
#
# a = max(p, q)
# b = min(p, q)
# if a - b >= m:
# b += m
# return c2(a) + c2(b)
#
# else:
# m -= (a - b)
# b = a
# if m % 2:
# return c2(a + 1 + m // 2) + c2(b + m // 2)
# else:
# return c2(a + m // 2) + c2(b + m // 2)
if __name__ == '__main__':
print(main())
``` | instruction | 0 | 101,012 | 1 | 202,024 |
No | output | 1 | 101,012 | 1 | 202,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21
Submitted Solution:
```
N,M = map(int,input().split())
bridge = [[True for _ in range(N)] for _ in range(N)]
for i in range(M):
a,b = map(int,input().split())
bridge[a-1][b-1] = False
bridge[b-1][a-1] = False
connect = [[] for _ in range(N)]
for i in range(N):
for j in range(N):
if bridge[i][j] and i!=j:
connect[i].append(j)
flg = False
used = [False for i in range(N)]
seplist = []
for i in range(N):
if not used[i]:
consider = [i]
g = [0 for i in range(N)]
g[i] = 1
while consider != []:
j = consider.pop()
used[j] = True
for k in connect[j]:
if g[k] == 0:
g[k] = -1 if g[j] == 1 else 1
consider.append(k)
elif g[k]*g[j]==1:
flg = True
break
if flg:
break
if flg:
break
else:
seplist.append([g.count(1),g.count(-1)])
if flg:
print(-1)
else:
canmake = set()
for s in seplist:
if canmake == set():
canmake.add(s[0])
canmake.add(s[1])
else:
c = canmake.copy()
for j in c:
canmake.add(s[0]+j)
canmake.add(s[1]+j)
cc = list(canmake)
cc.sort()
for i in cc:
if i<=N//2:
left = i
right = N-left
print(left*(left-1)//2+right*(right-1)//2)
``` | instruction | 0 | 101,013 | 1 | 202,026 |
No | output | 1 | 101,013 | 1 | 202,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21
Submitted Solution:
```
"""
m,k 個に分けた場合 mC2+kC2が答え
分けられるもののうち、差が最小となるようにする。
aとbがつながってない
a = 0とすると b = 1
bとcがつながってない c = 0
ぐる0,ぐる1で分かれる
x,y個に分かれた時、abs(x-y)として差を最小にする。
dpで求めればいいか。
[親、所属(0or1)]でunion-find
"""
import math
import sys
def nCr(n,r):
if n-r < 0:
return 0
return math.factorial(n) // (math.factorial(n-r) * math.factorial(r))
def wantp(n):
wpl = []
while n != p[n]:
wpl.append(n)
n = p[n]
for i in wpl:
p[i] = n
return n
N,M = map(int,input().split())
link = [[False] * N for i in range(N)]
for i in range(M):
A,B = map(int,input().split())
A -= 1
B -= 1
link[A][B] = True
link[B][A] = True
#まず普通にUnion-Findする
p = [i for i in range(N)]
rank = [1] * N
for i in range(N):
for j in range(N):
if not link[i][j]:
ip = wantp(i)
jp = wantp(j)
if ip != jp:
if rank[ip] > rank[jp]:
p[jp] = ip
elif rank[ip] < rank[jp]:
p[ip] = jp
else:
p[ip] = jp
rank[jp] += 1
dic = {} #親がキーで配列内に属す頂点を入れる(これで分類)
for i in range(N):
np = wantp(i)
if np not in dic:
dic[np] = []
dic[np].append(i)
side = [-1] * N #0と1サイドで分ける
for i in dic: #整合性の確認
side[i] = 0
for j in dic[i]:
for k in dic[i]:
if j != k and (not link[j][k]) and side[k] != -1:
if side[j] == -1:
side[j] = side[k] ^ 1
elif side[j] == side[k]:
print (-1)
sys.exit()
dic2 = {} #キーは先頭[0の数-1の数を入れる]
for i in range(N):
np = wantp(i)
if np not in dic2:
dic2[np] = 0
if side[i] == 0:
dic2[np] += 1
else:
dic2[np] -= 1
allnum = [False] * 1401
allnum[0] = [True]
for i in dic2:
dic2[i] = abs(dic2[i])
#dpで中心に一番近い数を求める
for i in dic2:
nn = dic2[i]
nall = [False] * 1401
for j in range(1401):
if allnum[j]:
nall[j + nn] = True
nall[j - nn] = True
allnum = nall.copy()
ret = 0
while True:
if allnum[ret] or allnum[-1 * ret]:
break
ret += 1
a = N
b = 0
while abs(a-b) != ret:
a -= 1
b += 1
ans = 0
print (nCr(a,2) + nCr(b,2))
``` | instruction | 0 | 101,014 | 1 | 202,028 |
No | output | 1 | 101,014 | 1 | 202,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21
Submitted Solution:
```
#クリーク二つで覆えるか
#各州の都市の数で未知の本数は決まるので均等に分ける
#小さいほうのmaxとるかn//2とn+1//2で分けるか
n,m = map(int, input().split( ))
N = [set() for i in range(n)]
for i in range(m):
ai,bi = map(int, input().split( ))
ai-=1;bi-=1
N[ai].add(bi)
N[bi].add(ai)
#0の属するqulique
q0 = {v for v in N[0]}
q0.add(0)
q_remove = set()
for v in q0:
for u in q0:
if u!=v and u not in N[v] and v not in q_remove:
q_remove.add(v)
q_temp2 = {i for i in range(n)}^q_remove
q0 &= q_temp2
v = -1
for u in range(n):
if u not in q0:
v = u
break
if v ==-1 and len(q0)<n:
print(-1)
exit()
q1 = {u for u in N[v]}
q1.add(v)
q_temp = set()
for v in q1:
for u in q1:
if u!= v and u not in N[v] and u not in q_temp:
q_temp.add(v)
q_temp2 = {i for i in range(n)}^q_temp
q1 &=q_temp2
Used = [1 if (u in q0 or u in q1) else 0 for u in range(n)]
for i in range(n):
if not Used[i]:
if len(q0)<n-1 and len(q1)<n-1:
print(-1)
exit()
mn = min(len(q0),len(q1))
if mn<n//2:
print(mn*(mn-1)//2+(n-mn)*(n-mn-1)//2)
else:
m=n//2
print(m*(m-1)//2+(n-m)*(n-m-1)//2)
``` | instruction | 0 | 101,015 | 1 | 202,030 |
No | output | 1 | 101,015 | 1 | 202,031 |
Provide a correct Python 3 solution for this coding contest problem.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0 | instruction | 0 | 101,016 | 1 | 202,032 |
"Correct Solution:
```
N = int(input())
CSF = [list(map(int, input().split())) for _ in range(N - 1)]
def ceil(x, y):
return (x -1) // y + 1
for i in range(N - 1):
n = 0
for j in range(i, N - 1):
c, s, f = CSF[j]
if n <= s:
n = s
n = s + ceil(n - s, f) * f + c
print(n)
print(0)
``` | output | 1 | 101,016 | 1 | 202,033 |
Provide a correct Python 3 solution for this coding contest problem.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0 | instruction | 0 | 101,017 | 1 | 202,034 |
"Correct Solution:
```
def f():
n=int(input())
l=[list(map(int,input().split())) for i in range(n-1)]+[[0,0,1]]
for i in range(n):
now=0
for a,s,d in l[i:]:
now=a+s-(-max(0,now-s)//d)*d
print(now)
if __name__=="__main__":
f()
``` | output | 1 | 101,017 | 1 | 202,035 |
Provide a correct Python 3 solution for this coding contest problem.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0 | instruction | 0 | 101,018 | 1 | 202,036 |
"Correct Solution:
```
N = int(input())
csf = [list(map(int, input().split())) for _ in range(N-1)]
for i in range(N-1):
time = 0
for c, s, f in csf[i:]:
if time <= s:
time = s + c
else:
if time % f == 0:
time += c
else:
time += c + f - time % f
print(time)
print(0)
``` | output | 1 | 101,018 | 1 | 202,037 |
Provide a correct Python 3 solution for this coding contest problem.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0 | instruction | 0 | 101,019 | 1 | 202,038 |
"Correct Solution:
```
n = int(input())
ans = [0] * n
for i in range(1, n):
c, s, f = list(map(int, input().split()))
for j in range(i):
ans[j] = max(ans[j], s)
ans[j] = ((ans[j]+f-1)//f) * f
ans[j] += c
for a in ans:
print(a)
``` | output | 1 | 101,019 | 1 | 202,039 |
Provide a correct Python 3 solution for this coding contest problem.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0 | instruction | 0 | 101,020 | 1 | 202,040 |
"Correct Solution:
```
n = int(input())
csf=[]
for _ in range(n-1):
c,s,f=map(int,input().split())
csf.append((c,s,f))
ans=[0]*n
for i,(c,s,f) in enumerate(csf):
for j in range(0,i+1):
if ans[j]<=s:
ans[j]=s+c
else:
ans[j]=(ans[j]+f-1)//f*f+c
for x in ans:
print(x)
``` | output | 1 | 101,020 | 1 | 202,041 |
Provide a correct Python 3 solution for this coding contest problem.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0 | instruction | 0 | 101,021 | 1 | 202,042 |
"Correct Solution:
```
N = int(input())
CSF = [list(map(int, input().split())) for _ in range(N-1)]
for i in range(N):
ans = 0
for j in range(i, N-1):
if ans >= CSF[j][1]:
ans = -(-ans//CSF[j][2]*CSF[j][2]) + CSF[j][0]
else:
ans = CSF[j][1] + CSF[j][0]
print(ans)
``` | output | 1 | 101,021 | 1 | 202,043 |
Provide a correct Python 3 solution for this coding contest problem.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0 | instruction | 0 | 101,022 | 1 | 202,044 |
"Correct Solution:
```
N=int(input())
csf=[list(map(int,input().split()))for _ in range(N-1)]
i=0
while i<N:
ans=0
j=i
while j<N-1:
c,s,f=list(csf[j])
ans=max(ans,s)
if ans%f:
ans+=f-ans%f
ans+=c
j+=1
print(ans)
i+=1
``` | output | 1 | 101,022 | 1 | 202,045 |
Provide a correct Python 3 solution for this coding contest problem.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0 | instruction | 0 | 101,023 | 1 | 202,046 |
"Correct Solution:
```
N = int(input())
ans = [0 for i in range(N)]
import math
for i in range(N-1):
c, s, f = map(int, input().split())
for j in range(i+1):
if ans[j]>=s:
x = math.ceil((ans[j]-s)/f)
ans[j] = s+f*x+c
else:
ans[j] = s+c
for i in range(N):
print(ans[i])
``` | output | 1 | 101,023 | 1 | 202,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0
Submitted Solution:
```
import sys
input = sys.stdin.readline
def f():
n=int(input())
l=tuple(tuple(map(int,input().split())) for i in range(n-1))
for i in range(n):
now=0
for a,s,d in l[i:]:
now=a+s-(-max(0,now-s)//d)*d
print(now)
if __name__=="__main__":
f()
``` | instruction | 0 | 101,024 | 1 | 202,048 |
Yes | output | 1 | 101,024 | 1 | 202,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0
Submitted Solution:
```
N = int(input())
CSF = [list(map(int,input().split())) for i in range(N-1)]
ans = []
for i in range(N-1):
res = 0
for c,s,f in CSF[i:]:
if res < s:
res = s
if res % f != 0:
res += f - res % f
res += c
ans.append(res)
ans.append(0)
for a in ans:
print(a)
``` | instruction | 0 | 101,025 | 1 | 202,050 |
Yes | output | 1 | 101,025 | 1 | 202,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0
Submitted Solution:
```
N = int(input())
csf = [[int(x) for x in input().split()] for _ in range(N - 1)]
from math import ceil
def f(t, i):
for j in range(i, N - 1):
c, s, f = csf[j]
d, m = divmod(t, f)
t = max(s, ceil(t / f) * f) + c
return t
for i in range(N):
print(f(0, i))
``` | instruction | 0 | 101,026 | 1 | 202,052 |
Yes | output | 1 | 101,026 | 1 | 202,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0
Submitted Solution:
```
N=int(input())
TTBL=[list(map(int,input().split())) for i in range(N-1)]
def GT(k,t):
c,s,f=TTBL[k][0],TTBL[k][1],TTBL[k][2]
return s+max(0,t-s+(f-1))//f*f+c
for i in range(N-1):
ret = 0
for j in range(i,N-1):
ret=GT(j,ret)
print(ret)
print(0)
``` | instruction | 0 | 101,027 | 1 | 202,054 |
Yes | output | 1 | 101,027 | 1 | 202,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0
Submitted Solution:
```
N = int(input())
C = [0]*(N-1)
S = [0]*(N-1)
F = [0]*(N-1)
T = [0]*N
for i in range(N-1):
C[i], S[i], F[i] = map(int, input().split())
for j in range(N-1):
T[j] = C[j] + S[j]
for i in range(j, N-1):
if T[j] >= S[i+1] or S[i+1] == 0:
T[j] = T[j] + C[i+1]
elif T[j] < S[i+1]:
T[j] = S[i+1]
T[N-1] = 0
for i in range(N):
print(T[i])
``` | instruction | 0 | 101,028 | 1 | 202,056 |
No | output | 1 | 101,028 | 1 | 202,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0
Submitted Solution:
```
# ABC084C - Special Trains
import sys
input = sys.stdin.readline
def main():
n = int(input())
arr = tuple(tuple(map(int, input().split())) for _ in range(n - 1))
for i in range(n - 1):
cur = 0
for j in range(i, n - 1):
m, f, s = arr[j] # move, first train, space (interval)
if cur <= f:
cur = f + m
elif cur % s == 0:
cur += m
else:
cur = cur + (cur % f) + m
print(cur)
print(0)
if __name__ == "__main__":
main()
``` | instruction | 0 | 101,029 | 1 | 202,058 |
No | output | 1 | 101,029 | 1 | 202,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0
Submitted Solution:
```
#-*-coding:utf-8-*-
def main():
n = int(input())
station_list = list(tuple(map(int, input().split())) for _ in range(n-1))
for i in range(n-1):
ans = 0
for j in range(i, n-1):
c, s, f = station_list[j]
if ans <= s:
ans = s
else:
if ans % f != 0:
ans += f - (ans % s)
ans += c
print(ans)
print(0)
if __name__ == '__main__':
main()
``` | instruction | 0 | 101,030 | 1 | 202,060 |
No | output | 1 | 101,030 | 1 | 202,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0
Submitted Solution:
```
n = int(input())
x = [[int(i) for i in input().split()] for i in range(n-1)]
for j in range(n-1):
answer = x[j][0]+x[j][1]
for k in range(j+1,n-1):
num = x[k][1]
while num<answer: num+=x[k][2]
answer = num+x[k][0]
print(answer)
print(0)
``` | instruction | 0 | 101,031 | 1 | 202,062 |
No | output | 1 | 101,031 | 1 | 202,063 |
Provide a correct Python 3 solution for this coding contest problem.
Railroad Trip
There are N cities in the JOI country, numbered 1, 2, ..., and N, respectively. In addition, there are N − 1 railroads, which are numbered 1, 2, ..., and N − 1, respectively. The railroad i (1 ≤ i ≤ N − 1) connects the city i and the city i + 1 in both directions.
There are two ways to get on the JOI railway, one is to use a paper ticket and the other is to use an IC card.
* The fare for boarding the railway i with a paper ticket is Ai yen.
* The fare for boarding the railway i with an IC card is Bi Yen. However, in order to board the railway i with an IC card, it is necessary to purchase an IC card that can be used with the railway i in advance. It costs Ci yen to purchase an IC card that can be used on the railway i. Once purchased, the IC card can be used any number of times.
Since the IC card makes it easier to process the amount, the fare for boarding with an IC card is cheaper than the fare for boarding with a paper ticket. That is, for i = 1, 2, ..., N − 1, Ai> Bi holds. Since the specifications of IC cards are all different for each railroad, the IC card that can be used on railroad i cannot be used on other railroads for any i.
You decide to travel all over the JOI country. We plan to start from the city P1 and visit the cities in the order of P2, P3, ..., PM. The trip consists of an M-1 day journey. On day j (1 ≤ j ≤ M − 1), travel by rail from city Pj to city Pj + 1. At this time, it may move by connecting several railroads. You may also visit the same city more than once. The railroads in JOI are so fast that you can travel from any city to any city in a day.
You currently do not have an IC card for any railroad. You want to purchase some railroad IC cards in advance and minimize the cost of this trip, that is, the sum of the IC card purchase cost and the railroad fare you boarded.
Task
Given the number of cities in the JOI country, the itinerary of the trip, and the fare and IC card price for each railroad in the JOI country. At this time, create a program to find the minimum amount of money required for the trip.
input
Read the following data from standard input.
* On the first line, integers N and M are written with blanks as delimiters. Each of these represents that there are N cities in the JOI country and the trip consists of an M-1 day journey.
* On the second line, M integers P1, P2, ..., PM are written with a space as a delimiter. These represent the rail movement from city Pj to city Pj + 1 on day j (1 ≤ j ≤ M − 1).
* On the i-th line (1 ≤ i ≤ N − 1) of the following N − 1 lines, three integers Ai, Bi, and Ci are written separated by blanks. These indicate that the fare when boarding the railway i with a paper ticket is Ai yen, the fare when boarding with an IC card is Bi yen, and the amount of the IC card that can be used on the railway i is Ci yen.
output
On the standard output, output an integer that represents the minimum value of the travel amount in yen on one line.
Limits
All input data satisfy the following conditions.
* 2 ≤ N ≤ 100 000.
* 2 ≤ M ≤ 100 000.
* 1 ≤ Bi <Ai ≤ 100 000 (1 ≤ i ≤ N − 1).
* 1 ≤ Ci ≤ 100 000 (1 ≤ i ≤ N − 1).
* 1 ≤ Pj ≤ N (1 ≤ j ≤ M).
* Pj ≠ Pj + 1 (1 ≤ j ≤ M − 1).
Input / output example
Input example 1
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output example 1
550
In this case, the method to minimize the cost of travel is as follows.
* Purchase IC cards for Railroad 2 and Railroad 3. This costs 80 + 130 = 210 yen.
* On the first day, move from city 1 to city 2 using a paper ticket, and then move from city 2 to city 3 using an IC card. This costs 120 + 50 = 170 yen.
* On the second day, move from city 3 to city 2 using an IC card. This costs 50 yen.
* On the third day, move from city 2 to city 3 using an IC card, and then move from city 3 to city 4 using an IC card. This costs 50 + 70 = 120 yen.
When moving in this way, the total amount of money spent on the trip is 210 + 170 + 50 + 120 = 550 yen. Since this is the minimum, it outputs 550.
Input example 2
8 5
7 5 3 5 4
12 5 8
16 2 1
3 1 5
17 12 17
19 7 5
12 2 19
4 1 3
Output example 2
81
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output
550 | instruction | 0 | 101,122 | 1 | 202,244 |
"Correct Solution:
```
N,M = map(int,input().split())
P = list(map(int,input().split()))
cs = [0] * N
prices = []
# paper,ic,事前購入
for _ in range(N-1):
prices.append(list(map(int,input().split())))
for i in range(M-1):
cur = P[i]
nxt = P[i+1]
cs[min(nxt-1, cur-1)] += 1
cs[max(nxt-1, cur-1)] -= 1
for i in range(N-1):
cs[i+1] += cs[i]
res = 0
for i in range(N-1):
times = cs[i]
a,b,c = prices[i]
res += min(a*times, b*times+c)
print(res)
``` | output | 1 | 101,122 | 1 | 202,245 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.