text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke built an online judge to hold a programming contest.
When a program is submitted to the judge, the judge returns a verdict, which is a two-character string that appears in the string S as a contiguous substring. (The judge can return any two-character substring of S.)
Determine whether the judge can return the string `AC` as the verdict to a program.
Constraints
* 2 \leq |S| \leq 5
* S consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
If the judge can return the string `AC` as a verdict to a program, print `Yes`; if it cannot, print `No`.
Examples
Input
BACD
Output
Yes
Input
ABCD
Output
No
Input
CABD
Output
No
Input
ACACA
Output
Yes
Input
XX
Output
No
Submitted Solution:
```
import bisect
import os
from collections import Counter, deque
from fractions import gcd
from functools import lru_cache
from functools import reduce
import functools
import heapq
import itertools
import math
import numpy as np
import re
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
S = sys.stdin.readline().rstrip()
if re.match('.*A.*C.*',S):
print('Yes')
else:
print('No')
```
No
| 11,500 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke built an online judge to hold a programming contest.
When a program is submitted to the judge, the judge returns a verdict, which is a two-character string that appears in the string S as a contiguous substring. (The judge can return any two-character substring of S.)
Determine whether the judge can return the string `AC` as the verdict to a program.
Constraints
* 2 \leq |S| \leq 5
* S consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
If the judge can return the string `AC` as a verdict to a program, print `Yes`; if it cannot, print `No`.
Examples
Input
BACD
Output
Yes
Input
ABCD
Output
No
Input
CABD
Output
No
Input
ACACA
Output
Yes
Input
XX
Output
No
Submitted Solution:
```
data = input()
tmp = data.replace("x", "")
c1 , c2, num = 0, -1, 0
if tmp == tmp[::-1]:
while(c1 < len(data) + c2):
if data[c1] == data[c2]:
c1+=1
c2-=1
elif data[c2]=="x":
c2-=1
num+=1
else:
c1+=1
num+=1
else:
num = -1
print(num)
```
No
| 11,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke built an online judge to hold a programming contest.
When a program is submitted to the judge, the judge returns a verdict, which is a two-character string that appears in the string S as a contiguous substring. (The judge can return any two-character substring of S.)
Determine whether the judge can return the string `AC` as the verdict to a program.
Constraints
* 2 \leq |S| \leq 5
* S consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
If the judge can return the string `AC` as a verdict to a program, print `Yes`; if it cannot, print `No`.
Examples
Input
BACD
Output
Yes
Input
ABCD
Output
No
Input
CABD
Output
No
Input
ACACA
Output
Yes
Input
XX
Output
No
Submitted Solution:
```
s = input()
i = 0
j = len(s)-1
ist = 0
while i < j:
if s[i] == s[j]:
i += 1
j -= 1
elif s[i] == 'x':
ist += 1
i += 1
elif s[j] == 'x':
ist += 1
j -= 1
else:
print(-1)
exit()
print(ist)
```
No
| 11,502 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke built an online judge to hold a programming contest.
When a program is submitted to the judge, the judge returns a verdict, which is a two-character string that appears in the string S as a contiguous substring. (The judge can return any two-character substring of S.)
Determine whether the judge can return the string `AC` as the verdict to a program.
Constraints
* 2 \leq |S| \leq 5
* S consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
If the judge can return the string `AC` as a verdict to a program, print `Yes`; if it cannot, print `No`.
Examples
Input
BACD
Output
Yes
Input
ABCD
Output
No
Input
CABD
Output
No
Input
ACACA
Output
Yes
Input
XX
Output
No
Submitted Solution:
```
s = int(input())
l = []
for i in range(len(s)-1):
l.append(s[i:i+2])
print("Yes" if "AC" in l else "No")
```
No
| 11,503 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
"Correct Solution:
```
n, m = map(int, input().split())
edges = [None] * m
for i in range(m):
a, b, c = map(int, input().split())
edges[i] = (a-1, b-1, -c)
INF = float("inf")
d = [INF] * n
d[0] = 0
for i in range(n-1):
for f, t, c in edges:
if d[f] == INF: continue
d[t] = min(d[t], d[f] + c)
inf_flag = [False] * n
for i in range(n):
for f, t, c in edges:
if d[f] == INF: continue
if inf_flag[f] == True:
inf_flag[t] = True
if d[t] > d[f] + c:
d[t] = d[f] + c
inf_flag[t] = True
print("inf" if inf_flag[n-1] else -d[n-1])
```
| 11,504 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
"Correct Solution:
```
N, M = map(int, input().split())
edge = []
for i in range(M):
a, b, c = map(int, input().split())
edge.append([a, b, c*-1])
d = [float('inf')] * (N+1)
d[1] = 0
for i in range(1, N+1):
for e in edge:
if (d[e[0]] != float('inf')) & (d[e[1]] > d[e[0]] + e[2]):
d[e[1]] = d[e[0]] + e[2]
update = True
if (i == N) & (e[1] == N):
print('inf')
exit()
print(d[N]*-1)
```
| 11,505 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
"Correct Solution:
```
n, m = map(int, input().split())
edges = []
for _ in range(m):
a, b, c = map(int, input().split())
edges.append((a-1, b-1, -c))
def shortest_path(v, s, edges, inf):
d = [inf] * v
d[s] = 0
for i in range(2 * n):
update = False
for frm, to, cost in edges:
if d[frm] != inf and d[to] > d[frm] + cost:
d[to] = d[frm] + cost
update = True
if i == n:
memo = d[-1]
if memo != d[-1]:
print('inf')
exit()
return d[-1]
inf = 1e30
print(-shortest_path(n, 0, edges, inf))
```
| 11,506 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
"Correct Solution:
```
n,m=map(int,input().split())
abc=[tuple(map(int,input().split())) for _ in range(m)]
Inf=float('inf')
dist=[Inf]*n
dist[0]=0
for i in range(n):
for a,b,c in abc:
a,b,c=a-1,b-1,-c
if dist[b] >dist[a]+c:
dist[b]=dist[a]+c
if i==n-1 and b==n-1:
print('inf')
exit()
print(-dist[-1])
```
| 11,507 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
"Correct Solution:
```
# ABC061 D - Score Attack
import sys
N, M = map(int, input().split())
edge = [list(map(int, input().split())) for _ in range(M)]
INF = 1 << 60
cost = [- INF] * (N + 1)
cost[1] = 0
for i in range(N):
for n, nn, c in edge:
if cost[nn] < cost[n] + c:
# ベルマンフォード法の性質より、N回目に更新があるならinf
if i == N - 1 and nn == N:
print("inf")
sys.exit()
cost[nn] = cost[n] + c
print(cost[N])
```
| 11,508 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
"Correct Solution:
```
(n,m),*l=[list(map(int,s.split()))for s in open(0)];d=[0]*2+[9e99]*n
for i in range(n*2):
for a,b,c in l:
if d[b]>d[a]-c:d[b]=[d[a]-c,-9e99][i>n]
if i==n:x=d[n]
print([-x,'inf'][d[n]!=x])
```
| 11,509 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
"Correct Solution:
```
n,m = map(int , input().split())
e = []
for i in range(m):
a,b,c = map(int , input().split())
e.append((a-1,b-1,c))
maxdis = [-float('inf') for i in range(n)]
maxdis[0] = 0
mugen = False
for i in range(2*n):
for j in e:
st,gl,cost = j
if (maxdis[gl] < maxdis[st]+cost):
maxdis[gl] = maxdis[st]+cost
if (i >= n-1 and (gl == n-1)):
mugen = True
break
if mugen:
print("inf")
else:
print(maxdis[n-1])
```
| 11,510 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
"Correct Solution:
```
def shortest_path(edge,num_v,start):
inf = float("inf")
d = [-inf for f in range(num_v)]
d[start] = 0;
for i in range(3000):
update = False
for e in edge:
if (d[e[0]-1] != -inf and d[e[1]-1] < d[e[0]-1] + e[2]):
d[e[1]-1] = d[e[0]-1] + e[2]
update = True
if (e[1] == n and i >= n):
return "inf"
if not update:
break
return d[-1]
n,m = map(int,input().split())
p = []
for i in range(m):
p.append(list(map(int, input().split())))
ans = shortest_path(p,n,0)
print(ans)
```
| 11,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
def main():
INF = float("inf")
N, M, *ABC = map(int, open(0).read().split())
D = [0] + [INF] * (N - 1)
E = tuple((a - 1, b - 1, -c) for a, b, c in zip(*[iter(ABC)] * 3))
for a, b, c in E:
D[b] = min(D[b], D[a] + c)
ans = D[-1]
for a, b, c in E:
D[b] = min(D[b], D[a] + c)
print("inf" if ans != D[-1] else -ans)
main()
```
Yes
| 11,512 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
N, M = map(int, input().split())
edges = []
for i in range(M):
a, b, c = map(int, input().split())
edges.append((a, b, c))
edges.sort()
def bellmanford(n, edges, start):
INF = float('inf')
dist = [-INF] * (n+1) # dist[0]は使わない
dist[start] = 0
for i in range(n):
for (pre, ne, weight) in edges:
if dist[pre] != -INF and dist[pre] + weight > dist[ne]:
dist[ne] = dist[pre] + weight
if i == n-1 and ne == n:
return 'inf'
return dist[n]
answer = bellmanford(N, edges, 1)
print(answer)
```
Yes
| 11,513 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
def bellmanford(s, n, es):
# 負の経路の検出
# n:頂点数, w:辺の数, es[i]: [辺の始点,辺の終点,辺のコスト]
d = [float("inf")] * n
neg = [False]*n
d[s] = 0
for i in range(n):
for p, q, r in es:
if d[p] != float("inf") and d[q] > d[p] + r:
d[q] = d[p] + r
if i == n-1:
neg[q] = True
return d, neg
n, w = map(int, input().split()) # n:頂点数 w:辺の数
es = []
for _ in range(w):
x, y, z = map(int, input().split())
es.append([x-1, y-1, -z])
d, neg = bellmanford(0, n, es)
if neg[-1]:
print("inf")
else:
print(-d[-1])
```
Yes
| 11,514 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
import sys
INF = float("inf")
def Bellmanford(n, edges, r): # rは始点
d = [INF] * n
d[r] = 0
for i in range(n):
for (u, v, c) in edges:
if d[u] != INF and d[u] + c < d[v]:
d[v] = d[u] + c
if i == n - 1 and v == n - 1:
return "inf"
return -d[n-1]
N, M = map(int, sys.stdin.readline().split())
Edges = [None] * M
for i in range(M):
ai, bi, ci = map(int, sys.stdin.readline().split())
Edges[i] = (ai - 1, bi - 1, -ci)
ans = Bellmanford(N, Edges, 0)
print(ans)
```
Yes
| 11,515 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
from collections import defaultdict
N, M, *L = map(int, open(0).read().split())
dic = defaultdict(list)
rdic = defaultdict(list)
nin = [0]*N
Els = []
for a,b,c in zip(*[iter(L)]*3):
dic[a-1] += [b-1]
rdic[b-1] += [a-1]
nin[b-1] += 1
Els += [(a-1,b-1,-c)]
To = [False]*N
From = [False]*N
q = [0]
To[0] = True
while q:
p = q.pop()
for e in dic[p]:
if To[e]==False:
To[e] = True
q += [e]
q = [N-1]
From[N-1] = True
while q:
p = q.pop()
for e in rdic[p]:
if From[e]==False:
From[e] = True
q += [e]
ok = [False]*N
for i in range(N):
ok[i] = To[i]&From[i]
cnt = 0
dist = [float('inf')]*N
dist[0] = 0
cnt = 0
flag = False
while True:
update = True
for a,b,c in Els:
if dist[a]!=float('inf') and dist[b]>dist[a]+c:
dist[b] = dist[a]+c
update = False
if update:
break
cnt += 1
if cnt>2*M:
flag = True
break
if flag:
print('inf')
else:
print(-dist[N-1])
```
No
| 11,516 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
N, M = map(int, input().split())
G = [[] for i in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
G[a - 1].append((b - 1, -c))
INF = float("inf")
d = [INF] * N
d[0] = 0
for i in range(N):
for b, c in G[i]:
if d[b] > d[i] + c:
d[b] = d[i] + c
mi = [False] * N
for i in range(N):
for b, c in G[i]:
if d[b] > d[i] + c:
mi[b] = True
if mi[N - 1]:
print("inf")
else:
print(-d[N - 1])
```
No
| 11,517 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
V, E = map(int, input().split())
G = [[] for i in range(V+1)]
for i in range(E):
a, b, c = map(int, input().split())
G[a-1].append((b-1, 0-c))
G[V-1].append((V, 0))
INF = float('inf')
dist = [INF] * (V + 1)
dist[0] = 0
Flag = False
for i in range(V+1):
UnUpdate = True
for v, e in enumerate(G):
for t, cost in e:
if dist[v] != INF and dist[v] + cost < dist[t]:
dist[t] = dist[v] + cost
UnUpdate = False
if UnUpdate and i < V:
Flag = True
break
if Flag:
print(0-dist[V])
else:
print(1/0)
```
No
| 11,518 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
n, m = map(int, input().split())
abc = [list(map(int, input().split())) for _ in range(m)]
cost = [[0] * n for _ in range(n)]
for a, b, c in abc:
cost[a-1][b-1] = -c
from scipy.sparse.csgraph import floyd_warshall
try:
dist = floyd_warshall(cost)
print(-1 * int(dist[0][n-1]))
except:
print('inf')
```
No
| 11,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke received N intervals as a birthday present. The i-th interval was [-L_i, R_i]. It is guaranteed that both L_i and R_i are positive. In other words, the origin is strictly inside each interval.
Snuke doesn't like overlapping intervals, so he decided to move some intervals. For any positive integer d, if he pays d dollars, he can choose one of the intervals and move it by the distance of d. That is, if the chosen segment is [a, b], he can change it to either [a+d, b+d] or [a-d, b-d].
He can repeat this type of operation arbitrary number of times. After the operations, the intervals must be pairwise disjoint (however, they may touch at a point). Formally, for any two intervals, the length of the intersection must be zero.
Compute the minimum cost required to achieve his goal.
Constraints
* 1 ≤ N ≤ 5000
* 1 ≤ L_i, R_i ≤ 10^9
* All values in the input are integers.
Input
The input is given from Standard Input in the following format:
N
L_1 R_1
:
L_N R_N
Output
Print the minimum cost required to achieve his goal.
Examples
Input
4
2 7
2 5
4 1
7 5
Output
22
Input
20
97 2
75 25
82 84
17 56
32 2
28 37
57 39
18 11
79 6
40 68
68 16
40 63
93 49
91 10
55 68
31 80
57 18
34 28
76 55
21 80
Output
7337
Submitted Solution:
```
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
import numpy as np
N = int(readline())
LR = [tuple(int(x) for x in line.split()) for line in readlines()]
"""
・奇数個のとき：中央にどれかを固定。
・偶数のとき：原点で左右に分けるとしてよい。
・基本的に長さで内側から昇順（奇数のときの中央は謎）。→ソートしてdpできる。
・左に置いた個数をもってdp更新。また、中央を使ったかも同時に持って。
・偶数のときは、中央に1つ置いた状態から始める。
・大きい区間から外側に入れていく。
"""
LR.sort(key = lambda x: -x[1]-x[0])
INF = 10**15
dp_0 = np.full(N+1,INF,np.int64) # 左に置いた個数 → コスト。中央未確定。
dp_1 = np.full(N+1,INF,np.int64) # 左に置いた個数 → コスト。中央確定。
if N&1:
dp_0[0] = 0
else:
dp_1[0] = 0
for n,(L,R) in enumerate(LR):
length = R + L
prev_0 = dp_0
prev_1 = dp_1
dp_0 = np.full(N+1,INF,np.int64)
dp_1 = np.full(N+1,INF,np.int64)
x = np.arange(n+1,dtype=np.int64) # もともと左側にあった個数
# 左側に置く場合
np.minimum(prev_0[:n+1] + R + x * length, dp_0[1:n+2], out=dp_0[1:n+2])
np.minimum(prev_1[:n+1] + R + x * length, dp_1[1:n+2], out=dp_1[1:n+2])
# 右側に置く場合
np.minimum(prev_0[:n+1] + L + (n-x) * length, dp_0[:n+1], out=dp_0[:n+1])
np.minimum(prev_1[:n+1] + L + (n-x) * length, dp_1[:n+1], out=dp_1[:n+1])
# 中央に置く場合
np.minimum(prev_0[:n+1] + (N-1)//2 * length, dp_1[:n+1], out = dp_1[:n+1])
answer = dp_1[N//2]
print(answer)
```
No
| 11,520 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke received N intervals as a birthday present. The i-th interval was [-L_i, R_i]. It is guaranteed that both L_i and R_i are positive. In other words, the origin is strictly inside each interval.
Snuke doesn't like overlapping intervals, so he decided to move some intervals. For any positive integer d, if he pays d dollars, he can choose one of the intervals and move it by the distance of d. That is, if the chosen segment is [a, b], he can change it to either [a+d, b+d] or [a-d, b-d].
He can repeat this type of operation arbitrary number of times. After the operations, the intervals must be pairwise disjoint (however, they may touch at a point). Formally, for any two intervals, the length of the intersection must be zero.
Compute the minimum cost required to achieve his goal.
Constraints
* 1 ≤ N ≤ 5000
* 1 ≤ L_i, R_i ≤ 10^9
* All values in the input are integers.
Input
The input is given from Standard Input in the following format:
N
L_1 R_1
:
L_N R_N
Output
Print the minimum cost required to achieve his goal.
Examples
Input
4
2 7
2 5
4 1
7 5
Output
22
Input
20
97 2
75 25
82 84
17 56
32 2
28 37
57 39
18 11
79 6
40 68
68 16
40 63
93 49
91 10
55 68
31 80
57 18
34 28
76 55
21 80
Output
7337
Submitted Solution:
```
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
import numpy as np
N = int(readline())
LR = [tuple(int(x) for x in line.split()) for line in readlines()]
"""
・奇数個のとき：中央にどれかを固定。
・偶数のとき：原点で左右に分けるとしてよい。
・基本的に長さで内側から昇順（奇数のときの中央は謎）。→ソートしてdpできる。
・左に置いた個数をもってdp更新。また、中央を使ったかも同時に持って。
・偶数のときは、中央に1つ置いた状態から始める。
・大きい区間から外側に入れていく。
"""
LR.sort(key = lambda x: -x[1]-x[0])
if N%2 == 1:
raise Exception
INF = 10**15
dp_0 = np.full(N+1,INF,np.int64) # 左に置いた個数 → コスト。中央未確定。
dp_1 = np.full(N+1,INF,np.int64) # 左に置いた個数 → コスト。中央確定。
if N&1:
dp_0[0] = 0
else:
dp_1[0] = 0
for n,(L,R) in enumerate(LR):
length = R + L
prev_0 = dp_0
prev_1 = dp_1
dp_0 = np.full(N+1,INF,np.int64)
dp_1 = np.full(N+1,INF,np.int64)
x = np.arange(n+1,dtype=np.int64) # もともと左側にあった個数
# 左側に置く場合
np.minimum(prev_0[:n+1] + R + x * length, dp_0[1:n+2], out=dp_0[1:n+2])
np.minimum(prev_1[:n+1] + R + x * length, dp_1[1:n+2], out=dp_1[1:n+2])
# 右側に置く場合
np.minimum(prev_0[:n+1] + L + (n-x) * length, dp_0[:n+1], out=dp_0[:n+1])
np.minimum(prev_1[:n+1] + L + (n-x) * length, dp_1[:n+1], out=dp_1[:n+1])
# 中央に置く場合
np.minimum(prev_0[:n+1] + (N-1)//2 * length, dp_1[:n+1], out = dp_1[:n+1])
answer = dp_1[N//2]
print(answer)
```
No
| 11,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke received N intervals as a birthday present. The i-th interval was [-L_i, R_i]. It is guaranteed that both L_i and R_i are positive. In other words, the origin is strictly inside each interval.
Snuke doesn't like overlapping intervals, so he decided to move some intervals. For any positive integer d, if he pays d dollars, he can choose one of the intervals and move it by the distance of d. That is, if the chosen segment is [a, b], he can change it to either [a+d, b+d] or [a-d, b-d].
He can repeat this type of operation arbitrary number of times. After the operations, the intervals must be pairwise disjoint (however, they may touch at a point). Formally, for any two intervals, the length of the intersection must be zero.
Compute the minimum cost required to achieve his goal.
Constraints
* 1 ≤ N ≤ 5000
* 1 ≤ L_i, R_i ≤ 10^9
* All values in the input are integers.
Input
The input is given from Standard Input in the following format:
N
L_1 R_1
:
L_N R_N
Output
Print the minimum cost required to achieve his goal.
Examples
Input
4
2 7
2 5
4 1
7 5
Output
22
Input
20
97 2
75 25
82 84
17 56
32 2
28 37
57 39
18 11
79 6
40 68
68 16
40 63
93 49
91 10
55 68
31 80
57 18
34 28
76 55
21 80
Output
7337
Submitted Solution:
```
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
import numpy as np
N = int(readline())
LR = [tuple(int(x) for x in line.split()) for line in readlines()]
"""
・奇数個のとき：中央にどれかを固定。
・偶数のとき：原点で左右に分けるとしてよい。
・基本的に長さで内側から昇順（奇数のときの中央は謎）。→ソートしてdpできる。
・左に置いた個数をもってdp更新。また、中央を使ったかも同時に持って。
・偶数のときは、中央に1つ置いた状態から始める。
・大きい区間から外側に入れていく。
"""
LR.sort(key = lambda x: -x[1]-x[0])
if N%2 == 1:
raise Exception
INF = 10**18
dp_0 = np.full(N+1,INF,np.int64) # 左に置いた個数 → コスト。中央未確定。
dp_1 = np.full(N+1,INF,np.int64) # 左に置いた個数 → コスト。中央確定。
if N&1:
dp_0[0] = 0
else:
dp_1[0] = 0
for n,(L,R) in enumerate(LR):
length = R + L
prev_0 = dp_0
prev_1 = dp_1
dp_0 = np.full(N+1,INF,np.int64)
dp_1 = np.full(N+1,INF,np.int64)
x = np.arange(n+1,dtype=np.int64) # もともと左側にあった個数
# 左側に置く場合
np.minimum(prev_0[:n+1] + R + x * length, dp_0[1:n+2], out=dp_0[1:n+2])
np.minimum(prev_1[:n+1] + R + x * length, dp_1[1:n+2], out=dp_1[1:n+2])
# 右側に置く場合
np.minimum(prev_0[:n+1] + L + (n-x) * length, dp_0[:n+1], out=dp_0[:n+1])
np.minimum(prev_1[:n+1] + L + (n-x) * length, dp_1[:n+1], out=dp_1[:n+1])
# 中央に置く場合
np.minimum(prev_0[:n+1] + (N-1)//2 * length, dp_1[:n+1], out = dp_1[:n+1])
answer = dp_1[N//2]
print(answer)
```
No
| 11,522 |
Provide a correct Python 3 solution for this coding contest problem.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
"Correct Solution:
```
print(['NO','YES'][sorted(input().split())=='5 5 7'.split()])
```
| 11,523 |
Provide a correct Python 3 solution for this coding contest problem.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
"Correct Solution:
```
str = input().split()
if str.count("7") == 1 :
print("YES")
else:
print("NO")
```
| 11,524 |
Provide a correct Python 3 solution for this coding contest problem.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
"Correct Solution:
```
print('YES' if sum(map(int,input().split()))==17 else 'NO' )
```
| 11,525 |
Provide a correct Python 3 solution for this coding contest problem.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
"Correct Solution:
```
s = sorted([int(x) for x in input().split()])
print("YES" if s==[5,5,7] else "NO")
```
| 11,526 |
Provide a correct Python 3 solution for this coding contest problem.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
"Correct Solution:
```
ar=sorted(list(map(int,input().split())))
print("YES" if ar==[5,5,7] else "NO")
```
| 11,527 |
Provide a correct Python 3 solution for this coding contest problem.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
"Correct Solution:
```
print(' YNEOS'[input().count('7')::2])
```
| 11,528 |
Provide a correct Python 3 solution for this coding contest problem.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
"Correct Solution:
```
a=list(map(int, input().split()))
print('YES' if a.count(7)==1 else 'NO')
```
| 11,529 |
Provide a correct Python 3 solution for this coding contest problem.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
"Correct Solution:
```
a=list(map(int,input().split()))
a.sort()
print("YNEOS"[a!=[5,5,7]::2])
```
| 11,530 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
Submitted Solution:
```
print(['NO','YES'][['5','5','7']==sorted(input()[::2])])
```
Yes
| 11,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
Submitted Solution:
```
A,B,C=map(int,input().split())
print('YES'if A+B+C==17 and A*B*C==175 else "NO")
```
Yes
| 11,532 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
Submitted Solution:
```
n=[int(_) for _ in input().split()]
print('YES' if sorted(n)==[5,5,7] else 'NO')
```
Yes
| 11,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
Submitted Solution:
```
l=input().split()
print('YES' if l.count('5')==2 and l.count('7')==1 else 'NO')
```
Yes
| 11,534 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
Submitted Solution:
```
def Haiku(check,syllables):
check.sort()
syllables.sort()
if check==syllables:
return "YES"
else:
return "NO"
print(Haiku(check,syllables))
```
No
| 11,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
Submitted Solution:
```
A=int(input('A'))
B=int(input('B'))
C=int(input('C'))
if (A==5 and B==5 and C==7) or (A==5 and B==7 and C==5) or (A==7 and B==5 and C==5):
print('yes')
else:
print('no')
```
No
| 11,536 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
Submitted Solution:
```
N = list(map(int, input().split()))
cnt_5 = 0
cnt_7 = 0
for n in N:
if n == 5 :
cnt_5 += 1
elif n == 7 :
cnt_7 += 1
if cnt_5 == 2 and cnt_7 == 1:
print('YES')
else:
print('N0')
```
No
| 11,537 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iroha loves Haiku. Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
To create a Haiku, Iroha has come up with three different phrases. These phrases have A, B and C syllables, respectively. Determine whether she can construct a Haiku by using each of the phrases once, in some order.
Constraints
* 1≦A,B,C≦10
Input
The input is given from Standard Input in the following format:
A B C
Output
If it is possible to construct a Haiku by using each of the phrases once, print `YES` (case-sensitive). Otherwise, print `NO`.
Examples
Input
5 5 7
Output
YES
Input
7 7 5
Output
NO
Submitted Solution:
```
a = list(map(int, input().split())
if a.count(5) == 2 and a.count(7) == 1:
print("Yes")
else:
print("No")
```
No
| 11,538 |
Provide a correct Python 3 solution for this coding contest problem.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
"Correct Solution:
```
def getScore(d):
return int(d[1]) * 3 + int(d[3])
isFirst = True
while 1:
n = int(input())
if n == 0:
break
if not isFirst:
print()
table = []
for i in range(0,n):
d = list(_ for _ in input().split())
score = getScore(d)
table.append((d[0],score))
table.sort(key=lambda i:i[1],reverse=True)
for n,s in table:
print(str(n) + ',' + str(s))
isFirst = False
```
| 11,539 |
Provide a correct Python 3 solution for this coding contest problem.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
"Correct Solution:
```
f = True
while True:
n = int(input())
if n == 0:
break
T = []
for i in range(n):
name,w,l,d = list(input().split())
T.append((name,i,int(w)*3+int(d)))
if f: f = False
else: print()
for i in sorted(T, key = lambda x:(-x[2],x[1])):
print(i[0],",",i[2],sep="")
```
| 11,540 |
Provide a correct Python 3 solution for this coding contest problem.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
"Correct Solution:
```
flag = True
while True:
n = int(input())
if n == 0: break
answer = {}
for _ in range(n):
result = input().split()
country = result[0]
win, lose, draw = map(int, result[1:])
score = win * 3 + draw
answer[country] = score
if flag:
flag = False
else:
print()
for c, s in sorted(answer.items(), key=lambda x: -x[1]):
print(c + ',' + str(s))
```
| 11,541 |
Provide a correct Python 3 solution for this coding contest problem.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
"Correct Solution:
```
b=False
while True:
n = int(input())
if n==0:break
d=dict()
if b:print()
b=True
for _ in range(n):
line = input().split()
tmp = int(line[1])*3+int(line[3]*1)
if tmp in d:
d[tmp].append(line[0])
else:
d[tmp] = []
d[tmp].append(line[0])
for k, vs in sorted(d.items(), key=lambda x: x[0])[::-1]:
for v in vs:
print('{0},{1}'.format(v, k))
```
| 11,542 |
Provide a correct Python 3 solution for this coding contest problem.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
"Correct Solution:
```
import bisect
cnt = 0
while 1:
outs = []
outn = []
n = int(input())
if n == 0: break
elif cnt > 0: print()
names = []
scores = []
for i in range(n):
line = list(input().split())
name = line[0]
names.append(name)
w = line[1]
l = line[2]
d = line[3]
score = 3*int(w) + int(d)
tm = bisect.bisect_left(outs, score)
outs.insert(tm, score)
outn.insert(tm, name)
#scores.append(score)
#ind = 1
for i,j in zip(reversed(outn),reversed(outs)):
print(f'{i},{j}')
#if ind != n: print()
#ind += 1
#t = zip(scores, names)
#t = sorted(t,reverse=True)
#names,scores = zip(*t)
#ind = 0
#for i,j in t:
#print(f'{j},{i}',end='')
#if ind != len(t)-1: print()
#ind += 1
cnt += 1
```
| 11,543 |
Provide a correct Python 3 solution for this coding contest problem.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
"Correct Solution:
```
f = True
while True:
n = int(input())
if n == 0: break
tbl = []
for i in range(n):
name, w, l, d = list(input().split())
tbl.append([name, i, 3*int(w)+int(d)])
if f: f = False
else: print()
for i in sorted(tbl, key=lambda x:(-x[2],x[1])): print(i[0], ',', i[2], sep='')
```
| 11,544 |
Provide a correct Python 3 solution for this coding contest problem.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
"Correct Solution:
```
st=True
while True:
n=int(input())
if n==0:
break
if st==False:
print()
team={}
for _ in range(n):
data=input().split(" ")
team[data[0]]=3*int(data[1])+int(data[3])
team=team.items()
team=sorted(team,key=lambda w:w[1],reverse=True)
for t in team:
print("{0},{1}".format(*t))
st=False
```
| 11,545 |
Provide a correct Python 3 solution for this coding contest problem.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0124
"""
import sys
from operator import itemgetter
def solve(data):
result = []
for name, win, lose, draw in data:
score = win * 3 + draw * 1
result.append([name, score])
result.sort(key=itemgetter(1), reverse=True)
return result
def main(args):
first_data_set = True
while True:
n = int(input())
if n == 0:
break
data = []
for _ in range(n):
name, win, lose, draw = input().split()
data.append([name, int(win), int(lose), int(draw)])
result = solve(data)
if first_data_set:
first_data_set = False
else:
print()
for r in result:
print(','.join(map(str, r)))
if __name__ == '__main__':
main(sys.argv[1:])
```
| 11,546 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
Submitted Solution:
```
a = int(input())
while True:
s = []
for i in range(a):
b,c,d,e = input().split()
c = int(c)
e = int(e)
s.append([c*3+e,-(i),b])
s.sort(reverse = True)
for z in s:
print(z[2]+","+str(z[0]))
a = int(input())
if a == 0:
break
else:
print()
```
Yes
| 11,547 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
import math
for i, s in enumerate(sys.stdin):
n = int(s)
if n == 0:
break
elif i != 0:
print()
A = []
for i in range(n):
lst = input().split()
name = lst[0]
w = int(lst[1])
l = int(lst[2])
d = int(lst[3])
score = 3 * w + d
A.append((score, -i, name))
A.sort(reverse=True)
for a in A:
score = a[0]
name = a[2]
print('{},{}'.format(name, score))
```
Yes
| 11,548 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
Submitted Solution:
```
c = 0
while True:
c +=1
L = []
num = int(input())
if num == 0:
break
for i in range(num):
name, w, l, d = input().split()
w = int(w)
d = int(d)
L.append((i,name,w*3+d))
L.sort(key=lambda x: (-x[2],x[0]))
if c > 1:
print()
for l in L:
print("{},{}".format(l[1], l[2]))
```
Yes
| 11,549 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
Submitted Solution:
```
b = False
while True:
n = int(input())
if n == 0:
break
dataset = []
if b:
print()
b = True
for _ in range(n):
name, w, l, d = input().split()
dataset.append((name, 3*int(w) + int(d), n-len(dataset)))
for name, score, _ in sorted(dataset, key=lambda x: (x[1], x[2]))[::-1]:
print(name + "," + str(score))
```
Yes
| 11,550 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
Submitted Solution:
```
def main():
while True:
n = int(input())
if n == 0: break
teams = []
for i in range(n):
row = input().split()
teams.append([row[0], 0])
s_t = 0
for e, p in zip(row[1:], [3, 0, 1]):
s_t += int(e) * p
teams[i][1] = s_t
for t in sorted(teams, key=lambda x: x[1], reverse=True):
print("{},{}".format(t[0], t[1]))
print()
if __name__ == "__main__":
main()
```
No
| 11,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
Submitted Solution:
```
def main():
while True:
n = int(input())
if n == 0: break
teams = []
for i in range(n):
row = input().split()
teams.append([row[0], 0])
s_t = 0
for e, p in zip(row[1:], [3, 0, 1]):
s_t += int(e) * p
teams[i][1] = s_t
for t in sorted(teams, key=lambda x: x[1], reverse=True):
print("{},{}".format(t[0], t[1]))
if __name__ == "__main__":
main()
```
No
| 11,552 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
Submitted Solution:
```
while True:
n = int(input())
if n == 0:
break
dataset = []
for _ in range(n):
name, w, l, d = input().split()
dataset.append((name, 3*int(w) + int(d), n-len(dataset)))
for name, score, _ in sorted(dataset, key=lambda x: (x[1], x[2]))[::-1]:
print(name + "," + str(score))
```
No
| 11,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n ≤ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 ≤ wi, li, di ≤ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
Submitted Solution:
```
b=False
while True:
n = int(input())
if n==0:break
d=dict()
if b:print()
for _ in range(n):
t = input().split()
d[t[0]]=int(t[1])*3+int(t[3])*1
b=True
for s in sorted(d.items(), key=lambda x:x[1])[::-1]:
print('{0},{1}'.format(s[0],s[1]))
print()
```
No
| 11,554 |
Provide a correct Python 3 solution for this coding contest problem.
Taro made a sugoroku so that everyone can play at the children's association event. In order to make the game interesting, I wrote instructions such as "advance 6" and "back 5" in some of the sugoroku squares other than "Furidashi" and "Agari". Turn the roulette wheel to advance as many times as you can, and if an instruction is written on the stopped square, move according to that instruction. However, it does not follow the instructions of the squares that proceeded according to the instructions.
Roulette shall be able to give a number between 1 and a certain number with equal probability. Also, if you get a larger number than you reach "Agari", or if you follow the instructions and you go beyond "Agari", you will move to "Agari". If you follow the instructions and return before "Furidashi", you will return to "Furidashi".
<image>
However, depending on the instructions of the roulette wheel and the square, it may not be possible to reach the "rise". For example, let's say you made a sugoroku like the one shown in the figure. If you use a roulette wheel that only gives 1 and 2, you can go to "Agari" if you come out in the order of 1 and 2, but if you get 2 first, you will not be able to reach "Agari" forever no matter what comes out. Taro didn't know that and wrote instructions in various squares.
Therefore, on behalf of Taro, please create a program to determine whether or not you may not be able to reach the "rise" depending on the instructions of the roulette and the square.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
max
n
d1
d2
..
..
..
dn
The first line gives the maximum number of roulette wheels max (2 ≤ max ≤ 250), and the second line gives the number of cells other than "starting" and "rising" n (2 ≤ n ≤ 250). .. The next n lines are given the number di (-n ≤ di ≤ n) that represents the indication for each cell. When di is zero, it means that no instruction is written, when it is a positive number, it means | di | forward instruction, and when it is negative, it means | di | back instruction (where | x | is x). Represents an absolute value). All values entered are integers.
The number of datasets does not exceed 100.
output
The judgment result is output to one line for each data set. Depending on the instructions of the roulette and the square, if it may not be possible to reach the "go up", "NG" is output, otherwise "OK" is output.
Example
Input
3
3
-2
1
0
2
4
2
0
-1
-2
2
2
-2
-2
0
Output
OK
NG
NG
"Correct Solution:
```
while True:
m = int(input())
if not m:
break
n = int(input())
ds = [0] + [int(input()) for _ in range(n)] + [0]
g = [[] for _ in range(n+2)]
rg = [[] for _ in range(n+2)]
for i in range(n+2):
for j in range(min(n+1,i+1),min(n+1,i+m)+1):
j = max(0,min(n+1,j+ds[j]))
g[i].append(j)
rg[j].append(i)
def go(g,bs,i):
bs[i] = True
for j in g[i]:
if not bs[j]:
go(g,bs,j)
bs = [False]*(n+2)
rbs = [False]*(n+2)
go(g,bs,0)
go(rg,rbs,n+1)
if any((b and (not rb)) for b,rb in zip(bs,rbs)):
print('NG')
else:
print('OK')
```
| 11,555 |
Provide a correct Python 3 solution for this coding contest problem.
Taro made a sugoroku so that everyone can play at the children's association event. In order to make the game interesting, I wrote instructions such as "advance 6" and "back 5" in some of the sugoroku squares other than "Furidashi" and "Agari". Turn the roulette wheel to advance as many times as you can, and if an instruction is written on the stopped square, move according to that instruction. However, it does not follow the instructions of the squares that proceeded according to the instructions.
Roulette shall be able to give a number between 1 and a certain number with equal probability. Also, if you get a larger number than you reach "Agari", or if you follow the instructions and you go beyond "Agari", you will move to "Agari". If you follow the instructions and return before "Furidashi", you will return to "Furidashi".
<image>
However, depending on the instructions of the roulette wheel and the square, it may not be possible to reach the "rise". For example, let's say you made a sugoroku like the one shown in the figure. If you use a roulette wheel that only gives 1 and 2, you can go to "Agari" if you come out in the order of 1 and 2, but if you get 2 first, you will not be able to reach "Agari" forever no matter what comes out. Taro didn't know that and wrote instructions in various squares.
Therefore, on behalf of Taro, please create a program to determine whether or not you may not be able to reach the "rise" depending on the instructions of the roulette and the square.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
max
n
d1
d2
..
..
..
dn
The first line gives the maximum number of roulette wheels max (2 ≤ max ≤ 250), and the second line gives the number of cells other than "starting" and "rising" n (2 ≤ n ≤ 250). .. The next n lines are given the number di (-n ≤ di ≤ n) that represents the indication for each cell. When di is zero, it means that no instruction is written, when it is a positive number, it means | di | forward instruction, and when it is negative, it means | di | back instruction (where | x | is x). Represents an absolute value). All values entered are integers.
The number of datasets does not exceed 100.
output
The judgment result is output to one line for each data set. Depending on the instructions of the roulette and the square, if it may not be possible to reach the "go up", "NG" is output, otherwise "OK" is output.
Example
Input
3
3
-2
1
0
2
4
2
0
-1
-2
2
2
-2
-2
0
Output
OK
NG
NG
"Correct Solution:
```
import queue
while True:
m = int(input())
if m == 0:
break
n = int(input())
d = [0]*(n+2)
for i in range(1,n+1):
d[i] = int(input())
visited = [False]*(n+2)
visited[0] = True
ok = [False]*(n+2)
ok[n+1] = True
rev = [[] for _ in range(n+2)]
que = queue.LifoQueue()
que.put(0)
while not que.empty():
i = que.get()
for j in range(1,m+1):
if i+j > n+1:
break
k = min(max(i+j+d[i+j], 0), n+1)
rev[k].append(i)
if not visited[k]:
que.put(k)
visited[k] = True
que.put(n+1)
while not que.empty():
i = que.get()
for j in rev[i]:
if not ok[j]:
ok[j] = True
que.put(j)
ans = 'OK'
if not visited[n+1]:
ans = 'NG'
for i in range(n+1):
if visited[i] and (not ok[i]):
ans = 'NG'
print(ans)
```
| 11,556 |
Provide a correct Python 3 solution for this coding contest problem.
Taro made a sugoroku so that everyone can play at the children's association event. In order to make the game interesting, I wrote instructions such as "advance 6" and "back 5" in some of the sugoroku squares other than "Furidashi" and "Agari". Turn the roulette wheel to advance as many times as you can, and if an instruction is written on the stopped square, move according to that instruction. However, it does not follow the instructions of the squares that proceeded according to the instructions.
Roulette shall be able to give a number between 1 and a certain number with equal probability. Also, if you get a larger number than you reach "Agari", or if you follow the instructions and you go beyond "Agari", you will move to "Agari". If you follow the instructions and return before "Furidashi", you will return to "Furidashi".
<image>
However, depending on the instructions of the roulette wheel and the square, it may not be possible to reach the "rise". For example, let's say you made a sugoroku like the one shown in the figure. If you use a roulette wheel that only gives 1 and 2, you can go to "Agari" if you come out in the order of 1 and 2, but if you get 2 first, you will not be able to reach "Agari" forever no matter what comes out. Taro didn't know that and wrote instructions in various squares.
Therefore, on behalf of Taro, please create a program to determine whether or not you may not be able to reach the "rise" depending on the instructions of the roulette and the square.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
max
n
d1
d2
..
..
..
dn
The first line gives the maximum number of roulette wheels max (2 ≤ max ≤ 250), and the second line gives the number of cells other than "starting" and "rising" n (2 ≤ n ≤ 250). .. The next n lines are given the number di (-n ≤ di ≤ n) that represents the indication for each cell. When di is zero, it means that no instruction is written, when it is a positive number, it means | di | forward instruction, and when it is negative, it means | di | back instruction (where | x | is x). Represents an absolute value). All values entered are integers.
The number of datasets does not exceed 100.
output
The judgment result is output to one line for each data set. Depending on the instructions of the roulette and the square, if it may not be possible to reach the "go up", "NG" is output, otherwise "OK" is output.
Example
Input
3
3
-2
1
0
2
4
2
0
-1
-2
2
2
-2
-2
0
Output
OK
NG
NG
"Correct Solution:
```
def reachable(graph, init):
if init not in graph or graph[init] is None:
return set()
tmp, graph[init] = graph[init], None
return tmp.union(* [reachable(graph, i) for i in tmp])
def sugoroku(m, d):
d = [0] + d + [0]
start, goal = 0, len(d) - 1
graph_to = {goal:{goal}}
graph_from = {start:{start}}
for init in range(len(d) - 1):
for xi in range(1, 1 + m):
pos = min(init + xi, goal)
to = max(start, min(pos + d[pos],goal))
try:
graph_to[to].add(init)
except KeyError:
graph_to[to] = {init}
try:
graph_from[init].add(to)
except KeyError:
graph_from[init] = {to}
unreachable_node = reachable(graph_from, start).difference(reachable(graph_to, goal))
return 0 == len(unreachable_node)
import sys
f = sys.stdin
while True:
m = int(f.readline())
if m == 0:
break
d = [int(f.readline()) for _ in range(int(f.readline()))]
print('OK' if sugoroku(m, d) else 'NG')
```
| 11,557 |
Provide a correct Python 3 solution for this coding contest problem.
Taro made a sugoroku so that everyone can play at the children's association event. In order to make the game interesting, I wrote instructions such as "advance 6" and "back 5" in some of the sugoroku squares other than "Furidashi" and "Agari". Turn the roulette wheel to advance as many times as you can, and if an instruction is written on the stopped square, move according to that instruction. However, it does not follow the instructions of the squares that proceeded according to the instructions.
Roulette shall be able to give a number between 1 and a certain number with equal probability. Also, if you get a larger number than you reach "Agari", or if you follow the instructions and you go beyond "Agari", you will move to "Agari". If you follow the instructions and return before "Furidashi", you will return to "Furidashi".
<image>
However, depending on the instructions of the roulette wheel and the square, it may not be possible to reach the "rise". For example, let's say you made a sugoroku like the one shown in the figure. If you use a roulette wheel that only gives 1 and 2, you can go to "Agari" if you come out in the order of 1 and 2, but if you get 2 first, you will not be able to reach "Agari" forever no matter what comes out. Taro didn't know that and wrote instructions in various squares.
Therefore, on behalf of Taro, please create a program to determine whether or not you may not be able to reach the "rise" depending on the instructions of the roulette and the square.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
max
n
d1
d2
..
..
..
dn
The first line gives the maximum number of roulette wheels max (2 ≤ max ≤ 250), and the second line gives the number of cells other than "starting" and "rising" n (2 ≤ n ≤ 250). .. The next n lines are given the number di (-n ≤ di ≤ n) that represents the indication for each cell. When di is zero, it means that no instruction is written, when it is a positive number, it means | di | forward instruction, and when it is negative, it means | di | back instruction (where | x | is x). Represents an absolute value). All values entered are integers.
The number of datasets does not exceed 100.
output
The judgment result is output to one line for each data set. Depending on the instructions of the roulette and the square, if it may not be possible to reach the "go up", "NG" is output, otherwise "OK" is output.
Example
Input
3
3
-2
1
0
2
4
2
0
-1
-2
2
2
-2
-2
0
Output
OK
NG
NG
"Correct Solution:
```
def search(x, visited, edges):
if visited[x]:
return
visited[x] = True
for to in edges[x]:
search(to, visited, edges)
def main():
while True:
m = int(input())
if m == 0:
break
n = int(input())
mp = [0] + [int(input()) for _ in range(n)] + [0]
visited = [False] * (n + 2)
rev_visited = [False] * (n + 2)
edges = [[] for _ in range(n + 2)]
rev_edges = [[] for _ in range(n + 2)]
for i in range(n + 2):
for j in range(1, m + 1):
nex = i + j
nex = min(nex, n + 1)
nex += mp[nex]
nex = min(nex, n + 1)
nex = max(nex, 0)
edges[i].append(nex)
rev_edges[nex].append(i)
search(0, visited, edges)
search(n + 1, rev_visited, rev_edges)
for node in range(n + 1):
if visited[node] and not rev_visited[node]:
print("NG")
break
else:
print("OK")
main()
```
| 11,558 |
Provide a correct Python 3 solution for this coding contest problem.
Taro made a sugoroku so that everyone can play at the children's association event. In order to make the game interesting, I wrote instructions such as "advance 6" and "back 5" in some of the sugoroku squares other than "Furidashi" and "Agari". Turn the roulette wheel to advance as many times as you can, and if an instruction is written on the stopped square, move according to that instruction. However, it does not follow the instructions of the squares that proceeded according to the instructions.
Roulette shall be able to give a number between 1 and a certain number with equal probability. Also, if you get a larger number than you reach "Agari", or if you follow the instructions and you go beyond "Agari", you will move to "Agari". If you follow the instructions and return before "Furidashi", you will return to "Furidashi".
<image>
However, depending on the instructions of the roulette wheel and the square, it may not be possible to reach the "rise". For example, let's say you made a sugoroku like the one shown in the figure. If you use a roulette wheel that only gives 1 and 2, you can go to "Agari" if you come out in the order of 1 and 2, but if you get 2 first, you will not be able to reach "Agari" forever no matter what comes out. Taro didn't know that and wrote instructions in various squares.
Therefore, on behalf of Taro, please create a program to determine whether or not you may not be able to reach the "rise" depending on the instructions of the roulette and the square.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
max
n
d1
d2
..
..
..
dn
The first line gives the maximum number of roulette wheels max (2 ≤ max ≤ 250), and the second line gives the number of cells other than "starting" and "rising" n (2 ≤ n ≤ 250). .. The next n lines are given the number di (-n ≤ di ≤ n) that represents the indication for each cell. When di is zero, it means that no instruction is written, when it is a positive number, it means | di | forward instruction, and when it is negative, it means | di | back instruction (where | x | is x). Represents an absolute value). All values entered are integers.
The number of datasets does not exceed 100.
output
The judgment result is output to one line for each data set. Depending on the instructions of the roulette and the square, if it may not be possible to reach the "go up", "NG" is output, otherwise "OK" is output.
Example
Input
3
3
-2
1
0
2
4
2
0
-1
-2
2
2
-2
-2
0
Output
OK
NG
NG
"Correct Solution:
```
import sys
input = sys.stdin.readline
from collections import deque
def bfs(adj_list, s):
q = deque([s])
visited = [False]*(n+2)
visited[s] = True
while q:
v = q.popleft()
for nv in adj_list[v]:
if not visited[nv]:
visited[nv] = True
q.append(nv)
return visited
while True:
m = int(input())
if m==0:
break
n = int(input())
d = [int(input()) for _ in range(n)]
adj_list = [[] for _ in range(n+2)]
rev_adj_list = [[] for _ in range(n+2)]
for i in range(n+1):
for j in range(1, m+1):
if i+j>n:
adj_list[i].append(n+1)
rev_adj_list[n+1].append(i)
else:
t = min(n+1, max(i+j+d[i+j-1], 0))
adj_list[i].append(t)
rev_adj_list[t].append(i)
visited_1 = bfs(adj_list, 0)
visited_2 = bfs(rev_adj_list, n+1)
for i in range(n+2):
if visited_1[i] and not visited_2[i]:
print('NG')
break
else:
print('OK')
```
| 11,559 |
Provide a correct Python 3 solution for this coding contest problem.
Taro made a sugoroku so that everyone can play at the children's association event. In order to make the game interesting, I wrote instructions such as "advance 6" and "back 5" in some of the sugoroku squares other than "Furidashi" and "Agari". Turn the roulette wheel to advance as many times as you can, and if an instruction is written on the stopped square, move according to that instruction. However, it does not follow the instructions of the squares that proceeded according to the instructions.
Roulette shall be able to give a number between 1 and a certain number with equal probability. Also, if you get a larger number than you reach "Agari", or if you follow the instructions and you go beyond "Agari", you will move to "Agari". If you follow the instructions and return before "Furidashi", you will return to "Furidashi".
<image>
However, depending on the instructions of the roulette wheel and the square, it may not be possible to reach the "rise". For example, let's say you made a sugoroku like the one shown in the figure. If you use a roulette wheel that only gives 1 and 2, you can go to "Agari" if you come out in the order of 1 and 2, but if you get 2 first, you will not be able to reach "Agari" forever no matter what comes out. Taro didn't know that and wrote instructions in various squares.
Therefore, on behalf of Taro, please create a program to determine whether or not you may not be able to reach the "rise" depending on the instructions of the roulette and the square.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
max
n
d1
d2
..
..
..
dn
The first line gives the maximum number of roulette wheels max (2 ≤ max ≤ 250), and the second line gives the number of cells other than "starting" and "rising" n (2 ≤ n ≤ 250). .. The next n lines are given the number di (-n ≤ di ≤ n) that represents the indication for each cell. When di is zero, it means that no instruction is written, when it is a positive number, it means | di | forward instruction, and when it is negative, it means | di | back instruction (where | x | is x). Represents an absolute value). All values entered are integers.
The number of datasets does not exceed 100.
output
The judgment result is output to one line for each data set. Depending on the instructions of the roulette and the square, if it may not be possible to reach the "go up", "NG" is output, otherwise "OK" is output.
Example
Input
3
3
-2
1
0
2
4
2
0
-1
-2
2
2
-2
-2
0
Output
OK
NG
NG
"Correct Solution:
```
from collections import deque
while 1:
M = int(input())
if M == 0:
break
N = int(input())
D = [0] + [int(input()) for i in range(N)] + [0]
G = [[] for i in range(N+2)]
u = [0]*(N+2)
que = deque([0])
u[0] = 1
while que:
v = que.popleft()
for j in range(1, M+1):
if D[min(v+j, N+1)] != 0:
to = max(min(v+j+D[v+j], N+1), 0)
else:
to = min(v+j, N+1)
if not u[to]:
que.append(to)
u[to] = 1
G[to].append(v)
z = [0]*(N+2)
que = deque([N+1])
z[N+1] = 1
while que:
v = que.popleft()
for w in G[v]:
if z[w]:
continue
z[w] = 1
que.append(w)
print("OK" if u == z else "NG")
```
| 11,560 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro made a sugoroku so that everyone can play at the children's association event. In order to make the game interesting, I wrote instructions such as "advance 6" and "back 5" in some of the sugoroku squares other than "Furidashi" and "Agari". Turn the roulette wheel to advance as many times as you can, and if an instruction is written on the stopped square, move according to that instruction. However, it does not follow the instructions of the squares that proceeded according to the instructions.
Roulette shall be able to give a number between 1 and a certain number with equal probability. Also, if you get a larger number than you reach "Agari", or if you follow the instructions and you go beyond "Agari", you will move to "Agari". If you follow the instructions and return before "Furidashi", you will return to "Furidashi".
<image>
However, depending on the instructions of the roulette wheel and the square, it may not be possible to reach the "rise". For example, let's say you made a sugoroku like the one shown in the figure. If you use a roulette wheel that only gives 1 and 2, you can go to "Agari" if you come out in the order of 1 and 2, but if you get 2 first, you will not be able to reach "Agari" forever no matter what comes out. Taro didn't know that and wrote instructions in various squares.
Therefore, on behalf of Taro, please create a program to determine whether or not you may not be able to reach the "rise" depending on the instructions of the roulette and the square.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
max
n
d1
d2
..
..
..
dn
The first line gives the maximum number of roulette wheels max (2 ≤ max ≤ 250), and the second line gives the number of cells other than "starting" and "rising" n (2 ≤ n ≤ 250). .. The next n lines are given the number di (-n ≤ di ≤ n) that represents the indication for each cell. When di is zero, it means that no instruction is written, when it is a positive number, it means | di | forward instruction, and when it is negative, it means | di | back instruction (where | x | is x). Represents an absolute value). All values entered are integers.
The number of datasets does not exceed 100.
output
The judgment result is output to one line for each data set. Depending on the instructions of the roulette and the square, if it may not be possible to reach the "go up", "NG" is output, otherwise "OK" is output.
Example
Input
3
3
-2
1
0
2
4
2
0
-1
-2
2
2
-2
-2
0
Output
OK
NG
NG
Submitted Solution:
```
def sugoroku(m, d):
d = [0] + d + [0]
start, goal = 0, len(d) - 1
g = [[0 for j in range(len(d))] for i in range(len(d))]
for i in range(len(d) - 1):
for mi in range(1, m + 1):
pos = min(goal, i + mi)
pos = max(start, pos + d[pos])
g[i][pos] = 1
for k in range(len(d)):
for i in range(len(d)):
for j in range(len(d)):
if g[i][k] and g[k][j]:
g[i][j] = 1
for i in range(len(d) - 1):
if g[start][i] and not g[i][goal]:
return False
return True
import sys
f = sys.stdin
while True:
m = int(f.readline())
if m == 0:
break
d = [int(f.readline()) for _ in range(int(f.readline()))]
print('OK' if sugoroku(m, d) else 'NG')
```
No
| 11,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro made a sugoroku so that everyone can play at the children's association event. In order to make the game interesting, I wrote instructions such as "advance 6" and "back 5" in some of the sugoroku squares other than "Furidashi" and "Agari". Turn the roulette wheel to advance as many times as you can, and if an instruction is written on the stopped square, move according to that instruction. However, it does not follow the instructions of the squares that proceeded according to the instructions.
Roulette shall be able to give a number between 1 and a certain number with equal probability. Also, if you get a larger number than you reach "Agari", or if you follow the instructions and you go beyond "Agari", you will move to "Agari". If you follow the instructions and return before "Furidashi", you will return to "Furidashi".
<image>
However, depending on the instructions of the roulette wheel and the square, it may not be possible to reach the "rise". For example, let's say you made a sugoroku like the one shown in the figure. If you use a roulette wheel that only gives 1 and 2, you can go to "Agari" if you come out in the order of 1 and 2, but if you get 2 first, you will not be able to reach "Agari" forever no matter what comes out. Taro didn't know that and wrote instructions in various squares.
Therefore, on behalf of Taro, please create a program to determine whether or not you may not be able to reach the "rise" depending on the instructions of the roulette and the square.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
max
n
d1
d2
..
..
..
dn
The first line gives the maximum number of roulette wheels max (2 ≤ max ≤ 250), and the second line gives the number of cells other than "starting" and "rising" n (2 ≤ n ≤ 250). .. The next n lines are given the number di (-n ≤ di ≤ n) that represents the indication for each cell. When di is zero, it means that no instruction is written, when it is a positive number, it means | di | forward instruction, and when it is negative, it means | di | back instruction (where | x | is x). Represents an absolute value). All values entered are integers.
The number of datasets does not exceed 100.
output
The judgment result is output to one line for each data set. Depending on the instructions of the roulette and the square, if it may not be possible to reach the "go up", "NG" is output, otherwise "OK" is output.
Example
Input
3
3
-2
1
0
2
4
2
0
-1
-2
2
2
-2
-2
0
Output
OK
NG
NG
Submitted Solution:
```
inf = 1000000
def graph_set(g, i, j, v):
g[i][j >> 5] |= v << (j & 31)
def graph_set1(g, i, j):
graph_set(g, i, j, 1)
def graph_get(g, i, j):
return (g[i][j >> 5] >> (j & 31)) & 1
def solve(dmax, arr):
arr.insert(0, 0)
arr.append(0)
n = len(arr)
g = [[0 for _ in range(int((n + 31) / 32))] for _ in range(n)]
for i in range(n):
graph_set1(g, i, i)
for s in range(n):
for d in range(1, dmax + 1):
next = min(max(0, s + d), n - 1)
next += arr[next]
next = min(max(0, next), n - 1)
graph_set1(g, s, next)
for k in range(n):
for i in range(n):
for j in range(n):
graph_set(g, i, j,
graph_get(g, i, j) | graph_get(g, i, k) & graph_get(g, k, j))
for i in range(0, n - 1):
if graph_get(g, 0, i) and (not graph_get(g, i, n - 1)):
print("NG")
return
print("OK")
def main():
while True:
dmax = int(input())
if dmax == 0:
return
n = int(input())
arr = [int(input()) for _ in range(n)]
solve(dmax, arr)
main()
```
No
| 11,562 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro made a sugoroku so that everyone can play at the children's association event. In order to make the game interesting, I wrote instructions such as "advance 6" and "back 5" in some of the sugoroku squares other than "Furidashi" and "Agari". Turn the roulette wheel to advance as many times as you can, and if an instruction is written on the stopped square, move according to that instruction. However, it does not follow the instructions of the squares that proceeded according to the instructions.
Roulette shall be able to give a number between 1 and a certain number with equal probability. Also, if you get a larger number than you reach "Agari", or if you follow the instructions and you go beyond "Agari", you will move to "Agari". If you follow the instructions and return before "Furidashi", you will return to "Furidashi".
<image>
However, depending on the instructions of the roulette wheel and the square, it may not be possible to reach the "rise". For example, let's say you made a sugoroku like the one shown in the figure. If you use a roulette wheel that only gives 1 and 2, you can go to "Agari" if you come out in the order of 1 and 2, but if you get 2 first, you will not be able to reach "Agari" forever no matter what comes out. Taro didn't know that and wrote instructions in various squares.
Therefore, on behalf of Taro, please create a program to determine whether or not you may not be able to reach the "rise" depending on the instructions of the roulette and the square.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
max
n
d1
d2
..
..
..
dn
The first line gives the maximum number of roulette wheels max (2 ≤ max ≤ 250), and the second line gives the number of cells other than "starting" and "rising" n (2 ≤ n ≤ 250). .. The next n lines are given the number di (-n ≤ di ≤ n) that represents the indication for each cell. When di is zero, it means that no instruction is written, when it is a positive number, it means | di | forward instruction, and when it is negative, it means | di | back instruction (where | x | is x). Represents an absolute value). All values entered are integers.
The number of datasets does not exceed 100.
output
The judgment result is output to one line for each data set. Depending on the instructions of the roulette and the square, if it may not be possible to reach the "go up", "NG" is output, otherwise "OK" is output.
Example
Input
3
3
-2
1
0
2
4
2
0
-1
-2
2
2
-2
-2
0
Output
OK
NG
NG
Submitted Solution:
```
inf = 1000000
def graph_set(g, i, j, v):
g[i][j >> 5] |= v << (j & 31)
def graph_set1(g, i, j):
graph_set(g, i, j, 1)
def graph_get(g, i, j):
return (g[i][j >> 5] >> (j & 31)) & 1
def solve(dmax, arr):
arr.insert(0, 0)
arr.append(0)
n = len(arr)
g = [[False for _ in range(n)] for _ in range(n)]
for i in range(n):
g[i][i] = True
for s in range(n):
for d in range(1, dmax + 1):
next = min(max(0, s + d), n - 1)
next += arr[next]
next = min(max(0, next), n - 1)
g[s][next] = True
visited = [[False for _ in range(n)] for _ in range(n)]
memo = [[None for _ in range(n)] for _ in range(n)]
def dfs(s, i, t):
if i == t:
return True
if visited[i][t]:
return False
if memo[i][t] != None:
return memo[i][t]
visited[i][t] = True
memo[s][i] = True
for j in range(n):
if g[i][j] and not visited[j][t] and dfs(s, j, t):
g[i][t] = True
return True
memo[i][t] = False
g[i][t] = False
return False
for i in range(n):
for j in range(n):
if dfs(i, i, j):
g[i][j] = True
for i in range(0, n - 1):
if g[0][i] and (not g[i][n - 1]):
print("NG")
return
print("OK")
def main():
while True:
dmax = int(input())
if dmax == 0:
return
n = int(input())
arr = [int(input()) for _ in range(n)]
solve(dmax, arr)
main()
```
No
| 11,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Taro made a sugoroku so that everyone can play at the children's association event. In order to make the game interesting, I wrote instructions such as "advance 6" and "back 5" in some of the sugoroku squares other than "Furidashi" and "Agari". Turn the roulette wheel to advance as many times as you can, and if an instruction is written on the stopped square, move according to that instruction. However, it does not follow the instructions of the squares that proceeded according to the instructions.
Roulette shall be able to give a number between 1 and a certain number with equal probability. Also, if you get a larger number than you reach "Agari", or if you follow the instructions and you go beyond "Agari", you will move to "Agari". If you follow the instructions and return before "Furidashi", you will return to "Furidashi".
<image>
However, depending on the instructions of the roulette wheel and the square, it may not be possible to reach the "rise". For example, let's say you made a sugoroku like the one shown in the figure. If you use a roulette wheel that only gives 1 and 2, you can go to "Agari" if you come out in the order of 1 and 2, but if you get 2 first, you will not be able to reach "Agari" forever no matter what comes out. Taro didn't know that and wrote instructions in various squares.
Therefore, on behalf of Taro, please create a program to determine whether or not you may not be able to reach the "rise" depending on the instructions of the roulette and the square.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
max
n
d1
d2
..
..
..
dn
The first line gives the maximum number of roulette wheels max (2 ≤ max ≤ 250), and the second line gives the number of cells other than "starting" and "rising" n (2 ≤ n ≤ 250). .. The next n lines are given the number di (-n ≤ di ≤ n) that represents the indication for each cell. When di is zero, it means that no instruction is written, when it is a positive number, it means | di | forward instruction, and when it is negative, it means | di | back instruction (where | x | is x). Represents an absolute value). All values entered are integers.
The number of datasets does not exceed 100.
output
The judgment result is output to one line for each data set. Depending on the instructions of the roulette and the square, if it may not be possible to reach the "go up", "NG" is output, otherwise "OK" is output.
Example
Input
3
3
-2
1
0
2
4
2
0
-1
-2
2
2
-2
-2
0
Output
OK
NG
NG
Submitted Solution:
```
def sugoroku(m, d):
d = [0] + d + [0]
start, goal = 0, len(d) - 1
g = [[0 for j in range(len(d))] for i in range(len(d))]
for i in range(len(d) - 1):
for mi in range(m + 1):
pos = min(goal, i + mi)
pos = max(start, pos + d[pos])
g[i][pos] = 1
for i in range(len(d)):
for j in range(len(d)):
for k in range(len(d)):
if g[i][j] and g[j][k]:
g[i][k]
for i in range(len(d)):
if g[start][i] and not g[i][goal]:
return False
return True
import sys
f = sys.stdin
while True:
m = int(f.readline())
if m == 0:
break
d = [int(f.readline()) for _ in range(int(f.readline()))]
print('OK' if sugoroku(m, d) else 'NG')
```
No
| 11,564 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
"Correct Solution:
```
coin=[500,100,50,10,5,1]
while True:
a = 1000-int(input())
if a == 1000: break
ans = 0
for i in coin:
ans += a // i
a %= i
print(ans)
```
| 11,565 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
"Correct Solution:
```
while True:
money=int(input())
if money==0:
break
a=1000-money
A=a//500
b=a-500*A
B=b//100
c=b-100*B
C=c//50
d=c-50*C
D=d//10
e=d-D*10
E=e//5
F=e-E*5
print(A+B+C+D+E+F)
```
| 11,566 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
"Correct Solution:
```
while True:
money=int(input())
if money==0:
break
n=1000-money
a=n//500
b=(n%500)//100
c=(n%500%100)//50
d=(n%500%100%50)//10
e=(n%500%100%50%10)//5
f=(n%500%100%50%10%5)//1
print(a+b+c+d+e+f)
```
| 11,567 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
"Correct Solution:
```
while True:
x=int(input())
if x==0:
break
y=1000-x
a=y//500
b=(y-500*a)//100
c=(y-500*a-100*b)//50
d=(y-500*a-100*b-50*c)//10
e=(y-500*a-100*b-50*c-10*d)//5
f=(y-500*a-100*b-50*c-10*d-5*e)
print(a+b+c+d+e+f)
```
| 11,568 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
"Correct Solution:
```
while True:
coin = int(input())
if coin == 0: break
ans = 0
oturi = 1000 - coin
for i in [500,100,50,10,5,1]:
ans += oturi // i
oturi = oturi % i
print(ans)
```
| 11,569 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
"Correct Solution:
```
i = 0
while True:
n = int(input())
x = 1000 - n
if n == 0:
break
a = x//500
x = x%500
b = x//100
x = x%100
c = x//50
x = x%50
d = x//10
x = x%10
e = x//5
f = x%5
print(a+b+c+d+e+f)
i += 1
```
| 11,570 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
"Correct Solution:
```
try:
while True:
n=int(input())
m=1000-n
i=0
if m==1000:
break
else:
i+=m//500
m=m%500
i+=m//100
m=m%100
i+=m//50
m=m%50
i+=m//10
m=m%10
i+=m//5
m=m%5
i+=m
print(i)
except EOFError:
pass
```
| 11,571 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
"Correct Solution:
```
while True:
a = int(input())
if a == 0:break
b=(1000-a)//500
c=(1000-a-500*b)//100
d=(1000-a-500*b-100*c)//50
e=(1000-a-500*b-100*c-50*d)//10
f=(1000-a-500*b-100*c-50*d-10*e)//5
g=1000-a-500*b-100*c-50*d-10*e-5*f
print(b+c+d+e+f+g)
```
| 11,572 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
Submitted Solution:
```
for i in range(5):
x=int(input())
if x==0:break
else:
s=1000-x
a=s//500
a1=s-a*500
b=a1//100
b1=a1-b*100
c=b1//50
c1=b1-c*50
d=c1//10
d1=c1-d*10
e=d1//5
f=d1-e*5
sum=a+b+c+d+e+f
print(sum)
```
Yes
| 11,573 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
Submitted Solution:
```
while True:
price = int(input())
change = 1000 - price
n = 0
if price == 0:
break
if change >= 500:
change -= 500
n += 1
while change >= 100:
change -= 100
n += 1
if change >= 50:
change -= 50
n += 1
while change >= 10:
change -= 10
n += 1
if change >= 5:
change -= 5
n += 1
while change >= 1:
change -= 1
n += 1
print(n)
```
Yes
| 11,574 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
Submitted Solution:
```
a = [500,100,50,10,5,1]
while True:
x = int(input())
if x == 0:
break
x = 1000-x
b = 0
for c in a:
b += x//c
x %= c
print(b)
```
Yes
| 11,575 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
Submitted Solution:
```
for i in range(5):
a=int(input())
A=1000-a
x=A//500
M=A%500
y=M//100
M=M%100
z=M//50
M=M%50
w=M//10
M=M%10
u=M//5
M=M%5
if a==0: break
print(x+y+z+w+u+M)
```
Yes
| 11,576 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
Submitted Solution:
```
coins = [500, 100, 50, 10, 5, 1]
if __name__ == '__main__':
p = int(input())
ch = 1000 - p
count = 0
for coin in coins:
n = ch // coin
ch -= coin * n
count += n
print(count)
```
No
| 11,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
Submitted Solution:
```
for e in iter(input,'0'):
a,b=0,1000-int(e)
for i in[500,100,50,10,5]:
b%=i
a+=b//i
print(b+a)
```
No
| 11,578 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
Submitted Solution:
```
c, o= 0, 1000-int(input())
def change(v):
global c, o
if o>= v:
t= o//v
o, c= o-(v*t), c+t
for l in [500, 100, 50, 10, 5, 1]: change(l)
print(int(c+o))
```
No
| 11,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
Submitted Solution:
```
c, o= 0, 1000-int(input())
def change(v):
global c, o
if o>= v:
t= o//v
o, c= o-(v*t), c+t
for l in [500, 100, 50, 10, 5, 1]: change(l)
print(c+o)
```
No
| 11,580 |
Provide a correct Python 3 solution for this coding contest problem.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
"Correct Solution:
```
def solve():
def measurement(a, b, w):
a_root = root[a]
b_root = root[b]
if a_root != b_root:
a_member = member[a_root]
b_member = member[b_root]
offset = w - (weight[b] - weight[a])
if len(a_member) > len(b_member):
a_member.extend(b_member)
for n in b_member:
root[n] = a_root
weight[n] += offset
else:
b_member.extend(a_member)
for n in a_member:
root[n] = b_root
weight[n] -= offset
def inquiry(a, b):
if root[a] == root[b]:
return weight[b] - weight[a]
else:
return 'UNKNOWN'
import sys
file_input = sys.stdin.readlines()
ans = []
while True:
N, M = map(int, file_input[0].split())
if N == 0:
break
root = [i for i in range(N + 1)]
member = [[i] for i in range(N + 1)]
weight = [0] * (N + 1)
for line in file_input[1:M+1]:
if line[0] == '!':
a, b, w = map(int, line[2:].split())
measurement(a, b, w)
else:
a, b= map(int, line[2:].split())
ans.append(inquiry(a, b))
del file_input[:M+1]
print(*ans, sep='\n')
solve()
```
| 11,581 |
Provide a correct Python 3 solution for this coding contest problem.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
class UnionFind:
def __init__(self, size):
self.table = [-1 for _ in range(size)]
def find(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.find(self.table[x])
return self.table[x]
def union(self, x, y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] <= self.table[s2]:
self.table[s1] += self.table[s2]
self.table[s2] = s1
else:
self.table[s2] += self.table[s1]
self.table[s1] = s2
return True
return False
def subsetall(self):
a = []
for i in range(len(self.table)):
if self.table[i] < 0:
a.append((i, -self.table[i]))
return a
def main():
random.seed(42)
rr = []
def f(n, m):
qa = [LS() for _ in range(m)]
d = collections.defaultdict(lambda: collections.defaultdict(int))
for i in range(n+1):
d[i][i] = random.randrange(1,100)
r = []
uf = UnionFind(n+1)
for q in qa:
if q[0] == '!':
a,b,w = map(int, q[1:])
fa = uf.find(a)
fb = uf.find(b)
if fa == fb:
continue
uf.union(a,b)
# print('a,b',a,b)
# print('dfa', d[fa])
# print('dfb', d[fb])
if fa == uf.find(a):
sa = w + (d[fa][a] - d[fb][b])
for k in d[fb].keys():
d[fa][k] = d[fb][k] + sa
else:
sa = (d[fa][a] - d[fb][b]) + w
for k in d[fa].keys():
d[fb][k] = d[fa][k] - sa
# print('sa',sa)
# print('dfa', d[fa])
# print('dfb', d[fb])
else:
a,b = map(int , q[1:])
fa = uf.find(a)
if fa != uf.find(b):
r.append('UNKNOWN')
else:
r.append(d[fa][b] - d[fa][a])
# for k in d.keys():
# print('k,d',k,d[k])
return r
while 1:
n,m = LI()
if n == 0 and m == 0:
break
rr.extend(f(n,m))
return '\n'.join(map(str,rr))
print(main())
```
| 11,582 |
Provide a correct Python 3 solution for this coding contest problem.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
"Correct Solution:
```
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
class WeightedUnionFind():
def __init__(self,N):
self.N = N
self.parents = [-1] * self.N
self.diff_weight = [0] * self.N
def find(self,x):
if self.parents[x] < 0:
return x
else:
p = self.find(self.parents[x])
self.diff_weight[x] += self.diff_weight[self.parents[x]]
self.parents[x] = p
return p
def weight(self,x):#xの親からの重みを返す
self.find(x)
return self.diff_weight[x]
def diff(self,x,y):#同じグループにいたらxとyの重みの差を返す
if self.find(x) == self.find(y):
return self.weight(y) - self.weight(x)
else:
return 10000000000
def unite(self,x,y,w):#wieght(y) = weight(x) + dとなるように合体
w += self.weight(x)
w -= self.weight(y)
x = self.find(x)
y = self.find(y)
if x == y:
if self.diff(x,y) == w:
return True
else:
return False
if self.parents[x] > self.parents[y]:
x,y = y,x
w *= -1
self.parents[x] += self.parents[y]
self.parents[y] = x
self.diff_weight[y] = w
return True
def same(self,x,y):
return self.find(x) == self.find(y)
def size(self,x):
return -self.parents[self.find(x)]
def solve(N,M):
uf = WeightedUnionFind(N)
for _ in range(M):
q = input().split()
if q[0] == '!':
a,b,w = map(int,q[1:])
a -= 1
b -= 1
uf.unite(a,b,w)
else:
a,b = map(int,q[1:])
a -= 1
b -= 1
ans = uf.diff(a,b)
if ans == 10000000000:
print('UNKNOWN')
else:
print(ans)
def main():
while True:
N,M = map(int,input().split())
if N == 0 and M == 0:
break
solve(N,M)
if __name__ == '__main__':
main()
```
| 11,583 |
Provide a correct Python 3 solution for this coding contest problem.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
"Correct Solution:
```
class WeightedUnionFind(object):
__slots__ = ["nodes", "weight"]
def __init__(self, n: int) -> None:
self.nodes = [-1]*n
self.weight = [0]*n
def get_root(self, x: int) -> int:
if x < 0:
raise ValueError("Negative Index")
if self.nodes[x] < 0:
return x
else:
root = self.get_root(self.nodes[x])
self.weight[x] += self.weight[self.nodes[x]]
self.nodes[x] = root
return root
def relate(self, smaller: int, bigger: int, diff_weight: int) -> None:
if smaller < 0 or bigger < 0:
raise ValueError("Negative Index")
root_a, root_b = self.get_root(smaller), self.get_root(bigger)
new_weight = diff_weight + self.weight[smaller] - self.weight[bigger]
if root_a == root_b:
# 問題によっては必要かも（情報に矛盾があるなら-1を出力など）
if self.weight[smaller] + diff_weight == self.weight[bigger]:
return
raise ValueError("relateに矛盾あり")
if self.nodes[root_a] > self.nodes[root_b]:
root_a, root_b, new_weight = root_b, root_a, -new_weight
self.nodes[root_a] += self.nodes[root_b]
self.nodes[root_b] = root_a
self.weight[root_b] = new_weight
def diff(self, x: int, y: int) -> int:
root_x, root_y = self.get_root(x), self.get_root(y)
if root_x != root_y:
return None
return self.weight[y] - self.weight[x]
import sys
while True:
N, M = map(int, input().split())
if N == 0:
break
uf = WeightedUnionFind(N+1)
for qtype, a, b, *c in (sys.stdin.readline().split() for _ in [0]*M):
if qtype == "!":
uf.relate(int(a), int(b), int(c[0]))
else:
diff = uf.diff(int(a), int(b))
print(diff if diff is not None else "UNKNOWN")
```
| 11,584 |
Provide a correct Python 3 solution for this coding contest problem.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
"Correct Solution:
```
class Value_UnionFind():
def __init__(self,n):
self.par = [i for i in range(n)]
self.differ_weight = [0] * n
self.rank = [0] * n
def root(self,x):
if x == self.par[x]:
return x
r = self.root(self.par[x])
self.differ_weight[x] += self.differ_weight[self.par[x]]
self.par[x] = r
return r
def weight(self, x):
self.root(x)
return self.differ_weight[x]
def unit(self, x, y, w):
w += self.weight(x)
w -= self.weight(y)
x = self.root(x)
y = self.root(y)
if x == y: return False
if self.rank[x] < self.rank[y]: x, y, w = y, x, -w
if self.rank[x] == self.rank[y]: self.rank[x] += 1
self.par[y] = x
self.differ_weight[y] = w
return True
def differ(self, x, y):
return self.weight(y) - self.weight(x)
def main(n, m):
Union = Value_UnionFind(n)
for _ in range(m):
x = list(map(str, input().split()))
q = x[0]
if q == "!":
a, b, w = map(int, x[1:])
Union.unit(a-1, b-1, w)
if q == "?":
a, b = map(int,x[1:])
if Union.root(a-1) != Union.root(b-1):
print("UNKNOWN")
else:
print(Union.differ(a-1, b-1))
while 1:
n, m = map(int, input().split())
if n == m == 0:
break
main(n,m)
```
| 11,585 |
Provide a correct Python 3 solution for this coding contest problem.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
"Correct Solution:
```
def solve():
def measurement(a, b, w):
a_root = root[a]
b_root = root[b]
if a_root != b_root:
a_member = member[a_root]
b_member = member[b_root]
offset = w - (weight[b] - weight[a])
if len(a_member) > len(b_member):
a_member.extend(b_member)
for n in b_member:
root[n] = a_root
weight[n] += offset
else:
b_member.extend(a_member)
for n in a_member:
root[n] = b_root
weight[n] -= offset
def inquiry(a, b):
if root[a] == root[b]:
return weight[b] - weight[a]
else:
return 'UNKNOWN'
import sys
file_input = sys.stdin
while True:
N, M = map(int, file_input.readline().split())
if N == 0:
break
root = [i for i in range(N + 1)]
member = [[i] for i in range(N + 1)]
weight = [0] * (N + 1)
for _ in range(M):
line = file_input.readline()
if line[0] == '!':
a, b, w = map(int, line[2:].split())
measurement(a, b, w)
else:
a, b= map(int, line[2:].split())
print(inquiry(a, b))
solve()
```
| 11,586 |
Provide a correct Python 3 solution for this coding contest problem.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
"Correct Solution:
```
def solve():
def measurement(a, b, w):
a_root = root[a]
b_root = root[b]
if a_root != b_root:
a_member = member[a_root]
b_member = member[b_root]
offset = w - (weight[b] - weight[a])
if len(a_member) > len(b_member):
a_member.extend(b_member)
for n in b_member:
root[n] = a_root
weight[n] += offset
else:
b_member.extend(a_member)
for n in a_member:
root[n] = b_root
weight[n] -= offset
def inquiry(a, b):
if root[a] == root[b]:
return weight[b] - weight[a]
else:
return 'UNKNOWN'
def operation(line):
if line[0] == '!':
a, b, w = map(int, line[2:].split())
measurement(a, b, w)
else:
a, b = map(int, line[2:].split())
return inquiry(a, b)
import sys
file_input = sys.stdin.readlines()
while True:
N, M = map(int, file_input[0].split())
if N == 0:
break
root = [i for i in range(N + 1)]
member = [[i] for i in range(N + 1)]
weight = [0] * (N + 1)
ans = (operation(line) for line in file_input[1:M+1])
ans = filter(lambda x: x != None, ans)
print(*ans, sep='\n')
del file_input[:M+1]
solve()
```
| 11,587 |
Provide a correct Python 3 solution for this coding contest problem.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 5)
# 連結性の確認
class UnionFind():
def __init__(self, n):
self.parents = list(range(n))
self.weight = [0] * n
self.rank = [0] * n
def find(self, a):
if self.parents[a] == a:
return a
p = self.find(self.parents[a])
self.weight[a] += self.weight[self.parents[a]]
self.parents[a] = p
return p
def union(self, a, b, w):
self.find(a), self.find(b)
w += self.weight[a]
w -= self.weight[b]
a = self.find(a)
b = self.find(b)
if a == b: return
if self.rank[a] < self.rank[b]:
self.parents[a] = b
self.weight[a] = -w
else:
self.parents[b] = a
self.weight[b] = w
if self.rank[a] == self.rank[b]:
self.rank[a] += 1
def weight_check(self, a, b):
self.find(a), self.find(b)
return - self.weight[a] + self.weight[b]
while True:
N, M = map(int, input().split())
if not(N | M):
break
uf = UnionFind(N)
for i in range(M):
input_str = input().split()
if input_str[0] == '!':
a, b, w = map(int, input_str[1:])
uf.union(a - 1, b - 1, w)
else:
a, b = map(lambda x: int(x) - 1, input_str[1:])
if uf.find(a) != uf.find(b):
print('UNKNOWN')
continue
print(uf.weight_check(a, b))
```
| 11,588 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
Submitted Solution:
```
def solve():
def measurement(a, b, w):
a_root = root[a]
b_root = root[b]
if a_root != b_root:
a_member = member[a_root]
b_member = member[b_root]
offset = w - (weight[b] - weight[a])
if len(a_member) > len(b_member):
a_member.extend(b_member)
for n in b_member:
root[n] = a_root
weight[n] += offset
else:
b_member.extend(a_member)
for n in a_member:
root[n] = b_root
weight[n] -= offset
def inquiry(a, b):
if root[a] == root[b]:
return weight[b] - weight[a]
else:
return 'UNKNOWN'
import sys
file_input = sys.stdin.readlines()
while True:
N, M = map(int, file_input[0].split())
if N == 0:
break
root = [i for i in range(N + 1)]
member = [[i] for i in range(N + 1)]
weight = [0] * (N + 1)
for line in file_input[1:M+1]:
if line[0] == '!':
a, b, w = map(int, line[2:].split())
measurement(a, b, w)
else:
a, b= map(int, line[2:].split())
print(inquiry(a, b))
del file_input[:M+1]
solve()
```
Yes
| 11,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
Submitted Solution:
```
import sys
sys.setrecursionlimit(10**6)
def root(x):
if x == parent[x]:
return x
y = root(parent[x])
relative[x] += relative[parent[x]]
parent[x] = y
return y
def unite(a, b, w):
pa = root(a); pb = root(b)
pw = relative[a] + w - relative[b]
if pa < pb:
parent[pb] = pa
relative[pb] = pw
else:
parent[pa] = pb
relative[pa] = -pw
while 1:
N, M = map(int, input().split())
if N == M == 0:
break
*parent, = range(N)
relative = [0]*N
for i in range(M):
cmd = input().split()
if cmd[0] == '!':
a, b, w = map(int, cmd[1:])
unite(a-1, b-1, w)
else:
a, b = map(int, cmd[1:])
if root(a-1) != root(b-1):
print("UNKNOWN")
else:
print(relative[b-1] - relative[a-1])
```
Yes
| 11,590 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
Submitted Solution:
```
class WeightedUnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.weight = [0] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
y = self.find(self.par[x])
self.weight[x] += self.weight[self.par[x]]
self.par[x] = y
return y
# 重さの検索
def weighting(self, x):
self.find(x)
return self.weight[x]
# 併合
def union(self, x, y, w):
px = self.find(x)
py = self.find(y)
if px != py:
if self.rank[px] < self.rank[py]:
self.par[px] = py
self.weight[px] = w - self.weight[x] + self.weight[y]
else:
self.par[py] = px
self.weight[py] = -w - self.weight[y] + self.weight[x]
if self.rank[px] == self.rank[py]:
self.rank[px] += 1
# 同じ集合に属するか
def same(self, x, y):
return self.find(x) == self.find(y)
# 各頂点間の絶対距離
def diff(self, x, y):
return self.weight[x] - self.weight[y]
N, M = 1, 1
while True:
N, M = map(int, input().split())
if (N == 0) & (M == 0):
quit()
info = [list(input().split()) for i in range(M)]
wuf = WeightedUnionFind(N)
for i in range(M):
if info[i][0] == "!":
wuf.union(int(info[i][1]), int(info[i][2]), int(info[i][3]))
#print("parent:", wuf.par)
#print("weight:", wuf.weight)
#print("rank:", wuf.rank, "\n")
else:
if wuf.same(int(info[i][1]), int(info[i][2])):
print(wuf.diff(int(info[i][1]), int(info[i][2])))
#print("parent:", wuf.par)
#print("weight:", wuf.weight)
#print("rank:", wuf.rank, "\n")
else:
print("UNKNOWN")
#print("parent:", wuf.par)
#print("weight:", wuf.weight)
#print("rank:", wuf.rank, "\n")
```
Yes
| 11,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
Submitted Solution:
```
# Author: cr4zjh0bp
# Created: Fri Mar 20 22:48:43 UTC 2020
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
class WUnionFind:
def __init__(self, n, sum_unity=0):
self.n = n
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.diff_weight = [sum_unity for _ in range(n)]
self._size = [1 for _ in range(n)]
self._edges = 0
def find(self, x):
if self.par[x] == x:
return x
else:
r = self.find(self.par[x])
self.diff_weight[x] += self.diff_weight[self.par[x]]
self.par[x] = r
return r
def unite(self, x, y, w):
w += self.weight(x)
w -= self.weight(y)
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.diff_weight[x] = -w
self._size[y] += self._size[x]
self._edges += 1
else:
self.par[y] = x
self.diff_weight[y] = w
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self._size[x] += self._size[y]
self._edges += 1
def weight(self, x):
self.find(x)
return self.diff_weight[x]
def diff(self, x, y):
return self.weight(y) - self.weight(x)
def size(self, x):
x = self.find(x)
return self._size[x]
def trees(self):
return self.n - self._edges
def same(self, x, y):
return self.find(x) == self.find(y)
while True:
n, m = na()
if n == 0 and m == 0:
break
wuf = WUnionFind(n)
for i in range(m):
que = nas()
if que[0] == '!':
a, b, w = list(map(int, que[1:]))
a -= 1
b -= 1
wuf.unite(a, b, w)
elif que[0] == '?':
a, b = list(map(int, que[1:]))
a -= 1
b -= 1
if wuf.same(a, b):
print(wuf.diff(a, b))
else:
print("UNKNOWN")
```
Yes
| 11,592 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
Submitted Solution:
```
class WeightedUnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.weight = [0] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
y = self.find(self.par[x])
self.weight[x] += self.weight[self.par[x]]
self.par[x] = y
return y
# 重さの検索
def weighting(self, x):
self.find(x)
return self.weight[x]
# 併合
def union(self, x, y, w):
px = self.find(x)
py = self.find(y)
if px != py:
if self.rank[px] < self.rank[py]:
self.par[px] = py
self.weight[px] = w - self.weighting(x) + self.weighting(y)
else:
self.par[py] = px
self.weight[py] = -w - self.weighting(y) + self.weighting(x)
if self.rank[px] == self.rank[py]:
self.rank[px] += 1
# 同じ集合に属するか
def same(self, x, y):
return self.find(x) == self.find(y)
# 各頂点間の絶対距離
def diff(self, x, y):
return self.weighting(x) - self.weighting(y)
N, M = 1, 1
while True:
N, M = map(int, input().split())
if (N == 0) & (M == 0):
quit()
info = [list(input().split()) for i in range(M)]
wuf = WeightedUnionFind(N)
for i in range(M):
if info[i][0] == "!":
wuf.union(int(info[i][1]), int(info[i][2]), int(info[i][3]))
#print("parent:", wuf.par)
#print("weight:", wuf.weight)
#print("rank:", wuf.rank, "\n")
else:
if wuf.same(int(info[i][1]), int(info[i][2])):
print(wuf.diff(int(info[i][1]), int(info[i][2])))
#print("parent:", wuf.par)
#print("weight:", wuf.weight)
#print("rank:", wuf.rank, "\n")
else:
print("UNKNOWN")
#print("parent:", wuf.par)
#print("weight:", wuf.weight)
#print("rank:", wuf.rank, "\n")
```
No
| 11,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
Submitted Solution:
```
class WeightedUnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n + 1)
self.weight = [0] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.weight[x] += self.weight[self.par[x]]
self.par[x] = self.find(self.par[x])
return self.par[x]
# 重さの検索
def weighting(self, x):
self.find(x)
return self.weight[x]
# 併合
def union(self, x, y, w):
w -= self.weighting(x)
w += self.weighting(y)
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.weight[y] = w
self.par[y] = w
else:
self.weight[y] = -w
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか
def same(self, x, y):
return self.find(x) == self.find(y)
# 各頂点間の絶対距離
def diff(self, x, y):
return self.weighting(x) - self.weighting(y)
N, M = 1, 1
while True:
N, M = map(int, input().split())
if (N == 0) & (M == 0):
quit()
info = [list(input().split()) for i in range(M)]
wuf = WeightedUnionFind(N)
for i in range(M):
if info[i][0] == "!":
wuf.union(int(info[i][1]), int(info[i][2]), int(info[i][3]))
else:
if wuf.same(int(info[i][1]), int(info[i][2])):
print(wuf.diff(int(info[i][1]), int(info[i][2])))
else:
print("UNKNOWN")
```
No
| 11,594 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
Submitted Solution:
```
class WeightedUnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n + 1)
self.weight = [0] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.weight[x] += self.weight[self.par[x]]
self.par[x] = self.find(self.par[x])
return self.par[x]
# 重さの検索
def weighting(self, x):
self.find(x)
return self.weight[x]
# 併合
def union(self, x, y, w):
w -= self.weighting(x)
w += self.weighting(y)
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.weight[x] = w
self.par[x] = y
else:
w = -w
self.weight[y] = w
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか
def same(self, x, y):
return self.find(x) == self.find(y)
# 各頂点間の絶対距離
def diff(self, x, y):
return self.weighting(x) - self.weighting(y)
N, M = 1, 1
while True:
N, M = map(int, input().split())
if (N == 0) & (M == 0):
quit()
info = [list(input().split()) for i in range(M)]
wuf = WeightedUnionFind(N)
for i in range(M):
if info[i][0] == "!":
wuf.union(int(info[i][1]), int(info[i][2]), int(info[i][3]))
else:
if wuf.same(int(info[i][1]), int(info[i][2])):
print(wuf.diff(int(info[i][1]), int(info[i][2])))
else:
print("UNKNOWN")
```
No
| 11,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a laboratory, an assistant, Nathan Wada, is measuring weight differences between sample pieces pair by pair. He is using a balance because it can more precisely measure the weight difference between two samples than a spring scale when the samples have nearly the same weight.
He is occasionally asked the weight differences between pairs of samples. He can or cannot answer based on measurement results already obtained.
Since he is accumulating a massive amount of measurement data, it is now not easy for him to promptly tell the weight differences. Nathan asks you to develop a program that records measurement results and automatically tells the weight differences.
Input
The input consists of multiple datasets. The first line of a dataset contains two integers N and M. N denotes the number of sample pieces (2 ≤ N ≤ 100,000). Each sample is assigned a unique number from 1 to N as an identifier. The rest of the dataset consists of M lines (1 ≤ M ≤ 100,000), each of which corresponds to either a measurement result or an inquiry. They are given in chronological order.
A measurement result has the format,
! a b w
which represents the sample piece numbered b is heavier than one numbered a by w micrograms (a ≠ b). That is, w = wb − wa, where wa and wb are the weights of a and b, respectively. Here, w is a non-negative integer not exceeding 1,000,000.
You may assume that all measurements are exact and consistent.
An inquiry has the format,
? a b
which asks the weight difference between the sample pieces numbered a and b (a ≠ b).
The last dataset is followed by a line consisting of two zeros separated by a space.
Output
For each inquiry, ? a b, print the weight difference in micrograms between the sample pieces numbered a and b, wb − wa, followed by a newline if the weight difference can be computed based on the measurement results prior to the inquiry. The difference can be zero, or negative as well as positive. You can assume that its absolute value is at most 1,000,000. If the difference cannot be computed based on the measurement results prior to the inquiry, print UNKNOWN followed by a newline.
Example
Input
2 2
! 1 2 1
? 1 2
2 2
! 1 2 1
? 2 1
4 7
! 1 2 100
? 2 3
! 2 3 100
? 2 3
? 1 3
! 4 3 150
? 4 1
0 0
Output
1
-1
UNKNOWN
100
200
-50
Submitted Solution:
```
import sys
sys.setrecursionlimit(10**6)
def root(x):
if x == parent[x]:
return x
y = root(parent[x])
relative[x] += relative[parent[x]]
parent[x] = y
return y
def unite(a, b, w):
pa = root(a); pb = root(b)
if pa < pb:
parent[pb] = pa
relative[pb] = relative[a] + w
else:
parent[pa] = pb
relative[pa] = relative[b] - w
while 1:
N, M = map(int, input().split())
if N == M == 0:
break
*parent, = range(N+1)
relative = [0]*(N+1)
for i in range(M):
cmd = input().split()
if cmd[0] == '!':
a, b, w = map(int, cmd[1:])
unite(a-1, b-1, w)
else:
a, b = map(int, cmd[1:])
if root(a-1) != root(b-1):
print("UNKNOWN")
else:
print(relative[b-1] - relative[a-1])
```
No
| 11,596 |
Provide a correct Python 3 solution for this coding contest problem.
Matryoshka
Matryoshka is a famous Russian folk craft doll. Matryoshka can be divided into upper and lower parts, and when opened, there is another smaller doll inside. The nesting structure is such that when the small doll that appears is opened, a smaller doll is contained.
<image>
You found an unusually shaped matryoshka doll on your trip and bought N dolls. The shape of the i-th doll is a rectangular parallelepiped of xi × yi × zi.
After watching Matryoshka for a while, you are about to put away Matryoshka. Before that, I want to reduce the space required by storing some dolls in another. When storing a doll, one other doll can be stored only in the doll that has not yet stored any doll. However, only the dolls that are stored directly are counted, and the doll that contains the doll can be stored in another doll.
The stored doll becomes invisible from the outside. However, the following conditions must be met.
* The doll may rotate, but each side of the rectangular parallelepiped is parallel to any side of the other rectangular parallelepiped.
* After rotation, the length of the doll on the side to be stored is shorter for each of the lengths of the corresponding sides.
* At most one doll can be stored directly in one doll
Since the volume of the closet is limited, we want to minimize the sum of the volumes of the dolls that can be seen from the outside. Your job is to create a program that finds the minimum sum of the volumes of the dolls that are visible from the outside, which can be achieved by repeating the operation of storing the dolls any number of times.
Input
The input consists of multiple datasets. The maximum number of data sets does not exceed 50. Each dataset is represented in the following format.
> N
> x1 y1 z1
>::
>::
> xN yN zN
>
Each dataset consists of N + 1 rows, and the first row of the dataset is given the integer N, which represents the number of dolls. In the i-th line of the following N lines, three integers xi, yi, and zi representing the size of the i-th doll are given, separated by a half-width space. These integers satisfy 1 ≤ N, xi, yi, zi ≤ 100.
> The end of the input is represented by a single zero line.
> ### Output
For each data set, output the minimum value of the sum of the volumes of the dolls that can be seen from the outside in one line.
> ### Sample Input
2
one two Three
4 2 3
3
2 5 2
3 3 4
5 5 5
Five
1 1 1
2 2 2
3 3 3
4 4 4
5 5 5
Five
1 1 1
2 1 1
3 1 1
4 1 1
5 1 1
Ten
3 1 4
1 5 9
2 6 5
3 5 8
9 7 9
3 2 3
8 4 6
2 6 4
3 3 8
3 2 7
0
Output for Sample Input
twenty four
145
125
15
864
Example
Input
2
1 2 3
4 2 3
3
2 5 2
3 3 4
5 5 5
5
1 1 1
2 2 2
3 3 3
4 4 4
5 5 5
5
1 1 1
2 1 1
3 1 1
4 1 1
5 1 1
10
3 1 4
1 5 9
2 6 5
3 5 8
9 7 9
3 2 3
8 4 6
2 6 4
3 3 8
3 2 7
0
Output
24
145
125
15
864
"Correct Solution:
```
import heapq
class MinCostFlow:
class Edge:
def __init__(self,to,cap,rev,cost):
self.to = to
self.cap = cap
self.rev = rev
self.cost = cost
def __init__(self,n,inf=1000000007):
self.n = n
self.inf = inf
self.e = [[] for _ in range(n)]
def add_edge(self, fr, to, cap, cost):
self.e[fr].append(self.Edge(to,cap,len(self.e[to]),cost))
self.e[to].append(self.Edge(fr,0,len(self.e[fr])-1,-cost))
def compute(self,source,sink,f):
res = 0
h = [0]*self.n
prevv = [0]*self.n
preve = [0]*self.n
while (f > 0):
pq = []
dist = [self.inf]*self.n
dist[source] = 0
heapq.heappush(pq,(0,source))
while pq:
cost, v = heapq.heappop(pq)
cost = -cost
if dist[v] < cost:continue
for i, edge in enumerate(self.e[v]):
if edge.cap > 0 and dist[v] - h[edge.to] < dist[edge.to] - edge.cost - h[v]:
dist[edge.to] = dist[v] + edge.cost + h[v] - h[edge.to]
prevv[edge.to] = v
preve[edge.to] = i
heapq.heappush(pq,(-dist[edge.to],edge.to))
if dist[sink] == self.inf:return -1
for v in range(self.n):
h[v] += dist[v]
d, v = f, sink
while v != source:
d = min(d,self.e[prevv[v]][preve[v]].cap)
v = prevv[v]
f -= d
res += d*h[sink]
v = sink
while v != source:
self.e[prevv[v]][preve[v]].cap -= d
self.e[v][self.e[prevv[v]][preve[v]].rev].cap += d
v = prevv[v]
return res
def less(a,b):
for i in range(3):
if b[i]<=a[i]:return False
return True
def main():
while True:
n = int(input())
if n==0:break
a = []
MCF = MinCostFlow(n+n+2)
s = n+n
t = s+1
summ = 0
for i in range(n):
x = list(map(int,input().split()))
x.sort()
a.append(x)
summ+=(x[0]*x[1]*x[2])
for i in range(n):
for j in range(n):
if i == j:continue
if less(a[i],a[j]):
MCF.add_edge(i,j+n,1,-(a[i][0]*a[i][1]*a[i][2]))
for i in range(n):
MCF.add_edge(s,i,1,0)
MCF.add_edge(i+n,t,1,0)
MCF.add_edge(s,t,MCF.inf,0)
print (summ+MCF.compute(s,t,MCF.inf))
if __name__ == '__main__':
main()
```
| 11,597 |
Provide a correct Python 3 solution for this coding contest problem.
Matryoshka
Matryoshka is a famous Russian folk craft doll. Matryoshka can be divided into upper and lower parts, and when opened, there is another smaller doll inside. The nesting structure is such that when the small doll that appears is opened, a smaller doll is contained.
<image>
You found an unusually shaped matryoshka doll on your trip and bought N dolls. The shape of the i-th doll is a rectangular parallelepiped of xi × yi × zi.
After watching Matryoshka for a while, you are about to put away Matryoshka. Before that, I want to reduce the space required by storing some dolls in another. When storing a doll, one other doll can be stored only in the doll that has not yet stored any doll. However, only the dolls that are stored directly are counted, and the doll that contains the doll can be stored in another doll.
The stored doll becomes invisible from the outside. However, the following conditions must be met.
* The doll may rotate, but each side of the rectangular parallelepiped is parallel to any side of the other rectangular parallelepiped.
* After rotation, the length of the doll on the side to be stored is shorter for each of the lengths of the corresponding sides.
* At most one doll can be stored directly in one doll
Since the volume of the closet is limited, we want to minimize the sum of the volumes of the dolls that can be seen from the outside. Your job is to create a program that finds the minimum sum of the volumes of the dolls that are visible from the outside, which can be achieved by repeating the operation of storing the dolls any number of times.
Input
The input consists of multiple datasets. The maximum number of data sets does not exceed 50. Each dataset is represented in the following format.
> N
> x1 y1 z1
>::
>::
> xN yN zN
>
Each dataset consists of N + 1 rows, and the first row of the dataset is given the integer N, which represents the number of dolls. In the i-th line of the following N lines, three integers xi, yi, and zi representing the size of the i-th doll are given, separated by a half-width space. These integers satisfy 1 ≤ N, xi, yi, zi ≤ 100.
> The end of the input is represented by a single zero line.
> ### Output
For each data set, output the minimum value of the sum of the volumes of the dolls that can be seen from the outside in one line.
> ### Sample Input
2
one two Three
4 2 3
3
2 5 2
3 3 4
5 5 5
Five
1 1 1
2 2 2
3 3 3
4 4 4
5 5 5
Five
1 1 1
2 1 1
3 1 1
4 1 1
5 1 1
Ten
3 1 4
1 5 9
2 6 5
3 5 8
9 7 9
3 2 3
8 4 6
2 6 4
3 3 8
3 2 7
0
Output for Sample Input
twenty four
145
125
15
864
Example
Input
2
1 2 3
4 2 3
3
2 5 2
3 3 4
5 5 5
5
1 1 1
2 2 2
3 3 3
4 4 4
5 5 5
5
1 1 1
2 1 1
3 1 1
4 1 1
5 1 1
10
3 1 4
1 5 9
2 6 5
3 5 8
9 7 9
3 2 3
8 4 6
2 6 4
3 3 8
3 2 7
0
Output
24
145
125
15
864
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
from heapq import heappush, heappop
class MinCostFlow:
INF = 10**18
def __init__(self, N):
self.N = N
self.G = [[] for i in range(N)]
def add_edge(self, fr, to, cap, cost):
G = self.G
G[fr].append([to, cap, cost, len(G[to])])
G[to].append([fr, 0, -cost, len(G[fr])-1])
def flow(self, s, t, f):
N = self.N; G = self.G
INF = MinCostFlow.INF
res = 0
H = [0]*N
prv_v = [0]*N
prv_e = [0]*N
while f:
dist = [INF]*N
dist[s] = 0
que = [(0, s)]
while que:
c, v = heappop(que)
if dist[v] < c:
continue
for i, (w, cap, cost, _) in enumerate(G[v]):
if cap > 0 and dist[w] > dist[v] + cost + H[v] - H[w]:
dist[w] = r = dist[v] + cost + H[v] - H[w]
prv_v[w] = v; prv_e[w] = i
heappush(que, (r, w))
if dist[t] == INF:
return -1
for i in range(N):
H[i] += dist[i]
d = f; v = t
while v != s:
d = min(d, G[prv_v[v]][prv_e[v]][1])
v = prv_v[v]
f -= d
res += d * H[t]
v = t
while v != s:
e = G[prv_v[v]][prv_e[v]]
e[1] -= d
G[v][e[3]][1] += d
v = prv_v[v]
return res
def solve():
N = int(readline())
if N == 0:
return False
P = []
for i in range(N):
*p, = map(int, readline().split())
p.sort()
P.append(p)
mcf = MinCostFlow(2*N+2)
P.sort()
su = 0
for i in range(N):
xi, yi, zi = P[i]
for j in range(i):
xj, yj, zj = P[j]
if xi > xj and yi > yj and zi > zj:
mcf.add_edge(2*j+1, 2*i, 1, -xj*yj*zj)
su += xi*yi*zi
mcf.add_edge(2*i, 2*i+1, 1, 0)
mcf.add_edge(2*N, 2*i, 1, 0)
mcf.add_edge(2*i+1, 2*N+1, 1, 0)
ans = su
for i in range(N):
f = mcf.flow(2*N, 2*N+1, 1)
su += f
ans = min(ans, su)
write("%d\n" % ans)
return True
while solve():
...
```
| 11,598 |
Provide a correct Python 3 solution for this coding contest problem.
Cutlet Sandwich
In some worlds, there are $ X $ types of "sandwiches", $ Y $ types of "cutlets", and $ Z $ types of "curry" foods.
There is a $ N $ type of "cutlet sandwich" in this world, and the $ i $ type of cutlet sandwich is made from the $ A_i $ type of sand and the $ B_i $ type of cutlet.
There is also a $ M $ type of "cutlet curry", and the $ i $ type of cutlet curry is made from the $ C_i $ type of cutlet and the $ D_i $ type of curry.
When you have a cutlet sandwich or cutlet curry, you can exchange it for a cutlet sandwich or cutlet curry that shares at least $ 1 $ of the ingredients.
For example, if the $ a $ type sand and the $ b $ type cutlet have the raw cutlet sand, then the $ a $ type sand or any cutlet sand made from the $ b $ type cutlet. Or, you can exchange it for any cutlet curry that contains $ b $ type of cutlet.
Right now, Segtree has a $ S $ kind of cutlet sandwich, but he wants to eat a $ T $ kind of cutlet curry.
Determine if you can get the $ T $ kind of cutlet curry. If possible, ask for the minimum number of replacements to get the desired cutlet curry.
input
Input is given from standard input in the following format.
$ X $ $ Y $ $ Z $ $ N $ $ M $ $ S $ $ T $
$ A_1 $ $ B_1 $
$ A_2 $ $ B_2 $
$ \ ldots $
$ A_N $ $ B_N $
$ C_1 $ $ D_1 $
$ C_2 $ $ D_2 $
$ \ ldots $
$ C_M $ $ D_M $
output
Please output the minimum number of exchanges required to obtain the $ T $ type of cutlet curry. If you can't get it, print "$ -1 $" instead.
However, insert a line break at the end.
Constraint
* $ 1 \ leq X, Y, Z, N, M \ leq 10 ^ 5 $
* $ 1 \ leq S \ leq N $
* $ 1 \ leq T \ leq M $
* $ 1 \ leq A_i \ leq X $
* $ 1 \ leq B_i \ leq Y $
* $ 1 \ leq C_i \ leq Y $
* $ 1 \ leq D_i \ leq Z $
* All inputs are integers.
Input example 1
1 1 1 1 1 1 1
1 1
1 1
Output example 1
1
Input example 2
2 3 4 3 5 1 5
1 1
1 2
twenty two
twenty one
3 1
3 2
3 3
3 4
Output example 2
Four
Input example 3
1 2 2 1 2 1 1
1 2
1 2
twenty one
Output example 3
-1
Example
Input
1 1 1 1 1 1 1
1 1
1 1
Output
1
"Correct Solution:
```
from itertools import *
from bisect import *
from math import *
from collections import *
from heapq import *
from random import *
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def MF(): return map(float, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LF(): return list(map(float, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
dij = [(1, 0), (0, 1), (-1, 0), (0, -1)]
def main():
x,y,z,n,m,s,t=MI()
s,t=s-1,t-1+n
itoab=[]
to1=defaultdict(list)
to2=defaultdict(list)
for i in range(n):
a,b=MI1()
itoab.append([a,b])
to1[a].append(i)
to2[b].append(i)
for i in range(n,n+m):
b,a=MI1()
a+=x
itoab.append([a,b])
to1[a].append(i)
to2[b].append(i)
dist=[-1]*(n+m)
hp=[]
heappush(hp,[0,s])
while hp:
d,i=heappop(hp)
if dist[i]!=-1:continue
dist[i]=d
a,b=itoab[i]
for j in to1[a]:
if j==t:
print(d+1)
exit()
if j==i:continue
if dist[j]!=-1:continue
heappush(hp,[d+1,j])
for j in to2[b]:
if j==t:
print(d+1)
exit()
if j==i:continue
if dist[j]!=-1:continue
heappush(hp,[d+1,j])
print(-1)
main()
```
| 11,599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.