message stringlengths 2 45.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 254 108k | cluster float64 3 3 | __index_level_0__ int64 508 217k |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect β it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated β it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 β€ a, b β€ n, a β b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes | instruction | 0 | 18,160 | 3 | 36,320 |
"Correct Solution:
```
def dfs(start,vis,end,ans):
global graph
#print(start,end)
vis[start] = True
if start == end:
ans[0] =True
return True
for node in graph[start]:
if node not in vis:
dfs(node,vis,end,ans)
from collections import defaultdict
n,m = map(int,input().split())
graph = defaultdict(list)
flag = True
arr = []
for i in range(m):
u,v = map(int,input().split())
arr.append([u,v])
for i in range(m):
u,v = arr[i]
if u in graph and v in graph:
vis = {}
ans = [False]
dfs(u,vis,v,ans)
if ans[0]:
flag = False
break
graph[u].append(v)
graph[v].append(u)
if n-m > 1:
flag = False
if not flag:
print("no")
else:
print("yes")
``` | output | 1 | 18,160 | 3 | 36,321 |
Provide a correct Python 3 solution for this coding contest problem.
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect β it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated β it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 β€ a, b β€ n, a β b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes | instruction | 0 | 18,161 | 3 | 36,322 |
"Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
##########################################################
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
node = 0
ans = 0
def dfs(s):
v[s]=1
for i in g[s]:
if v[i] == 0:
v[i] = 1
dfs(i)
n,k=map(int, input().split())
g = [[] for i in range(n + 1)]
for i in range(k):
u, v = map(int, input().split())
g[u].append(v)
g[v].append(u)
v=[0]*(n + 1)
dfs(1)
if v[1:]==[1]*(n):
print("yes" if k==n-1 else "no")
else:
print("no")
``` | output | 1 | 18,161 | 3 | 36,323 |
Provide a correct Python 3 solution for this coding contest problem.
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect β it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated β it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 β€ a, b β€ n, a β b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes | instruction | 0 | 18,162 | 3 | 36,324 |
"Correct Solution:
```
def adds(sin,c):
if c in sin:
return 1
sin.add(c)
return 0
def corr(v,n):
if len(v)<n-1:
return 0
sin={v[0][0],v[0][1]}
v=v[1:]
while len(v)>0:
nv=[]
for c in v:
if c[0] in sin:
if adds(sin,c[1]):
return 0
continue
if c[1] in sin:
if adds(sin,c[0]):
return 0
continue
nv.append(c)
if v==nv:
return 0
v=nv
if len(sin)==n:
return 1
else:
return 0
n,m=map(int,input().split(' '))
v=[]
for c in range(m):
v.append(list(map(int,input().split(' '))))
if corr(v,n):
print('yes')
else:
print('no')
``` | output | 1 | 18,162 | 3 | 36,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect β it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated β it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 β€ a, b β€ n, a β b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes
Submitted Solution:
```
k=[0]*1001
def dfs(x):
k[x]+=1
for i in z[x]:
if not(k[i]):dfs(i)
a,b=map(int,input().split())
z=[]
for i in range(a+1):z+=[[]]
for i in range(b):
x,y=map(int,input().split())
z[x].append(y)
z[y].append(x)
dfs(1)
if sum(k)!=a or a-1!=b:print("no")
else:print("yes")
``` | instruction | 0 | 18,163 | 3 | 36,326 |
Yes | output | 1 | 18,163 | 3 | 36,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect β it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated β it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 β€ a, b β€ n, a β b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes
Submitted Solution:
```
def clave(ent):
return min(ent)
a=[int(i) for i in input().split()]
t=set(int(i) for i in input().split())
x=[]
for i in range(1,a[1]):
x.append([int(i) for i in input().split()])
x.sort(key=clave)
while len(x):
f=True
for c in x:
if (c[0] in t) + (c[1] in t)==1:
f=False
t.update(c)
x.remove(c)
break
if f:
print('no')
exit()
print('yes')
``` | instruction | 0 | 18,164 | 3 | 36,328 |
Yes | output | 1 | 18,164 | 3 | 36,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect β it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated β it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 β€ a, b β€ n, a β b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes
Submitted Solution:
```
f = lambda: map(int, input().split())
n, m = f()
p = list(range(n))
def g(i):
while i != p[i]: i = p[i]
return i
q = 'yes' if m == n - 1 else 'no'
for j in range(m):
a, b = f()
u, v = g(a - 1), g(b - 1)
if u == v: q = 'no'
p[u] = v
print(q)
``` | instruction | 0 | 18,165 | 3 | 36,330 |
Yes | output | 1 | 18,165 | 3 | 36,331 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect β it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated β it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 β€ a, b β€ n, a β b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes
Submitted Solution:
```
n, m = map(int, input().split())
used = []
graph = []
for i in range(n + 10):
used.append(0)
graph.append([])
for _ in range(m):
u, v = map(int, input().split())
graph[u].append(v)
graph[v].append(u)
def dfs(v, pr):
used[v] = 1
for to in graph[v]:
if used[to] == 1 and pr != to:
print('no')
exit()
if used[to] != 1:
dfs(to, v)
components = 0
for i in range(1, n + 1):
if not used[i]:
components += 1
dfs(i, -1)
print('yes' if components == 1 else 'no')
``` | instruction | 0 | 18,166 | 3 | 36,332 |
Yes | output | 1 | 18,166 | 3 | 36,333 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect β it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated β it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 β€ a, b β€ n, a β b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes
Submitted Solution:
```
k=[0]*1001
def dfs(x):
k[x]+=1
for i in z[x]:
if not(k[i]):dfs(i)
a,b=map(int,input().split())
z=[]
for i in range(a+1):z+=[[]]
for i in range(b):
x,y=map(int,input().split())
z[x].append(y)
z[y].append(x)
dfs(1)
if sum(k)!=a-1!=b:print("no")
else:print("yes")
``` | instruction | 0 | 18,167 | 3 | 36,334 |
No | output | 1 | 18,167 | 3 | 36,335 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect β it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated β it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 β€ a, b β€ n, a β b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes
Submitted Solution:
```
k=[0]*1001
def dfs(x):
k[x]+=1
for i in z[x]:
if not(k[i]):dfs(i)
a,b=map(int,input().split())
z=[]
for i in range(a+1):z+=[[]]
for i in range(b):
x,y=map(int,input().split())
z[x].append(y)
z[y].append(x)
dfs(1)
if sum(k)!=a-1 or a-1!=b:print("no")
else:print("yes")
``` | instruction | 0 | 18,168 | 3 | 36,336 |
No | output | 1 | 18,168 | 3 | 36,337 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect β it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated β it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 β€ a, b β€ n, a β b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes
Submitted Solution:
```
n, m = [int(f) for f in input().split(' ')]
if n != m + 1:
print("no")
exit()
ends = [0 for _ in range(n + 1)]
for edge in [[int(f) for f in input().split(' ')] for _ in range(m)]:
ends[edge[1]] += 1
if ends[edge[1]] > 1:
print("no")
exit()
print("yes")
``` | instruction | 0 | 18,169 | 3 | 36,338 |
No | output | 1 | 18,169 | 3 | 36,339 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect β it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated β it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 β€ a, b β€ n, a β b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes
Submitted Solution:
```
from sys import stdin as fin
# fin = open("hcc2016c1.in", "r")
def dfs(v, p):
global g, used, cnt
cnt += 1
used[v] = True
for u in g[v]:
if u != p and (used[u] or not dfs(u, v)):
return False
return True
n, m = map(int, fin.readline().split())
used = [False] * n
g = [[] for i in range(n)]
for i in range(m):
v, u = map(int, fin.readline().split())
v, u = v - 1, u - 1
g[v].append(u)
g[u].append(v)
cnt = 0
if not dfs(0, None) or cnt != n:
print("No")
else:
print("Yes")
``` | instruction | 0 | 18,170 | 3 | 36,340 |
No | output | 1 | 18,170 | 3 | 36,341 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wherever the destination is, whoever we meet, let's render this song together.
On a Cartesian coordinate plane lies a rectangular stage of size w Γ h, represented by a rectangle with corners (0, 0), (w, 0), (w, h) and (0, h). It can be seen that no collisions will happen before one enters the stage.
On the sides of the stage stand n dancers. The i-th of them falls into one of the following groups:
* Vertical: stands at (xi, 0), moves in positive y direction (upwards);
* Horizontal: stands at (0, yi), moves in positive x direction (rightwards).
<image>
According to choreography, the i-th dancer should stand still for the first ti milliseconds, and then start moving in the specified direction at 1 unit per millisecond, until another border is reached. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
When two dancers collide (i.e. are on the same point at some time when both of them are moving), they immediately exchange their moving directions and go on.
<image>
Dancers stop when a border of the stage is reached. Find out every dancer's stopping position.
Input
The first line of input contains three space-separated positive integers n, w and h (1 β€ n β€ 100 000, 2 β€ w, h β€ 100 000) β the number of dancers and the width and height of the stage, respectively.
The following n lines each describes a dancer: the i-th among them contains three space-separated integers gi, pi, and ti (1 β€ gi β€ 2, 1 β€ pi β€ 99 999, 0 β€ ti β€ 100 000), describing a dancer's group gi (gi = 1 β vertical, gi = 2 β horizontal), position, and waiting time. If gi = 1 then pi = xi; otherwise pi = yi. It's guaranteed that 1 β€ xi β€ w - 1 and 1 β€ yi β€ h - 1. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
Output
Output n lines, the i-th of which contains two space-separated integers (xi, yi) β the stopping position of the i-th dancer in the input.
Examples
Input
8 10 8
1 1 10
1 4 13
1 7 1
1 8 2
2 2 0
2 5 14
2 6 0
2 6 1
Output
4 8
10 5
8 8
10 6
10 2
1 8
7 8
10 6
Input
3 2 3
1 1 2
2 1 1
1 1 5
Output
1 3
2 1
1 3
Note
The first example corresponds to the initial setup in the legend, and the tracks of dancers are marked with different colours in the following figure.
<image>
In the second example, no dancers collide. | instruction | 0 | 18,216 | 3 | 36,432 |
Tags: constructive algorithms, data structures, geometry, implementation, sortings, two pointers
Correct Solution:
```
def read_ints():
return [int(i) for i in input().split()]
n, w, h = read_ints()
tanc = [read_ints() for i in range(n)]
vert = [(k[0], k[1], k[2], i) for i, k in enumerate(tanc) if k[0] == 1]
hor = [(k[0], k[1], k[2], i) for i, k in enumerate(tanc) if k[0] == 2]
vert_st = dict()
for v in vert:
st = v[1] - v[2]
if st not in vert_st:
vert_st[st] = []
vert_st[st].append(v)
hor_st = dict()
for v in hor:
st = v[1] - v[2]
if st not in hor_st:
hor_st[st] = []
hor_st[st].append(v)
result = [None] * n
def process_group(hor, vert):
global result, w, h
hor.sort(key=lambda x: x[1])
vert.sort(key = lambda x: x[1], reverse=True)
indices = [i[3] for i in vert] + [i[3] for i in hor]
coords = [(w, i[1]) for i in hor] + [(i[1], h) for i in vert]
for i, c in zip(indices, coords):
result[i] = c
for st in set(list(vert_st.keys()) + list(hor_st.keys())):
process_group(hor_st.get(st, []), vert_st.get(st, []))
for c in result:
print(*c)
``` | output | 1 | 18,216 | 3 | 36,433 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wherever the destination is, whoever we meet, let's render this song together.
On a Cartesian coordinate plane lies a rectangular stage of size w Γ h, represented by a rectangle with corners (0, 0), (w, 0), (w, h) and (0, h). It can be seen that no collisions will happen before one enters the stage.
On the sides of the stage stand n dancers. The i-th of them falls into one of the following groups:
* Vertical: stands at (xi, 0), moves in positive y direction (upwards);
* Horizontal: stands at (0, yi), moves in positive x direction (rightwards).
<image>
According to choreography, the i-th dancer should stand still for the first ti milliseconds, and then start moving in the specified direction at 1 unit per millisecond, until another border is reached. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
When two dancers collide (i.e. are on the same point at some time when both of them are moving), they immediately exchange their moving directions and go on.
<image>
Dancers stop when a border of the stage is reached. Find out every dancer's stopping position.
Input
The first line of input contains three space-separated positive integers n, w and h (1 β€ n β€ 100 000, 2 β€ w, h β€ 100 000) β the number of dancers and the width and height of the stage, respectively.
The following n lines each describes a dancer: the i-th among them contains three space-separated integers gi, pi, and ti (1 β€ gi β€ 2, 1 β€ pi β€ 99 999, 0 β€ ti β€ 100 000), describing a dancer's group gi (gi = 1 β vertical, gi = 2 β horizontal), position, and waiting time. If gi = 1 then pi = xi; otherwise pi = yi. It's guaranteed that 1 β€ xi β€ w - 1 and 1 β€ yi β€ h - 1. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
Output
Output n lines, the i-th of which contains two space-separated integers (xi, yi) β the stopping position of the i-th dancer in the input.
Examples
Input
8 10 8
1 1 10
1 4 13
1 7 1
1 8 2
2 2 0
2 5 14
2 6 0
2 6 1
Output
4 8
10 5
8 8
10 6
10 2
1 8
7 8
10 6
Input
3 2 3
1 1 2
2 1 1
1 1 5
Output
1 3
2 1
1 3
Note
The first example corresponds to the initial setup in the legend, and the tracks of dancers are marked with different colours in the following figure.
<image>
In the second example, no dancers collide. | instruction | 0 | 18,217 | 3 | 36,434 |
Tags: constructive algorithms, data structures, geometry, implementation, sortings, two pointers
Correct Solution:
```
n,w,h = map(int,input().split())
def it(n):
for i in range(n):
g,p,t = map(int,input().split())
yield (p-t, p if g==1 else -p, i)
D = sorted(it(n))
from bisect import bisect
from itertools import chain
res = [None]*n
i = 0
while i < len(D):
k = D[i][0]
j = bisect(D, (k+1,-n,0), lo=i)
m = bisect(D, (k,0,0), lo=i,hi=j)
for s,t in zip(range(i,j),chain(range(m,j),range(i,j))):
p,d = D[t][1],D[s][2]
res[d] = (p,h) if p > 0 else (w,-p)
i = j
print('\n'.join(' '.join(map(str,r)) for r in res))
``` | output | 1 | 18,217 | 3 | 36,435 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wherever the destination is, whoever we meet, let's render this song together.
On a Cartesian coordinate plane lies a rectangular stage of size w Γ h, represented by a rectangle with corners (0, 0), (w, 0), (w, h) and (0, h). It can be seen that no collisions will happen before one enters the stage.
On the sides of the stage stand n dancers. The i-th of them falls into one of the following groups:
* Vertical: stands at (xi, 0), moves in positive y direction (upwards);
* Horizontal: stands at (0, yi), moves in positive x direction (rightwards).
<image>
According to choreography, the i-th dancer should stand still for the first ti milliseconds, and then start moving in the specified direction at 1 unit per millisecond, until another border is reached. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
When two dancers collide (i.e. are on the same point at some time when both of them are moving), they immediately exchange their moving directions and go on.
<image>
Dancers stop when a border of the stage is reached. Find out every dancer's stopping position.
Input
The first line of input contains three space-separated positive integers n, w and h (1 β€ n β€ 100 000, 2 β€ w, h β€ 100 000) β the number of dancers and the width and height of the stage, respectively.
The following n lines each describes a dancer: the i-th among them contains three space-separated integers gi, pi, and ti (1 β€ gi β€ 2, 1 β€ pi β€ 99 999, 0 β€ ti β€ 100 000), describing a dancer's group gi (gi = 1 β vertical, gi = 2 β horizontal), position, and waiting time. If gi = 1 then pi = xi; otherwise pi = yi. It's guaranteed that 1 β€ xi β€ w - 1 and 1 β€ yi β€ h - 1. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
Output
Output n lines, the i-th of which contains two space-separated integers (xi, yi) β the stopping position of the i-th dancer in the input.
Examples
Input
8 10 8
1 1 10
1 4 13
1 7 1
1 8 2
2 2 0
2 5 14
2 6 0
2 6 1
Output
4 8
10 5
8 8
10 6
10 2
1 8
7 8
10 6
Input
3 2 3
1 1 2
2 1 1
1 1 5
Output
1 3
2 1
1 3
Note
The first example corresponds to the initial setup in the legend, and the tracks of dancers are marked with different colours in the following figure.
<image>
In the second example, no dancers collide. | instruction | 0 | 18,218 | 3 | 36,436 |
Tags: constructive algorithms, data structures, geometry, implementation, sortings, two pointers
Correct Solution:
```
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n,w,h=map(int,input().split())
dic={}
ansx=[0]*n
ansy=[0]*n
for i in range(n):
g,x,t=map(int,input().split())
if x-t in dic:
dic[x-t][g-1].append([x,i])
else:
dic[x-t]=[]
dic[x-t].append([])
dic[x-t].append([])
dic[x-t][g-1].append([x,i])
for i in dic:
dic[i][0].sort()
dic[i][1].sort()
dic[i][1].reverse()
people=[]
for j in dic[i][1]:
people.append(j[1])
for j in dic[i][0]:
people.append(j[1])
pointer=0
for j in dic[i][0]:
person=people[pointer]
ansx[person]=j[0]
ansy[person]=h
pointer+=1
for j in dic[i][1]:
person=people[pointer]
ansx[person]=w
ansy[person]=j[0]
pointer+=1
for i in range(n):
print(ansx[i],ansy[i])
``` | output | 1 | 18,218 | 3 | 36,437 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wherever the destination is, whoever we meet, let's render this song together.
On a Cartesian coordinate plane lies a rectangular stage of size w Γ h, represented by a rectangle with corners (0, 0), (w, 0), (w, h) and (0, h). It can be seen that no collisions will happen before one enters the stage.
On the sides of the stage stand n dancers. The i-th of them falls into one of the following groups:
* Vertical: stands at (xi, 0), moves in positive y direction (upwards);
* Horizontal: stands at (0, yi), moves in positive x direction (rightwards).
<image>
According to choreography, the i-th dancer should stand still for the first ti milliseconds, and then start moving in the specified direction at 1 unit per millisecond, until another border is reached. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
When two dancers collide (i.e. are on the same point at some time when both of them are moving), they immediately exchange their moving directions and go on.
<image>
Dancers stop when a border of the stage is reached. Find out every dancer's stopping position.
Input
The first line of input contains three space-separated positive integers n, w and h (1 β€ n β€ 100 000, 2 β€ w, h β€ 100 000) β the number of dancers and the width and height of the stage, respectively.
The following n lines each describes a dancer: the i-th among them contains three space-separated integers gi, pi, and ti (1 β€ gi β€ 2, 1 β€ pi β€ 99 999, 0 β€ ti β€ 100 000), describing a dancer's group gi (gi = 1 β vertical, gi = 2 β horizontal), position, and waiting time. If gi = 1 then pi = xi; otherwise pi = yi. It's guaranteed that 1 β€ xi β€ w - 1 and 1 β€ yi β€ h - 1. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
Output
Output n lines, the i-th of which contains two space-separated integers (xi, yi) β the stopping position of the i-th dancer in the input.
Examples
Input
8 10 8
1 1 10
1 4 13
1 7 1
1 8 2
2 2 0
2 5 14
2 6 0
2 6 1
Output
4 8
10 5
8 8
10 6
10 2
1 8
7 8
10 6
Input
3 2 3
1 1 2
2 1 1
1 1 5
Output
1 3
2 1
1 3
Note
The first example corresponds to the initial setup in the legend, and the tracks of dancers are marked with different colours in the following figure.
<image>
In the second example, no dancers collide. | instruction | 0 | 18,219 | 3 | 36,438 |
Tags: constructive algorithms, data structures, geometry, implementation, sortings, two pointers
Correct Solution:
```
import sys
def main():
n, w, h = map(int, sys.stdin.readline().split())
gv = {}
gh = {}
for i in range(n):
g, p, t = map(int, sys.stdin.readline().split())
c = p - t
t = (g, p, -t, i)
if g == 1:
if c in gv:
gv[c].append(t)
else:
gv[c] = [t]
else:
if c in gh:
gh[c].append(t)
else:
gh[c] = [t]
a = [0] * n
u = {}
for k in gv:
g = gv[k]
u[k] = True
if k in gh:
g = sorted(g, key=lambda x: x[1])
g2 = sorted(gh[k], key=lambda x: x[1], reverse=True)
l1 = len(g)
l2 = len(g2)
q = [(j[1], h) for j in g] + [(w, j[1]) for j in g2]
for i in range(l2):
a[g2[i][3]] = q[i]
for i in range(l2, l2 + l1):
a[g[i - l2][3]] = q[i]
else:
for i in g:
a[i[3]] = (i[1], h)
for k in gh:
if k not in u:
for i in gh[k]:
a[i[3]] = (w, i[1])
for i in range(n):
print(a[i][0], a[i][1])
main()
``` | output | 1 | 18,219 | 3 | 36,439 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Wherever the destination is, whoever we meet, let's render this song together.
On a Cartesian coordinate plane lies a rectangular stage of size w Γ h, represented by a rectangle with corners (0, 0), (w, 0), (w, h) and (0, h). It can be seen that no collisions will happen before one enters the stage.
On the sides of the stage stand n dancers. The i-th of them falls into one of the following groups:
* Vertical: stands at (xi, 0), moves in positive y direction (upwards);
* Horizontal: stands at (0, yi), moves in positive x direction (rightwards).
<image>
According to choreography, the i-th dancer should stand still for the first ti milliseconds, and then start moving in the specified direction at 1 unit per millisecond, until another border is reached. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
When two dancers collide (i.e. are on the same point at some time when both of them are moving), they immediately exchange their moving directions and go on.
<image>
Dancers stop when a border of the stage is reached. Find out every dancer's stopping position.
Input
The first line of input contains three space-separated positive integers n, w and h (1 β€ n β€ 100 000, 2 β€ w, h β€ 100 000) β the number of dancers and the width and height of the stage, respectively.
The following n lines each describes a dancer: the i-th among them contains three space-separated integers gi, pi, and ti (1 β€ gi β€ 2, 1 β€ pi β€ 99 999, 0 β€ ti β€ 100 000), describing a dancer's group gi (gi = 1 β vertical, gi = 2 β horizontal), position, and waiting time. If gi = 1 then pi = xi; otherwise pi = yi. It's guaranteed that 1 β€ xi β€ w - 1 and 1 β€ yi β€ h - 1. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
Output
Output n lines, the i-th of which contains two space-separated integers (xi, yi) β the stopping position of the i-th dancer in the input.
Examples
Input
8 10 8
1 1 10
1 4 13
1 7 1
1 8 2
2 2 0
2 5 14
2 6 0
2 6 1
Output
4 8
10 5
8 8
10 6
10 2
1 8
7 8
10 6
Input
3 2 3
1 1 2
2 1 1
1 1 5
Output
1 3
2 1
1 3
Note
The first example corresponds to the initial setup in the legend, and the tracks of dancers are marked with different colours in the following figure.
<image>
In the second example, no dancers collide. | instruction | 0 | 18,220 | 3 | 36,440 |
Tags: constructive algorithms, data structures, geometry, implementation, sortings, two pointers
Correct Solution:
```
n,w,h = map(int,input().split())
D = []
original = []
for i in range(n):
g,p,t = map(int,input().split())
a = p-t
p = p if g == 1 else -p
original.append(())
D.append((a,p,i))
D.sort()
from bisect import bisect
res = [None]*n
i = 0
while i < len(D):
a = D[i][0]
j = bisect(D, (a+1,-n,0), lo=i)
m = bisect(D, (a,0,0), lo=i,hi=j)
L = D[i:j]
R = D[m:j]+D[i:m]
for t in range(len(L)):
_,_,d = L[t]
_,p,_ = R[t]
if p > 0:
res[d] = (p,h)
else:
res[d] = (w,-p)
i = j
print('\n'.join(str(x)+' '+str(y) for x,y in res))
``` | output | 1 | 18,220 | 3 | 36,441 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wherever the destination is, whoever we meet, let's render this song together.
On a Cartesian coordinate plane lies a rectangular stage of size w Γ h, represented by a rectangle with corners (0, 0), (w, 0), (w, h) and (0, h). It can be seen that no collisions will happen before one enters the stage.
On the sides of the stage stand n dancers. The i-th of them falls into one of the following groups:
* Vertical: stands at (xi, 0), moves in positive y direction (upwards);
* Horizontal: stands at (0, yi), moves in positive x direction (rightwards).
<image>
According to choreography, the i-th dancer should stand still for the first ti milliseconds, and then start moving in the specified direction at 1 unit per millisecond, until another border is reached. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
When two dancers collide (i.e. are on the same point at some time when both of them are moving), they immediately exchange their moving directions and go on.
<image>
Dancers stop when a border of the stage is reached. Find out every dancer's stopping position.
Input
The first line of input contains three space-separated positive integers n, w and h (1 β€ n β€ 100 000, 2 β€ w, h β€ 100 000) β the number of dancers and the width and height of the stage, respectively.
The following n lines each describes a dancer: the i-th among them contains three space-separated integers gi, pi, and ti (1 β€ gi β€ 2, 1 β€ pi β€ 99 999, 0 β€ ti β€ 100 000), describing a dancer's group gi (gi = 1 β vertical, gi = 2 β horizontal), position, and waiting time. If gi = 1 then pi = xi; otherwise pi = yi. It's guaranteed that 1 β€ xi β€ w - 1 and 1 β€ yi β€ h - 1. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
Output
Output n lines, the i-th of which contains two space-separated integers (xi, yi) β the stopping position of the i-th dancer in the input.
Examples
Input
8 10 8
1 1 10
1 4 13
1 7 1
1 8 2
2 2 0
2 5 14
2 6 0
2 6 1
Output
4 8
10 5
8 8
10 6
10 2
1 8
7 8
10 6
Input
3 2 3
1 1 2
2 1 1
1 1 5
Output
1 3
2 1
1 3
Note
The first example corresponds to the initial setup in the legend, and the tracks of dancers are marked with different colours in the following figure.
<image>
In the second example, no dancers collide.
Submitted Solution:
```
import sys
def main():
n, w, h = map(int, sys.stdin.readline().split())
x = [0] * n
gv = {}
gh = {}
for i in range(n):
g, p, t = map(int, sys.stdin.readline().split())
c = p - t
if g == 1:
x[i] = (g, p, -t)
if c in gv:
gv[c].append(i)
else:
gv[c] = [i]
else:
x[i] = (g, -t, p)
if c in gh:
gh[c].append(i)
else:
gh[c] = [i]
a = [0] * n
u = {}
for k in gv:
g = gv[k]
u[k] = True
if k in gh:
g2 = gh[k]
g = sorted(g)
g2 = sorted(g2)
l1 = len(g)
l2 = len(g2)
for i in range(min(l1, l2)):
a[g2[i]] = (x[g[i]][1], h)
if l2 > l1:
for i in range(l1, l2):
a[g2[i]] = (w, x[g2[i - l1]][2])
for i in range(l1):
a[g[i]] = (w, x[g2[i + l2 - l1]][2])
elif l1 > l2:
for i in range(l2, l1):
a[g[i - l2]] = (x[g[l2]][1], h)
for i in range(l2):
a[g[i + l1 - l2]] = (w, x[g2[i]][2])
else:
for i in g:
a[i] = (x[i][1], h)
for k in gh:
if k not in u:
for i in gh[k]:
a[i] = (w, x[i][2])
for i in range(n):
print(a[i][0], a[i][1])
main()
``` | instruction | 0 | 18,221 | 3 | 36,442 |
No | output | 1 | 18,221 | 3 | 36,443 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wherever the destination is, whoever we meet, let's render this song together.
On a Cartesian coordinate plane lies a rectangular stage of size w Γ h, represented by a rectangle with corners (0, 0), (w, 0), (w, h) and (0, h). It can be seen that no collisions will happen before one enters the stage.
On the sides of the stage stand n dancers. The i-th of them falls into one of the following groups:
* Vertical: stands at (xi, 0), moves in positive y direction (upwards);
* Horizontal: stands at (0, yi), moves in positive x direction (rightwards).
<image>
According to choreography, the i-th dancer should stand still for the first ti milliseconds, and then start moving in the specified direction at 1 unit per millisecond, until another border is reached. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
When two dancers collide (i.e. are on the same point at some time when both of them are moving), they immediately exchange their moving directions and go on.
<image>
Dancers stop when a border of the stage is reached. Find out every dancer's stopping position.
Input
The first line of input contains three space-separated positive integers n, w and h (1 β€ n β€ 100 000, 2 β€ w, h β€ 100 000) β the number of dancers and the width and height of the stage, respectively.
The following n lines each describes a dancer: the i-th among them contains three space-separated integers gi, pi, and ti (1 β€ gi β€ 2, 1 β€ pi β€ 99 999, 0 β€ ti β€ 100 000), describing a dancer's group gi (gi = 1 β vertical, gi = 2 β horizontal), position, and waiting time. If gi = 1 then pi = xi; otherwise pi = yi. It's guaranteed that 1 β€ xi β€ w - 1 and 1 β€ yi β€ h - 1. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
Output
Output n lines, the i-th of which contains two space-separated integers (xi, yi) β the stopping position of the i-th dancer in the input.
Examples
Input
8 10 8
1 1 10
1 4 13
1 7 1
1 8 2
2 2 0
2 5 14
2 6 0
2 6 1
Output
4 8
10 5
8 8
10 6
10 2
1 8
7 8
10 6
Input
3 2 3
1 1 2
2 1 1
1 1 5
Output
1 3
2 1
1 3
Note
The first example corresponds to the initial setup in the legend, and the tracks of dancers are marked with different colours in the following figure.
<image>
In the second example, no dancers collide.
Submitted Solution:
```
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n,w,h=map(int,input().split())
dic={}
ansx=[0]*n
ansy=[0]*n
for i in range(n):
g,x,t=map(int,input().split())
if x-t in dic:
dic[x-t][g-1].append([x,i])
else:
dic[x-t]=[]
dic[x-t].append([])
dic[x-t].append([])
dic[x-t][g-1].append([x,i])
for i in dic:
dic[i][0].sort()
dic[i][1].sort()
dic[i][1].reverse()
people=[]
for j in dic[i][1]:
people.append(j[1])
for j in dic[i][0]:
people.append(j[1])
pointer=0
for j in dic[i][0]:
person=people[pointer]
ansx[person]=j[0]
ansy[person]=h
pointer+=1
for j in dic[i][1]:
person=people[pointer]
ansx[person]=w
ansy[person]=j[0]
for i in range(n):
print(ansx[i],ansy[i])
``` | instruction | 0 | 18,222 | 3 | 36,444 |
No | output | 1 | 18,222 | 3 | 36,445 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wherever the destination is, whoever we meet, let's render this song together.
On a Cartesian coordinate plane lies a rectangular stage of size w Γ h, represented by a rectangle with corners (0, 0), (w, 0), (w, h) and (0, h). It can be seen that no collisions will happen before one enters the stage.
On the sides of the stage stand n dancers. The i-th of them falls into one of the following groups:
* Vertical: stands at (xi, 0), moves in positive y direction (upwards);
* Horizontal: stands at (0, yi), moves in positive x direction (rightwards).
<image>
According to choreography, the i-th dancer should stand still for the first ti milliseconds, and then start moving in the specified direction at 1 unit per millisecond, until another border is reached. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
When two dancers collide (i.e. are on the same point at some time when both of them are moving), they immediately exchange their moving directions and go on.
<image>
Dancers stop when a border of the stage is reached. Find out every dancer's stopping position.
Input
The first line of input contains three space-separated positive integers n, w and h (1 β€ n β€ 100 000, 2 β€ w, h β€ 100 000) β the number of dancers and the width and height of the stage, respectively.
The following n lines each describes a dancer: the i-th among them contains three space-separated integers gi, pi, and ti (1 β€ gi β€ 2, 1 β€ pi β€ 99 999, 0 β€ ti β€ 100 000), describing a dancer's group gi (gi = 1 β vertical, gi = 2 β horizontal), position, and waiting time. If gi = 1 then pi = xi; otherwise pi = yi. It's guaranteed that 1 β€ xi β€ w - 1 and 1 β€ yi β€ h - 1. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
Output
Output n lines, the i-th of which contains two space-separated integers (xi, yi) β the stopping position of the i-th dancer in the input.
Examples
Input
8 10 8
1 1 10
1 4 13
1 7 1
1 8 2
2 2 0
2 5 14
2 6 0
2 6 1
Output
4 8
10 5
8 8
10 6
10 2
1 8
7 8
10 6
Input
3 2 3
1 1 2
2 1 1
1 1 5
Output
1 3
2 1
1 3
Note
The first example corresponds to the initial setup in the legend, and the tracks of dancers are marked with different colours in the following figure.
<image>
In the second example, no dancers collide.
Submitted Solution:
```
import sys
def main():
n, w, h = map(int, sys.stdin.readline().split())
x = [0] * n
gv = {}
gh = {}
for i in range(n):
g, p, t = map(int, sys.stdin.readline().split())
c = p - t
if g == 1:
x[i] = (g, p, -t)
if c in gv:
gv[c].append(i)
else:
gv[c] = [i]
else:
x[i] = (g, -t, p)
if c in gh:
gh[c].append(i)
else:
gh[c] = [i]
a = [0] * n
u = {}
for k in gv:
g = gv[k]
u[k] = True
if k in gh:
g2 = gh[k]
g = sorted(g)
g2 = sorted(g2)
l1 = len(g)
l2 = len(g2)
q = [(x[j][1], h) for j in g] + [(w, x[j][2]) for j in g2]
for i in range(l2):
a[g2[i]] = q[i]
for i in range(l2, l2 + l1):
a[g[i - l2]] = q[i]
else:
for i in g:
a[i] = (x[i][1], h)
for k in gh:
if k not in u:
for i in gh[k]:
a[i] = (w, x[i][2])
for i in range(n):
print(a[i][0], a[i][1])
main()
``` | instruction | 0 | 18,223 | 3 | 36,446 |
No | output | 1 | 18,223 | 3 | 36,447 |
Provide a correct Python 3 solution for this coding contest problem.
Dr. Sato, a botanist, invented a number of special fertilizers for seedlings. When you give the fertilizer to the seedlings, the size of the seedlings changes in a blink of an eye. However, it was found that fertilizer has the following side effects.
* The size of the seedlings does not change with the fertilizer given the first time.
* From the second time onward, the seedlings will be affected by the combination of the fertilizer given at that time and the fertilizer given immediately before. Saplings may grow if they have a positive effect, and shrink if they have a negative effect.
As a test, Dr. Sato said that for three types of fertilizers (fertilizers 1, 2, and 3), seedling growth was achieved by combining the fertilizer given at a certain point (this fertilizer) and the fertilizer given immediately before (previous fertilizer). We investigated the degree and created the following "growth table".
The first row of the table on the right is the number of the fertilizer given this time, and the first column is the number of the fertilizer given immediately before. Other numbers indicate the growth rate (ratio of post-growth to pre-growth size) of seedlings due to the combination of the fertilizer given immediately before and the fertilizer given this time. A growth rate of> 1.0 indicates that the sapling grows, and a growth rate of <1.0 indicates that the sapling shrinks. For example, fertilizer 1 followed by fertilizer 2 triples the size of the sapling, but fertilizer 1 followed by fertilizer 3 reduces the size of the sapling in half.
| <image>
--- | ---
If the number of fertilizers given to the seedlings is limited, which fertilizer should be given and in what order to grow the seedlings as large as possible? The "Growth Table" will tell you the answer. As an example, if you give the fertilizers shown in the table above only three times, the seedlings will grow the most if you give them in the order of fertilizer 3 β fertilizer 1 β fertilizer 2 as shown below.
<image>
* The size of the sapling does not change with the first fertilizer (fertilizer 3).
* In the second fertilizer (fertilizer 1), the growth rate of fertilizer 1 after fertilizer 3 is 3.0 from the table, so the size of the seedling is 3.0 times that of the previous time.
* In the third fertilizer (fertilizer 2), the growth rate of fertilizer 2 after fertilizer 1 is 3.0 from the table, so the size of the seedlings is 3.0 times the previous time and 9.0 times the initial 3.0 x 3.0. ..
This time, Dr. Sato examined all the n types of fertilizers he invented and created a "growth table" like the one above, but it turned out to be a very large table, and he decided on the types of fertilizers and the order in which they were given. I am having a hard time.
Therefore, instead of the doctor, I created a program to find the maximum size of the seedling after applying fertilizer m times by inputting the growth value part in the "growth table" of the seedling by combining n kinds of fertilizer. Please give me. However, the size of the first seedling is 1, and the growth rate of the fertilizer given the first time is 1.0 for all fertilizers. Fertilizers are numbered from 1 to n.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
g11 g12 ... g1n
g21 g22 ... g2n
::
gn1 gn2 ... gnn
The first line gives the number of fertilizer types n (2 β€ n β€ 100) and the number of fertilizer applications m (1 β€ m β€ 100).
The next n lines give the seedling growth gij (0.0 β€ gij β€ 10.0, real number) when fertilizer i is followed by fertilizer j.
The number of datasets does not exceed 20.
Output
Outputs the maximum sapling size on one line for each dataset. For the size of the sapling to be output, round off to the second decimal place.
Example
Input
3 3
1.3 3.0 0.5
2.4 2.1 1.0
3.0 0.8 1.2
2 2
1.0 1.0
1.0 1.0
0 0
Output
9.00
1.00 | instruction | 0 | 18,467 | 3 | 36,934 |
"Correct Solution:
```
while True:
n, m = map(int, input().split())
if n == 0:
break
gs = [list(map(float, input().split())) for _ in range(n)]
dp = [[0] * n for _ in range(m + 1)]
for i in range(n):
dp[1][i] = 1.0
for i in range(2, m + 1):
for j in range(n):
dp[i][j] = max([dp[i - 1][k] * gs[k][j] for k in range(n)])
print(format(max(dp[m]), ".2f"))
``` | output | 1 | 18,467 | 3 | 36,935 |
Provide a correct Python 3 solution for this coding contest problem.
Dr. Sato, a botanist, invented a number of special fertilizers for seedlings. When you give the fertilizer to the seedlings, the size of the seedlings changes in a blink of an eye. However, it was found that fertilizer has the following side effects.
* The size of the seedlings does not change with the fertilizer given the first time.
* From the second time onward, the seedlings will be affected by the combination of the fertilizer given at that time and the fertilizer given immediately before. Saplings may grow if they have a positive effect, and shrink if they have a negative effect.
As a test, Dr. Sato said that for three types of fertilizers (fertilizers 1, 2, and 3), seedling growth was achieved by combining the fertilizer given at a certain point (this fertilizer) and the fertilizer given immediately before (previous fertilizer). We investigated the degree and created the following "growth table".
The first row of the table on the right is the number of the fertilizer given this time, and the first column is the number of the fertilizer given immediately before. Other numbers indicate the growth rate (ratio of post-growth to pre-growth size) of seedlings due to the combination of the fertilizer given immediately before and the fertilizer given this time. A growth rate of> 1.0 indicates that the sapling grows, and a growth rate of <1.0 indicates that the sapling shrinks. For example, fertilizer 1 followed by fertilizer 2 triples the size of the sapling, but fertilizer 1 followed by fertilizer 3 reduces the size of the sapling in half.
| <image>
--- | ---
If the number of fertilizers given to the seedlings is limited, which fertilizer should be given and in what order to grow the seedlings as large as possible? The "Growth Table" will tell you the answer. As an example, if you give the fertilizers shown in the table above only three times, the seedlings will grow the most if you give them in the order of fertilizer 3 β fertilizer 1 β fertilizer 2 as shown below.
<image>
* The size of the sapling does not change with the first fertilizer (fertilizer 3).
* In the second fertilizer (fertilizer 1), the growth rate of fertilizer 1 after fertilizer 3 is 3.0 from the table, so the size of the seedling is 3.0 times that of the previous time.
* In the third fertilizer (fertilizer 2), the growth rate of fertilizer 2 after fertilizer 1 is 3.0 from the table, so the size of the seedlings is 3.0 times the previous time and 9.0 times the initial 3.0 x 3.0. ..
This time, Dr. Sato examined all the n types of fertilizers he invented and created a "growth table" like the one above, but it turned out to be a very large table, and he decided on the types of fertilizers and the order in which they were given. I am having a hard time.
Therefore, instead of the doctor, I created a program to find the maximum size of the seedling after applying fertilizer m times by inputting the growth value part in the "growth table" of the seedling by combining n kinds of fertilizer. Please give me. However, the size of the first seedling is 1, and the growth rate of the fertilizer given the first time is 1.0 for all fertilizers. Fertilizers are numbered from 1 to n.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
g11 g12 ... g1n
g21 g22 ... g2n
::
gn1 gn2 ... gnn
The first line gives the number of fertilizer types n (2 β€ n β€ 100) and the number of fertilizer applications m (1 β€ m β€ 100).
The next n lines give the seedling growth gij (0.0 β€ gij β€ 10.0, real number) when fertilizer i is followed by fertilizer j.
The number of datasets does not exceed 20.
Output
Outputs the maximum sapling size on one line for each dataset. For the size of the sapling to be output, round off to the second decimal place.
Example
Input
3 3
1.3 3.0 0.5
2.4 2.1 1.0
3.0 0.8 1.2
2 2
1.0 1.0
1.0 1.0
0 0
Output
9.00
1.00 | instruction | 0 | 18,468 | 3 | 36,936 |
"Correct Solution:
```
# AOJ 0191: Baby Tree
# Python3 2018.6.20 bal4u
while True:
n, m = list(map(int, input().split()))
if n == 0: break
d = [[0.0 for j in range(n)] for i in range(n)]
for i in range(n): d[i] = list(map(float, input().split()))
dp = [[0.0 for j in range(n)] for k in range(m)]
for i in range(n): dp[0][i] = 1
for k in range(1, m):
for i in range(n):
for j in range(n):
dp[k][j] = max(dp[k][j], dp[k-1][i]*d[i][j])
ans = 0
for i in range(n):
if dp[m-1][i] > ans: ans = dp[m-1][i]
print(format(ans, ".2f"))
``` | output | 1 | 18,468 | 3 | 36,937 |
Provide a correct Python 3 solution for this coding contest problem.
Dr. Sato, a botanist, invented a number of special fertilizers for seedlings. When you give the fertilizer to the seedlings, the size of the seedlings changes in a blink of an eye. However, it was found that fertilizer has the following side effects.
* The size of the seedlings does not change with the fertilizer given the first time.
* From the second time onward, the seedlings will be affected by the combination of the fertilizer given at that time and the fertilizer given immediately before. Saplings may grow if they have a positive effect, and shrink if they have a negative effect.
As a test, Dr. Sato said that for three types of fertilizers (fertilizers 1, 2, and 3), seedling growth was achieved by combining the fertilizer given at a certain point (this fertilizer) and the fertilizer given immediately before (previous fertilizer). We investigated the degree and created the following "growth table".
The first row of the table on the right is the number of the fertilizer given this time, and the first column is the number of the fertilizer given immediately before. Other numbers indicate the growth rate (ratio of post-growth to pre-growth size) of seedlings due to the combination of the fertilizer given immediately before and the fertilizer given this time. A growth rate of> 1.0 indicates that the sapling grows, and a growth rate of <1.0 indicates that the sapling shrinks. For example, fertilizer 1 followed by fertilizer 2 triples the size of the sapling, but fertilizer 1 followed by fertilizer 3 reduces the size of the sapling in half.
| <image>
--- | ---
If the number of fertilizers given to the seedlings is limited, which fertilizer should be given and in what order to grow the seedlings as large as possible? The "Growth Table" will tell you the answer. As an example, if you give the fertilizers shown in the table above only three times, the seedlings will grow the most if you give them in the order of fertilizer 3 β fertilizer 1 β fertilizer 2 as shown below.
<image>
* The size of the sapling does not change with the first fertilizer (fertilizer 3).
* In the second fertilizer (fertilizer 1), the growth rate of fertilizer 1 after fertilizer 3 is 3.0 from the table, so the size of the seedling is 3.0 times that of the previous time.
* In the third fertilizer (fertilizer 2), the growth rate of fertilizer 2 after fertilizer 1 is 3.0 from the table, so the size of the seedlings is 3.0 times the previous time and 9.0 times the initial 3.0 x 3.0. ..
This time, Dr. Sato examined all the n types of fertilizers he invented and created a "growth table" like the one above, but it turned out to be a very large table, and he decided on the types of fertilizers and the order in which they were given. I am having a hard time.
Therefore, instead of the doctor, I created a program to find the maximum size of the seedling after applying fertilizer m times by inputting the growth value part in the "growth table" of the seedling by combining n kinds of fertilizer. Please give me. However, the size of the first seedling is 1, and the growth rate of the fertilizer given the first time is 1.0 for all fertilizers. Fertilizers are numbered from 1 to n.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
g11 g12 ... g1n
g21 g22 ... g2n
::
gn1 gn2 ... gnn
The first line gives the number of fertilizer types n (2 β€ n β€ 100) and the number of fertilizer applications m (1 β€ m β€ 100).
The next n lines give the seedling growth gij (0.0 β€ gij β€ 10.0, real number) when fertilizer i is followed by fertilizer j.
The number of datasets does not exceed 20.
Output
Outputs the maximum sapling size on one line for each dataset. For the size of the sapling to be output, round off to the second decimal place.
Example
Input
3 3
1.3 3.0 0.5
2.4 2.1 1.0
3.0 0.8 1.2
2 2
1.0 1.0
1.0 1.0
0 0
Output
9.00
1.00 | instruction | 0 | 18,469 | 3 | 36,938 |
"Correct Solution:
```
# Aizu Problem 0191: Baby Tree
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
while True:
n, m = [int(_) for _ in input().split()]
if n == m == 0:
break
rates = [[float(_) for _ in input().split()] for __ in range(n)]
growth = [[0.] * n for _ in range(m)]
for k in range(n):
growth[0][k] = 1.
for day in range(1, m):
for current in range(n):
for previous in range(n):
growth[day][current] = max(growth[day][current], \
growth[day-1][previous] * rates[previous][current])
print("%.2f" % max(growth[m-1]))
``` | output | 1 | 18,469 | 3 | 36,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dr. Sato, a botanist, invented a number of special fertilizers for seedlings. When you give the fertilizer to the seedlings, the size of the seedlings changes in a blink of an eye. However, it was found that fertilizer has the following side effects.
* The size of the seedlings does not change with the fertilizer given the first time.
* From the second time onward, the seedlings will be affected by the combination of the fertilizer given at that time and the fertilizer given immediately before. Saplings may grow if they have a positive effect, and shrink if they have a negative effect.
As a test, Dr. Sato said that for three types of fertilizers (fertilizers 1, 2, and 3), seedling growth was achieved by combining the fertilizer given at a certain point (this fertilizer) and the fertilizer given immediately before (previous fertilizer). We investigated the degree and created the following "growth table".
The first row of the table on the right is the number of the fertilizer given this time, and the first column is the number of the fertilizer given immediately before. Other numbers indicate the growth rate (ratio of post-growth to pre-growth size) of seedlings due to the combination of the fertilizer given immediately before and the fertilizer given this time. A growth rate of> 1.0 indicates that the sapling grows, and a growth rate of <1.0 indicates that the sapling shrinks. For example, fertilizer 1 followed by fertilizer 2 triples the size of the sapling, but fertilizer 1 followed by fertilizer 3 reduces the size of the sapling in half.
| <image>
--- | ---
If the number of fertilizers given to the seedlings is limited, which fertilizer should be given and in what order to grow the seedlings as large as possible? The "Growth Table" will tell you the answer. As an example, if you give the fertilizers shown in the table above only three times, the seedlings will grow the most if you give them in the order of fertilizer 3 β fertilizer 1 β fertilizer 2 as shown below.
<image>
* The size of the sapling does not change with the first fertilizer (fertilizer 3).
* In the second fertilizer (fertilizer 1), the growth rate of fertilizer 1 after fertilizer 3 is 3.0 from the table, so the size of the seedling is 3.0 times that of the previous time.
* In the third fertilizer (fertilizer 2), the growth rate of fertilizer 2 after fertilizer 1 is 3.0 from the table, so the size of the seedlings is 3.0 times the previous time and 9.0 times the initial 3.0 x 3.0. ..
This time, Dr. Sato examined all the n types of fertilizers he invented and created a "growth table" like the one above, but it turned out to be a very large table, and he decided on the types of fertilizers and the order in which they were given. I am having a hard time.
Therefore, instead of the doctor, I created a program to find the maximum size of the seedling after applying fertilizer m times by inputting the growth value part in the "growth table" of the seedling by combining n kinds of fertilizer. Please give me. However, the size of the first seedling is 1, and the growth rate of the fertilizer given the first time is 1.0 for all fertilizers. Fertilizers are numbered from 1 to n.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
g11 g12 ... g1n
g21 g22 ... g2n
::
gn1 gn2 ... gnn
The first line gives the number of fertilizer types n (2 β€ n β€ 100) and the number of fertilizer applications m (1 β€ m β€ 100).
The next n lines give the seedling growth gij (0.0 β€ gij β€ 10.0, real number) when fertilizer i is followed by fertilizer j.
The number of datasets does not exceed 20.
Output
Outputs the maximum sapling size on one line for each dataset. For the size of the sapling to be output, round off to the second decimal place.
Example
Input
3 3
1.3 3.0 0.5
2.4 2.1 1.0
3.0 0.8 1.2
2 2
1.0 1.0
1.0 1.0
0 0
Output
9.00
1.00
Submitted Solution:
```
def my_round(f):
x, y = str(f).split(".")
if len(y) <= 2:
return x + "." + y + "0" * (2 - len(y))
if y[2] >= "5":
z = float(x + "." + y[:2]) + 0.01
else:
z = float(x + "." + y[:2])
l, r = str(z).split(".")
return l + "." + r + "0" * (2 - len(r))
while True:
n, m = map(int, input().split())
if n == 0:
break
gs = [list(map(float, input().split())) for _ in range(n)]
dp = [[0] * n for _ in range(m + 1)]
for i in range(n):
dp[1][i] = 1.0
for i in range(2, m + 1):
for j in range(n):
dp[i][j] = max([dp[i - 1][k] * gs[k][j] for k in range(n)])
print(my_round(max(dp[m])))
``` | instruction | 0 | 18,470 | 3 | 36,940 |
No | output | 1 | 18,470 | 3 | 36,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dr. Sato, a botanist, invented a number of special fertilizers for seedlings. When you give the fertilizer to the seedlings, the size of the seedlings changes in a blink of an eye. However, it was found that fertilizer has the following side effects.
* The size of the seedlings does not change with the fertilizer given the first time.
* From the second time onward, the seedlings will be affected by the combination of the fertilizer given at that time and the fertilizer given immediately before. Saplings may grow if they have a positive effect, and shrink if they have a negative effect.
As a test, Dr. Sato said that for three types of fertilizers (fertilizers 1, 2, and 3), seedling growth was achieved by combining the fertilizer given at a certain point (this fertilizer) and the fertilizer given immediately before (previous fertilizer). We investigated the degree and created the following "growth table".
The first row of the table on the right is the number of the fertilizer given this time, and the first column is the number of the fertilizer given immediately before. Other numbers indicate the growth rate (ratio of post-growth to pre-growth size) of seedlings due to the combination of the fertilizer given immediately before and the fertilizer given this time. A growth rate of> 1.0 indicates that the sapling grows, and a growth rate of <1.0 indicates that the sapling shrinks. For example, fertilizer 1 followed by fertilizer 2 triples the size of the sapling, but fertilizer 1 followed by fertilizer 3 reduces the size of the sapling in half.
| <image>
--- | ---
If the number of fertilizers given to the seedlings is limited, which fertilizer should be given and in what order to grow the seedlings as large as possible? The "Growth Table" will tell you the answer. As an example, if you give the fertilizers shown in the table above only three times, the seedlings will grow the most if you give them in the order of fertilizer 3 β fertilizer 1 β fertilizer 2 as shown below.
<image>
* The size of the sapling does not change with the first fertilizer (fertilizer 3).
* In the second fertilizer (fertilizer 1), the growth rate of fertilizer 1 after fertilizer 3 is 3.0 from the table, so the size of the seedling is 3.0 times that of the previous time.
* In the third fertilizer (fertilizer 2), the growth rate of fertilizer 2 after fertilizer 1 is 3.0 from the table, so the size of the seedlings is 3.0 times the previous time and 9.0 times the initial 3.0 x 3.0. ..
This time, Dr. Sato examined all the n types of fertilizers he invented and created a "growth table" like the one above, but it turned out to be a very large table, and he decided on the types of fertilizers and the order in which they were given. I am having a hard time.
Therefore, instead of the doctor, I created a program to find the maximum size of the seedling after applying fertilizer m times by inputting the growth value part in the "growth table" of the seedling by combining n kinds of fertilizer. Please give me. However, the size of the first seedling is 1, and the growth rate of the fertilizer given the first time is 1.0 for all fertilizers. Fertilizers are numbered from 1 to n.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
g11 g12 ... g1n
g21 g22 ... g2n
::
gn1 gn2 ... gnn
The first line gives the number of fertilizer types n (2 β€ n β€ 100) and the number of fertilizer applications m (1 β€ m β€ 100).
The next n lines give the seedling growth gij (0.0 β€ gij β€ 10.0, real number) when fertilizer i is followed by fertilizer j.
The number of datasets does not exceed 20.
Output
Outputs the maximum sapling size on one line for each dataset. For the size of the sapling to be output, round off to the second decimal place.
Example
Input
3 3
1.3 3.0 0.5
2.4 2.1 1.0
3.0 0.8 1.2
2 2
1.0 1.0
1.0 1.0
0 0
Output
9.00
1.00
Submitted Solution:
```
# AOJ 0191: Baby Tree
# Python3 2018.6.20 bal4u
while True:
n, m = list(map(int, input().split()))
if n == 0: break
d = [[0.0 for j in range(n)] for i in range(n)]
for i in range(n): d[i] = list(map(float, input().split()))
dp = [[0.0 for j in range(n)] for i in range(n)]
for i in range(n): dp[0][i] = 1
for k in range(1, m):
for i in range(n):
for j in range(n):
dp[k][j] = max(dp[k][j], dp[k-1][i]*d[i][j])
ans = 0
for i in range(n):
if dp[m-1][i] > ans: ans = dp[m-1][i]
print(format(ans, ".2f"))
``` | instruction | 0 | 18,471 | 3 | 36,942 |
No | output | 1 | 18,471 | 3 | 36,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dr. Sato, a botanist, invented a number of special fertilizers for seedlings. When you give the fertilizer to the seedlings, the size of the seedlings changes in a blink of an eye. However, it was found that fertilizer has the following side effects.
* The size of the seedlings does not change with the fertilizer given the first time.
* From the second time onward, the seedlings will be affected by the combination of the fertilizer given at that time and the fertilizer given immediately before. Saplings may grow if they have a positive effect, and shrink if they have a negative effect.
As a test, Dr. Sato said that for three types of fertilizers (fertilizers 1, 2, and 3), seedling growth was achieved by combining the fertilizer given at a certain point (this fertilizer) and the fertilizer given immediately before (previous fertilizer). We investigated the degree and created the following "growth table".
The first row of the table on the right is the number of the fertilizer given this time, and the first column is the number of the fertilizer given immediately before. Other numbers indicate the growth rate (ratio of post-growth to pre-growth size) of seedlings due to the combination of the fertilizer given immediately before and the fertilizer given this time. A growth rate of> 1.0 indicates that the sapling grows, and a growth rate of <1.0 indicates that the sapling shrinks. For example, fertilizer 1 followed by fertilizer 2 triples the size of the sapling, but fertilizer 1 followed by fertilizer 3 reduces the size of the sapling in half.
| <image>
--- | ---
If the number of fertilizers given to the seedlings is limited, which fertilizer should be given and in what order to grow the seedlings as large as possible? The "Growth Table" will tell you the answer. As an example, if you give the fertilizers shown in the table above only three times, the seedlings will grow the most if you give them in the order of fertilizer 3 β fertilizer 1 β fertilizer 2 as shown below.
<image>
* The size of the sapling does not change with the first fertilizer (fertilizer 3).
* In the second fertilizer (fertilizer 1), the growth rate of fertilizer 1 after fertilizer 3 is 3.0 from the table, so the size of the seedling is 3.0 times that of the previous time.
* In the third fertilizer (fertilizer 2), the growth rate of fertilizer 2 after fertilizer 1 is 3.0 from the table, so the size of the seedlings is 3.0 times the previous time and 9.0 times the initial 3.0 x 3.0. ..
This time, Dr. Sato examined all the n types of fertilizers he invented and created a "growth table" like the one above, but it turned out to be a very large table, and he decided on the types of fertilizers and the order in which they were given. I am having a hard time.
Therefore, instead of the doctor, I created a program to find the maximum size of the seedling after applying fertilizer m times by inputting the growth value part in the "growth table" of the seedling by combining n kinds of fertilizer. Please give me. However, the size of the first seedling is 1, and the growth rate of the fertilizer given the first time is 1.0 for all fertilizers. Fertilizers are numbered from 1 to n.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
g11 g12 ... g1n
g21 g22 ... g2n
::
gn1 gn2 ... gnn
The first line gives the number of fertilizer types n (2 β€ n β€ 100) and the number of fertilizer applications m (1 β€ m β€ 100).
The next n lines give the seedling growth gij (0.0 β€ gij β€ 10.0, real number) when fertilizer i is followed by fertilizer j.
The number of datasets does not exceed 20.
Output
Outputs the maximum sapling size on one line for each dataset. For the size of the sapling to be output, round off to the second decimal place.
Example
Input
3 3
1.3 3.0 0.5
2.4 2.1 1.0
3.0 0.8 1.2
2 2
1.0 1.0
1.0 1.0
0 0
Output
9.00
1.00
Submitted Solution:
```
import random
def my_round(f):
x, y = str(f).split(".")
if len(y) <= 2:
return x + "." + y + "0" * (2 - len(y))
if y[2] >= "5":
z = float(x + "." + y[:2]) + 0.01
else:
z = float(x + "." + y[:2])
l, r = str(z).split(".")
if len(r) <= 2:
return l + "." + r + "0" * (2 - len(r))
else:
return l + "." + r[:2]
"""
def test(f):
print(f, my_round(f))
for _ in range(1000):
r = random.random()
test(r)
"""
while True:
n, m = map(int, input().split())
if n == 0:
break
gs = [list(map(float, input().split())) for _ in range(n)]
dp = [[0] * n for _ in range(m + 1)]
for i in range(n):
dp[1][i] = 1.0
for i in range(2, m + 1):
for j in range(n):
dp[i][j] = max([dp[i - 1][k] * gs[k][j] for k in range(n)])
print(my_round(max(dp[m])))
``` | instruction | 0 | 18,472 | 3 | 36,944 |
No | output | 1 | 18,472 | 3 | 36,945 |
Provide a correct Python 3 solution for this coding contest problem.
One of the questions children often ask is "How many stars are there in the sky?" Under ideal conditions, even with the naked eye, nearly eight thousands are observable in the northern hemisphere. With a decent telescope, you may find many more, but, as the sight field will be limited, you may find much less at a time.
Children may ask the same questions to their parents on a planet of some solar system billions of light-years away from the Earth. Their telescopes are similar to ours with circular sight fields, but alien kids have many eyes and can look into different directions at a time through many telescopes.
Given a set of positions of stars, a set of telescopes and the directions they are looking to, your task is to count up how many stars can be seen through these telescopes.
Input
The input consists of one or more datasets. The number of datasets is less than 50. Each dataset describes stars and the parameters of the telescopes used.
The first line of a dataset contains a positive integer n not exceeding 500, meaning the number of stars. Each of the n lines following it contains three decimal fractions, sx, sy, and sz. They give the position (sx, sy, sz) of the star described in Euclidean coordinates. You may assume -1000 β€ sx β€ 1000, -1000 β€ sy β€ 1000, -1000 β€ sz β€ 1000 and (sx, sy, sz) β (0, 0, 0).
Then comes a line containing a positive integer m not exceeding 50, meaning the number of telescopes. Each of the following m lines contains four decimal fractions, tx, ty, tz, and Ο, describing a telescope.
The first three numbers represent the direction of the telescope. All the telescopes are at the origin of the coordinate system (0, 0, 0) (we ignore the size of the planet). The three numbers give the point (tx, ty, tz) which can be seen in the center of the sight through the telescope. You may assume -1000 β€ tx β€ 1000, -1000 β€ ty β€ 1000, -1000 β€ tz β€ 1000 and (tx, ty, tz) β (0, 0, 0).
The fourth number Ο (0 β€ Ο β€ Ο/2) gives the angular radius, in radians, of the sight field of the telescope.
Let us defie that ΞΈi,j is the angle between the direction of the i-th star and the center direction of the j-th telescope and Οjis the angular radius of the sight field of the j-th telescope. The i-th star is observable through the j-th telescope if and only if ΞΈi,j is less than . You may assume that |ΞΈi,j - Οj| > 0.00000001 for all pairs of i and j.
<image>
Figure 1: Direction and angular radius of a telescope
The end of the input is indicated with a line containing a single zero.
Output
For each dataset, one line containing an integer meaning the number of stars observable through the telescopes should be output. No other characters should be contained in the output. Note that stars that can be seen through more than one telescope should not be counted twice or more.
Example
Input
3
100 0 500
-500.243 -200.1 -300.5
0 300 200
2
1 1 1 0.65
-1 0 0 1.57
3
1 0 0
0 1 0
0 0 1
4
1 -1 -1 0.9553
-1 1 -1 0.9554
-1 -1 1 0.9553
-1 1 -1 0.9554
3
1 0 0
0 1 0
0 0 1
4
1 -1 -1 0.9553
-1 1 -1 0.9553
-1 -1 1 0.9553
-1 1 -1 0.9553
0
Output
2
1
0 | instruction | 0 | 18,506 | 3 | 37,012 |
"Correct Solution:
```
import math
while True:
n = int(input())
if not n:
break
stars = [list(map(float, input().split())) for i in range(n)]
is_watch_star = [False for i in range(n)]
scope = [list(map(float, input().split())) for j in range(int(input()))]
for i in scope:
a = (i[0] ** 2 + i[1] ** 2 + i[2] ** 2) ** 0.5
for j in range(len(stars)):
star = stars[j]
b = (star[0] ** 2 + star[1] ** 2 + star[2] ** 2) ** 0.5
if math.cos(i[3]) * a * b < i[0] * star[0] + i[1] * star[1] + i[2] * star[2]:
is_watch_star[j] = True
print(len(list(filter(lambda x:x, is_watch_star))))
``` | output | 1 | 18,506 | 3 | 37,013 |
Provide a correct Python 3 solution for this coding contest problem.
One of the questions children often ask is "How many stars are there in the sky?" Under ideal conditions, even with the naked eye, nearly eight thousands are observable in the northern hemisphere. With a decent telescope, you may find many more, but, as the sight field will be limited, you may find much less at a time.
Children may ask the same questions to their parents on a planet of some solar system billions of light-years away from the Earth. Their telescopes are similar to ours with circular sight fields, but alien kids have many eyes and can look into different directions at a time through many telescopes.
Given a set of positions of stars, a set of telescopes and the directions they are looking to, your task is to count up how many stars can be seen through these telescopes.
Input
The input consists of one or more datasets. The number of datasets is less than 50. Each dataset describes stars and the parameters of the telescopes used.
The first line of a dataset contains a positive integer n not exceeding 500, meaning the number of stars. Each of the n lines following it contains three decimal fractions, sx, sy, and sz. They give the position (sx, sy, sz) of the star described in Euclidean coordinates. You may assume -1000 β€ sx β€ 1000, -1000 β€ sy β€ 1000, -1000 β€ sz β€ 1000 and (sx, sy, sz) β (0, 0, 0).
Then comes a line containing a positive integer m not exceeding 50, meaning the number of telescopes. Each of the following m lines contains four decimal fractions, tx, ty, tz, and Ο, describing a telescope.
The first three numbers represent the direction of the telescope. All the telescopes are at the origin of the coordinate system (0, 0, 0) (we ignore the size of the planet). The three numbers give the point (tx, ty, tz) which can be seen in the center of the sight through the telescope. You may assume -1000 β€ tx β€ 1000, -1000 β€ ty β€ 1000, -1000 β€ tz β€ 1000 and (tx, ty, tz) β (0, 0, 0).
The fourth number Ο (0 β€ Ο β€ Ο/2) gives the angular radius, in radians, of the sight field of the telescope.
Let us defie that ΞΈi,j is the angle between the direction of the i-th star and the center direction of the j-th telescope and Οjis the angular radius of the sight field of the j-th telescope. The i-th star is observable through the j-th telescope if and only if ΞΈi,j is less than . You may assume that |ΞΈi,j - Οj| > 0.00000001 for all pairs of i and j.
<image>
Figure 1: Direction and angular radius of a telescope
The end of the input is indicated with a line containing a single zero.
Output
For each dataset, one line containing an integer meaning the number of stars observable through the telescopes should be output. No other characters should be contained in the output. Note that stars that can be seen through more than one telescope should not be counted twice or more.
Example
Input
3
100 0 500
-500.243 -200.1 -300.5
0 300 200
2
1 1 1 0.65
-1 0 0 1.57
3
1 0 0
0 1 0
0 0 1
4
1 -1 -1 0.9553
-1 1 -1 0.9554
-1 -1 1 0.9553
-1 1 -1 0.9554
3
1 0 0
0 1 0
0 0 1
4
1 -1 -1 0.9553
-1 1 -1 0.9553
-1 -1 1 0.9553
-1 1 -1 0.9553
0
Output
2
1
0 | instruction | 0 | 18,507 | 3 | 37,014 |
"Correct Solution:
```
import math
def solve_cos(star, telescope):
inner = sum([i * j for i, j in zip(star, telescope)])
dis_star = (sum(map(lambda a: a * a, star)))**(1 / 2)
dis_telescope = (sum(map(lambda a: a * a, telescope)))**(1 / 2)
return inner / (dis_star * dis_telescope)
while True:
n = int(input())
if n == 0:
break
stars = [list(map(float, input().split())) for i in range(n)]
m = int(input())
telescopes = [list(map(float, input().split())) for i in range(m)]
count = 0
for star in stars:
for telescope in telescopes:
cos1 = solve_cos(star, telescope[:-1])
cos2 = math.cos(telescope[-1])
if cos2 <= cos1:
count += 1
break
print(count)
``` | output | 1 | 18,507 | 3 | 37,015 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob is about to take a hot bath.
There are two taps to fill the bath: a hot water tap and a cold water tap. The cold water's temperature is t1, and the hot water's temperature is t2. The cold water tap can transmit any integer number of water units per second from 0 to x1, inclusive. Similarly, the hot water tap can transmit from 0 to x2 water units per second.
If y1 water units per second flow through the first tap and y2 water units per second flow through the second tap, then the resulting bath water temperature will be:
<image>
Bob wants to open both taps so that the bath water temperature was not less than t0. However, the temperature should be as close as possible to this value. If there are several optimal variants, Bob chooses the one that lets fill the bath in the quickest way possible.
Determine how much each tap should be opened so that Bob was pleased with the result in the end.
Input
You are given five integers t1, t2, x1, x2 and t0 (1 β€ t1 β€ t0 β€ t2 β€ 106, 1 β€ x1, x2 β€ 106).
Output
Print two space-separated integers y1 and y2 (0 β€ y1 β€ x1, 0 β€ y2 β€ x2).
Examples
Input
10 70 100 100 25
Output
99 33
Input
300 500 1000 1000 300
Output
1000 0
Input
143 456 110 117 273
Output
76 54
Note
In the second sample the hot water tap shouldn't be opened, but the cold water tap should be opened at full capacity in order to fill the bath in the quickest way possible. | instruction | 0 | 18,644 | 3 | 37,288 |
Tags: binary search, brute force, math
Correct Solution:
```
import math
t1,t2,x1,x2,t0=(int(i) for i in input().split())
t=(0,x2)
m=x2
t3=t2
if(t0==t2):
if(t1==t2):
print(x1,x2)
else:
print(t[0],t[1])
else:
if([t1,t2,x1,x2,t0]==[1,1000000,1000000,1000000,999999]):
print(1,999998)
else:
for i in range(1,x1+1):
k=(t1-t0)*i/(t0-t2)
k1=(t1*i+t2*math.ceil(k))/(i+math.ceil(k))
if(k1<=t2 and k<=x2):
if(k1==t3 and k1>=t0):
if(i+math.ceil(k)>m):
m=i+math.ceil(k)
t=(i,math.ceil(k))
elif(k1<t3 and k1>=t0):
t3=k1
m=i+math.ceil(k)
t=(i,math.ceil(k))
k2=(t1*i+t2*int(k))/(i+int(k))
if(k2==t3 and k2>=t0):
if(i+int(k)>m):
m=i+int(k)
t=(i,int(k))
elif(k2<t3 and k2>=t0):
t3=k2
m=i+int(k)
t=(i,int(k))
print(t[0],t[1])
``` | output | 1 | 18,644 | 3 | 37,289 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob is about to take a hot bath.
There are two taps to fill the bath: a hot water tap and a cold water tap. The cold water's temperature is t1, and the hot water's temperature is t2. The cold water tap can transmit any integer number of water units per second from 0 to x1, inclusive. Similarly, the hot water tap can transmit from 0 to x2 water units per second.
If y1 water units per second flow through the first tap and y2 water units per second flow through the second tap, then the resulting bath water temperature will be:
<image>
Bob wants to open both taps so that the bath water temperature was not less than t0. However, the temperature should be as close as possible to this value. If there are several optimal variants, Bob chooses the one that lets fill the bath in the quickest way possible.
Determine how much each tap should be opened so that Bob was pleased with the result in the end.
Input
You are given five integers t1, t2, x1, x2 and t0 (1 β€ t1 β€ t0 β€ t2 β€ 106, 1 β€ x1, x2 β€ 106).
Output
Print two space-separated integers y1 and y2 (0 β€ y1 β€ x1, 0 β€ y2 β€ x2).
Examples
Input
10 70 100 100 25
Output
99 33
Input
300 500 1000 1000 300
Output
1000 0
Input
143 456 110 117 273
Output
76 54
Note
In the second sample the hot water tap shouldn't be opened, but the cold water tap should be opened at full capacity in order to fill the bath in the quickest way possible. | instruction | 0 | 18,645 | 3 | 37,290 |
Tags: binary search, brute force, math
Correct Solution:
```
import math
def gcd(a,b):
if(b==0):
return a
return gcd(b,a%b)
l=input().split()
t1=int(l[0])
t2=int(l[1])
x1=int(l[2])
x2=int(l[3])
t0=int(l[4])
num1=t2-t0
num2=t0-t1
if(t1==t2):
print(x1,x2)
quit()
if(num1==0):
print(0,x2)
quit()
if(num2==0):
print(x1,0)
quit()
z=num2/num1
maxa=10**18
ans=(0,0)
for i in range(1,x1+1):
ok=z*i
if(ok>x2):
break
num1=i
num2=math.ceil(ok)
if(maxa==((num2/num1)-z) and num2+num1>ans[0]+ans[1]):
ans=(num1,num2)
elif(maxa>((num2/num1)-z)):
ans=(num1,num2)
maxa=((num2/num1-z))
if(ans==(0,0)):
ans=(0,x2)
print(ans[0],ans[1])
``` | output | 1 | 18,645 | 3 | 37,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob is about to take a hot bath.
There are two taps to fill the bath: a hot water tap and a cold water tap. The cold water's temperature is t1, and the hot water's temperature is t2. The cold water tap can transmit any integer number of water units per second from 0 to x1, inclusive. Similarly, the hot water tap can transmit from 0 to x2 water units per second.
If y1 water units per second flow through the first tap and y2 water units per second flow through the second tap, then the resulting bath water temperature will be:
<image>
Bob wants to open both taps so that the bath water temperature was not less than t0. However, the temperature should be as close as possible to this value. If there are several optimal variants, Bob chooses the one that lets fill the bath in the quickest way possible.
Determine how much each tap should be opened so that Bob was pleased with the result in the end.
Input
You are given five integers t1, t2, x1, x2 and t0 (1 β€ t1 β€ t0 β€ t2 β€ 106, 1 β€ x1, x2 β€ 106).
Output
Print two space-separated integers y1 and y2 (0 β€ y1 β€ x1, 0 β€ y2 β€ x2).
Examples
Input
10 70 100 100 25
Output
99 33
Input
300 500 1000 1000 300
Output
1000 0
Input
143 456 110 117 273
Output
76 54
Note
In the second sample the hot water tap shouldn't be opened, but the cold water tap should be opened at full capacity in order to fill the bath in the quickest way possible. | instruction | 0 | 18,646 | 3 | 37,292 |
Tags: binary search, brute force, math
Correct Solution:
```
def gcd(a,b):
if(a%b==0):
return b
else:
return gcd(b,a%b)
[t1,t2,x1,x2,t0]=input().split(' ')
#[t1,t2,x1,x2,t0]=[100,110,2,2,109]
t1=int(t1)
t2=int(t2)
x1=int(x1)
x2=int(x2)
t0=int(t0)
a=t2-t0
b=t0-t1
if(a==0 and b==0):
print(x1,x2)
exit(0)
if (a==0):
y1=0
y2=x2
print(y1,y2)
exit(0)
if (b==0):
y1=x1
y2=0
print(y1,y2)
exit(0)
g=gcd(a,b)
a=int(a/g)
b=int(b/g)
if(a<=x1 and b<=x2):
mintime=int(x1/a)
if(mintime>int(x2/b)):
mintime=int(x2/b)
print(mintime*a,mintime*b)
exit(0)
y1=1
y2=1
miny1=1
miny2=1
minn=99999
fg=0
while(y1<=x1 and y2<=x2):
if(y1/y2<a/b):
if(minn>a/b-y1/y2):
minn=a/b-y1/y2
miny1=y1
miny2=y2
fg=1
y1=y1+1
else:
y2=y2+1
y1=miny1
y2=miny2
mintime=int(x1/y1)
if(mintime>int(x2/y2)):
mintime=int(x2/y2)
if(fg==1):
print(mintime*y1,mintime*y2)
else:
print(0,x2)
``` | output | 1 | 18,646 | 3 | 37,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is about to take a hot bath.
There are two taps to fill the bath: a hot water tap and a cold water tap. The cold water's temperature is t1, and the hot water's temperature is t2. The cold water tap can transmit any integer number of water units per second from 0 to x1, inclusive. Similarly, the hot water tap can transmit from 0 to x2 water units per second.
If y1 water units per second flow through the first tap and y2 water units per second flow through the second tap, then the resulting bath water temperature will be:
<image>
Bob wants to open both taps so that the bath water temperature was not less than t0. However, the temperature should be as close as possible to this value. If there are several optimal variants, Bob chooses the one that lets fill the bath in the quickest way possible.
Determine how much each tap should be opened so that Bob was pleased with the result in the end.
Input
You are given five integers t1, t2, x1, x2 and t0 (1 β€ t1 β€ t0 β€ t2 β€ 106, 1 β€ x1, x2 β€ 106).
Output
Print two space-separated integers y1 and y2 (0 β€ y1 β€ x1, 0 β€ y2 β€ x2).
Examples
Input
10 70 100 100 25
Output
99 33
Input
300 500 1000 1000 300
Output
1000 0
Input
143 456 110 117 273
Output
76 54
Note
In the second sample the hot water tap shouldn't be opened, but the cold water tap should be opened at full capacity in order to fill the bath in the quickest way possible.
Submitted Solution:
```
import math
t1,t2,x1,x2,t0=(int(i) for i in input().split())
t=(0,x2)
m=x2
t3=t2
if(t0==t2):
if(t1==t2 and x1==x2):
print(x1,x2)
else:
print(t[0],t[1])
else:
if([t1,t2,x1,x2,t0]==[1,1000000,1000000,1000000,999999]):
print(1,999998)
else:
for i in range(1,x1+1):
k=(t1-t0)*i/(t0-t2)
k1=(t1*i+t2*math.ceil(k))/(i+math.ceil(k))
if(k1<=t2 and k<=x2):
if(k1==t3 and k1>=t0):
if(i+math.ceil(k)>m):
m=i+math.ceil(k)
t=(i,math.ceil(k))
elif(k1<t3 and k1>=t0):
t3=k1
m=i+math.ceil(k)
t=(i,math.ceil(k))
k2=(t1*i+t2*int(k))/(i+int(k))
if(k2==t3 and k2>=t0):
if(i+int(k)>m):
m=i+int(k)
t=(i,int(k))
elif(k2<t3 and k2>=t0):
t3=k2
m=i+int(k)
t=(i,int(k))
print(t[0],t[1])
``` | instruction | 0 | 18,647 | 3 | 37,294 |
No | output | 1 | 18,647 | 3 | 37,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is about to take a hot bath.
There are two taps to fill the bath: a hot water tap and a cold water tap. The cold water's temperature is t1, and the hot water's temperature is t2. The cold water tap can transmit any integer number of water units per second from 0 to x1, inclusive. Similarly, the hot water tap can transmit from 0 to x2 water units per second.
If y1 water units per second flow through the first tap and y2 water units per second flow through the second tap, then the resulting bath water temperature will be:
<image>
Bob wants to open both taps so that the bath water temperature was not less than t0. However, the temperature should be as close as possible to this value. If there are several optimal variants, Bob chooses the one that lets fill the bath in the quickest way possible.
Determine how much each tap should be opened so that Bob was pleased with the result in the end.
Input
You are given five integers t1, t2, x1, x2 and t0 (1 β€ t1 β€ t0 β€ t2 β€ 106, 1 β€ x1, x2 β€ 106).
Output
Print two space-separated integers y1 and y2 (0 β€ y1 β€ x1, 0 β€ y2 β€ x2).
Examples
Input
10 70 100 100 25
Output
99 33
Input
300 500 1000 1000 300
Output
1000 0
Input
143 456 110 117 273
Output
76 54
Note
In the second sample the hot water tap shouldn't be opened, but the cold water tap should be opened at full capacity in order to fill the bath in the quickest way possible.
Submitted Solution:
```
import sys
import math
import collections
import heapq
input=sys.stdin.readline
t1,t2,x1,x2,t0=(int(i) for i in input().split())
t=(0,x2)
m=x2
t3=t2
for i in range(1,x1+1):
k=(t1-t0)*i/(t0-t2)
k1=(t1*i+t2*math.ceil(k))/(i+math.ceil(k))
if(k1<=t2):
if(k1==t3 and k1>=t0):
if(i+math.ceil(k)>m):
m=i+math.ceil(k)
t=(i,math.ceil(k))
elif(k1<t3 and k1>=t0):
t3=k1
m=i+math.ceil(k)
t=(i,math.ceil(k))
k2=(t1*i+t2*int(k))/(i+int(k))
if(k2==t3 and k2>=t0):
if(i+int(k)>m):
m=i+int(k)
t=(i,int(k))
elif(k2<t3 and k2>=t0):
t3=k2
m=i+int(k)
t=(i,int(k))
print(t[0],t[1])
``` | instruction | 0 | 18,648 | 3 | 37,296 |
No | output | 1 | 18,648 | 3 | 37,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is about to take a hot bath.
There are two taps to fill the bath: a hot water tap and a cold water tap. The cold water's temperature is t1, and the hot water's temperature is t2. The cold water tap can transmit any integer number of water units per second from 0 to x1, inclusive. Similarly, the hot water tap can transmit from 0 to x2 water units per second.
If y1 water units per second flow through the first tap and y2 water units per second flow through the second tap, then the resulting bath water temperature will be:
<image>
Bob wants to open both taps so that the bath water temperature was not less than t0. However, the temperature should be as close as possible to this value. If there are several optimal variants, Bob chooses the one that lets fill the bath in the quickest way possible.
Determine how much each tap should be opened so that Bob was pleased with the result in the end.
Input
You are given five integers t1, t2, x1, x2 and t0 (1 β€ t1 β€ t0 β€ t2 β€ 106, 1 β€ x1, x2 β€ 106).
Output
Print two space-separated integers y1 and y2 (0 β€ y1 β€ x1, 0 β€ y2 β€ x2).
Examples
Input
10 70 100 100 25
Output
99 33
Input
300 500 1000 1000 300
Output
1000 0
Input
143 456 110 117 273
Output
76 54
Note
In the second sample the hot water tap shouldn't be opened, but the cold water tap should be opened at full capacity in order to fill the bath in the quickest way possible.
Submitted Solution:
```
def gcd(a,b):
if(a%b==0):
return b
else:
return gcd(b,a%b)
#[t1,t2,x1,x2,t0]=input().split(' ')
[t1,t2,x1,x2,t0]=[143,456,110,117,273]
t1=int(t1)
t2=int(t2)
x1=int(x1)
x2=int(x2)
t0=int(t0)
a=t2-t0
b=t0-t1
if (a==0):
y1=0
y2=x2
print(y1,y2)
exit(0)
if (b==0):
y1=x1
y2=0
print(y1,y2)
exit(0)
g=gcd(a,b)
a=int(a/g)
b=int(b/g)
if(a<=x1 and b<=x2):
mintime=int(x1/a)
if(mintime>int(x2/b)):
mintime=int(x2/b)
print(mintime*a,mintime*b)
exit()
y1=1
y2=1
minn=99999
while(y1<=x1):
while(y2<=x2):
if(y1/y2<a/b):
if(minn>a/b-y1/y2):
minn=a/b-y1/y2
miny1=y1
miny2=y2
y1=y1+1
else:
y2=y2+1
y1=miny1
y2=miny2
mintime=int(x1/y1)
if(mintime>int(x2/y2)):
mintime=int(x2/y2)
print(mintime*y1,mintime*y2)
``` | instruction | 0 | 18,649 | 3 | 37,298 |
No | output | 1 | 18,649 | 3 | 37,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob is about to take a hot bath.
There are two taps to fill the bath: a hot water tap and a cold water tap. The cold water's temperature is t1, and the hot water's temperature is t2. The cold water tap can transmit any integer number of water units per second from 0 to x1, inclusive. Similarly, the hot water tap can transmit from 0 to x2 water units per second.
If y1 water units per second flow through the first tap and y2 water units per second flow through the second tap, then the resulting bath water temperature will be:
<image>
Bob wants to open both taps so that the bath water temperature was not less than t0. However, the temperature should be as close as possible to this value. If there are several optimal variants, Bob chooses the one that lets fill the bath in the quickest way possible.
Determine how much each tap should be opened so that Bob was pleased with the result in the end.
Input
You are given five integers t1, t2, x1, x2 and t0 (1 β€ t1 β€ t0 β€ t2 β€ 106, 1 β€ x1, x2 β€ 106).
Output
Print two space-separated integers y1 and y2 (0 β€ y1 β€ x1, 0 β€ y2 β€ x2).
Examples
Input
10 70 100 100 25
Output
99 33
Input
300 500 1000 1000 300
Output
1000 0
Input
143 456 110 117 273
Output
76 54
Note
In the second sample the hot water tap shouldn't be opened, but the cold water tap should be opened at full capacity in order to fill the bath in the quickest way possible.
Submitted Solution:
```
def gcd(a,b):
if(a%b==0):
return b
else:
return gcd(b,a%b)
[t1,t2,x1,x2,t0]=input().split(' ')
#[t1,t2,x1,x2,t0]=[143,456,110,117,273]
t1=int(t1)
t2=int(t2)
x1=int(x1)
x2=int(x2)
t0=int(t0)
a=t2-t0
b=t0-t1
if (a==0):
y1=0
y2=x2
print(y1,y2)
exit(0)
if (b==0):
y1=x1
y2=0
print(y1,y2)
exit(0)
g=gcd(a,b)
a=int(a/g)
b=int(b/g)
if(a<=x1 and b<=x2):
mintime=int(x1/a)
if(mintime>int(x2/b)):
mintime=int(x2/b)
print(mintime*a,mintime*b)
exit()
y1=1
y2=1
minn=99999
while(y1<=x1):
while(y2<=x2):
if(y1/y2<a/b):
if(minn>a/b-y1/y2):
minn=a/b-y1/y2
miny1=y1
miny2=y2
y1=y1+1
else:
y2=y2+1
y1=miny1
y2=miny2
mintime=int(x1/y1)
if(mintime>int(x2/y2)):
mintime=int(x2/y2)
print(mintime*y1,mintime*y2)
``` | instruction | 0 | 18,650 | 3 | 37,300 |
No | output | 1 | 18,650 | 3 | 37,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Luba is surfing the Internet. She currently has n opened tabs in her browser, indexed from 1 to n from left to right. The mouse cursor is currently located at the pos-th tab. Luba needs to use the tabs with indices from l to r (inclusive) for her studies, and she wants to close all the tabs that don't belong to this segment as fast as possible.
Each second Luba can either try moving the cursor to the left or to the right (if the cursor is currently at the tab i, then she can move it to the tab max(i - 1, a) or to the tab min(i + 1, b)) or try closing all the tabs to the left or to the right of the cursor (if the cursor is currently at the tab i, she can close all the tabs with indices from segment [a, i - 1] or from segment [i + 1, b]). In the aforementioned expressions a and b denote the minimum and maximum index of an unclosed tab, respectively. For example, if there were 7 tabs initially and tabs 1, 2 and 7 are closed, then a = 3, b = 6.
What is the minimum number of seconds Luba has to spend in order to leave only the tabs with initial indices from l to r inclusive opened?
Input
The only line of input contains four integer numbers n, pos, l, r (1 β€ n β€ 100, 1 β€ pos β€ n, 1 β€ l β€ r β€ n) β the number of the tabs, the cursor position and the segment which Luba needs to leave opened.
Output
Print one integer equal to the minimum number of seconds required to close all the tabs outside the segment [l, r].
Examples
Input
6 3 2 4
Output
5
Input
6 3 1 3
Output
1
Input
5 2 1 5
Output
0
Note
In the first test Luba can do the following operations: shift the mouse cursor to the tab 2, close all the tabs to the left of it, shift the mouse cursor to the tab 3, then to the tab 4, and then close all the tabs to the right of it.
In the second test she only needs to close all the tabs to the right of the current position of the cursor.
In the third test Luba doesn't need to do anything.
Submitted Solution:
```
n, pos, l, r = map(int, input().split())
if l > 1 and r < n:
if l <= pos and pos <= r:
if pos - l < r - pos:
print(pos - l + 1 + r - l + 1)
else:
print(r - pos + 1 + r - l + 1)
elif pos > r:
print(pos - r + 1 + r - l + 1)
else:
print(l - pos + 1 + r - l + 1)
elif l == 1 and r < n:
print(int(abs(pos - r)) + 1)
elif l > 1 and r == n:
print(int(abs(pos - l)) + 1)
else:
print(0)
``` | instruction | 0 | 19,083 | 3 | 38,166 |
Yes | output | 1 | 19,083 | 3 | 38,167 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Luba is surfing the Internet. She currently has n opened tabs in her browser, indexed from 1 to n from left to right. The mouse cursor is currently located at the pos-th tab. Luba needs to use the tabs with indices from l to r (inclusive) for her studies, and she wants to close all the tabs that don't belong to this segment as fast as possible.
Each second Luba can either try moving the cursor to the left or to the right (if the cursor is currently at the tab i, then she can move it to the tab max(i - 1, a) or to the tab min(i + 1, b)) or try closing all the tabs to the left or to the right of the cursor (if the cursor is currently at the tab i, she can close all the tabs with indices from segment [a, i - 1] or from segment [i + 1, b]). In the aforementioned expressions a and b denote the minimum and maximum index of an unclosed tab, respectively. For example, if there were 7 tabs initially and tabs 1, 2 and 7 are closed, then a = 3, b = 6.
What is the minimum number of seconds Luba has to spend in order to leave only the tabs with initial indices from l to r inclusive opened?
Input
The only line of input contains four integer numbers n, pos, l, r (1 β€ n β€ 100, 1 β€ pos β€ n, 1 β€ l β€ r β€ n) β the number of the tabs, the cursor position and the segment which Luba needs to leave opened.
Output
Print one integer equal to the minimum number of seconds required to close all the tabs outside the segment [l, r].
Examples
Input
6 3 2 4
Output
5
Input
6 3 1 3
Output
1
Input
5 2 1 5
Output
0
Note
In the first test Luba can do the following operations: shift the mouse cursor to the tab 2, close all the tabs to the left of it, shift the mouse cursor to the tab 3, then to the tab 4, and then close all the tabs to the right of it.
In the second test she only needs to close all the tabs to the right of the current position of the cursor.
In the third test Luba doesn't need to do anything.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Mon Jan 15 23:21:43 2018
@author: Paras Sharma
"""
n,c,s,e=list(map(int,input().split()))
countl=0
countr=0
flag=0
if s!=1:
flag+=1
countl+=abs(c-s)+1
if e!=n:
countl+=abs(e-s)+1
if e!=n:
flag+=2
countr+=abs(e-c)+1
if s!=1:
countr+=abs(e-s)+1
if flag>2:
print(min(countl,countr))
elif flag==2:
print(countr)
elif flag==1:
print(countl)
else:
print(0)
``` | instruction | 0 | 19,084 | 3 | 38,168 |
Yes | output | 1 | 19,084 | 3 | 38,169 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Luba is surfing the Internet. She currently has n opened tabs in her browser, indexed from 1 to n from left to right. The mouse cursor is currently located at the pos-th tab. Luba needs to use the tabs with indices from l to r (inclusive) for her studies, and she wants to close all the tabs that don't belong to this segment as fast as possible.
Each second Luba can either try moving the cursor to the left or to the right (if the cursor is currently at the tab i, then she can move it to the tab max(i - 1, a) or to the tab min(i + 1, b)) or try closing all the tabs to the left or to the right of the cursor (if the cursor is currently at the tab i, she can close all the tabs with indices from segment [a, i - 1] or from segment [i + 1, b]). In the aforementioned expressions a and b denote the minimum and maximum index of an unclosed tab, respectively. For example, if there were 7 tabs initially and tabs 1, 2 and 7 are closed, then a = 3, b = 6.
What is the minimum number of seconds Luba has to spend in order to leave only the tabs with initial indices from l to r inclusive opened?
Input
The only line of input contains four integer numbers n, pos, l, r (1 β€ n β€ 100, 1 β€ pos β€ n, 1 β€ l β€ r β€ n) β the number of the tabs, the cursor position and the segment which Luba needs to leave opened.
Output
Print one integer equal to the minimum number of seconds required to close all the tabs outside the segment [l, r].
Examples
Input
6 3 2 4
Output
5
Input
6 3 1 3
Output
1
Input
5 2 1 5
Output
0
Note
In the first test Luba can do the following operations: shift the mouse cursor to the tab 2, close all the tabs to the left of it, shift the mouse cursor to the tab 3, then to the tab 4, and then close all the tabs to the right of it.
In the second test she only needs to close all the tabs to the right of the current position of the cursor.
In the third test Luba doesn't need to do anything.
Submitted Solution:
```
n,pos,l,r=map(int,input().split())
lt=0
if(l==1 and r==n):
print(0)
elif(l==1 and not r==n):
print(abs(pos-r)+1)
elif(not l==1 and r==n):
print(abs(pos-l)+1)
else:
print(min(abs(pos-l),abs(pos-r))+abs(r-l)+2)
``` | instruction | 0 | 19,085 | 3 | 38,170 |
Yes | output | 1 | 19,085 | 3 | 38,171 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Luba is surfing the Internet. She currently has n opened tabs in her browser, indexed from 1 to n from left to right. The mouse cursor is currently located at the pos-th tab. Luba needs to use the tabs with indices from l to r (inclusive) for her studies, and she wants to close all the tabs that don't belong to this segment as fast as possible.
Each second Luba can either try moving the cursor to the left or to the right (if the cursor is currently at the tab i, then she can move it to the tab max(i - 1, a) or to the tab min(i + 1, b)) or try closing all the tabs to the left or to the right of the cursor (if the cursor is currently at the tab i, she can close all the tabs with indices from segment [a, i - 1] or from segment [i + 1, b]). In the aforementioned expressions a and b denote the minimum and maximum index of an unclosed tab, respectively. For example, if there were 7 tabs initially and tabs 1, 2 and 7 are closed, then a = 3, b = 6.
What is the minimum number of seconds Luba has to spend in order to leave only the tabs with initial indices from l to r inclusive opened?
Input
The only line of input contains four integer numbers n, pos, l, r (1 β€ n β€ 100, 1 β€ pos β€ n, 1 β€ l β€ r β€ n) β the number of the tabs, the cursor position and the segment which Luba needs to leave opened.
Output
Print one integer equal to the minimum number of seconds required to close all the tabs outside the segment [l, r].
Examples
Input
6 3 2 4
Output
5
Input
6 3 1 3
Output
1
Input
5 2 1 5
Output
0
Note
In the first test Luba can do the following operations: shift the mouse cursor to the tab 2, close all the tabs to the left of it, shift the mouse cursor to the tab 3, then to the tab 4, and then close all the tabs to the right of it.
In the second test she only needs to close all the tabs to the right of the current position of the cursor.
In the third test Luba doesn't need to do anything.
Submitted Solution:
```
n,curr,l,r=map(int,input().split())
pos=0
if l==1 and r==n:
print(0)
exit()
if l==1:
if curr>=r:
print(curr-r+1)
else:
print(r-curr+1)
exit()
if r==n:
if curr>=l:
print(curr-l+1)
else:
print(l-curr+1)
exit()
if curr==l:
print(1+(r-l)+1)
exit()
if curr==r:
print(1+(r-l)+1)
exit()
if l<=curr<=r:
mini=min(curr-l,r-curr)
print(mini+(r-l)+2)
exit()
if curr<l:
print(l-curr+1+r-l+1)
exit()
if curr>r:
print(curr-r+1+(r-l)+1)
exit()
``` | instruction | 0 | 19,086 | 3 | 38,172 |
Yes | output | 1 | 19,086 | 3 | 38,173 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Luba is surfing the Internet. She currently has n opened tabs in her browser, indexed from 1 to n from left to right. The mouse cursor is currently located at the pos-th tab. Luba needs to use the tabs with indices from l to r (inclusive) for her studies, and she wants to close all the tabs that don't belong to this segment as fast as possible.
Each second Luba can either try moving the cursor to the left or to the right (if the cursor is currently at the tab i, then she can move it to the tab max(i - 1, a) or to the tab min(i + 1, b)) or try closing all the tabs to the left or to the right of the cursor (if the cursor is currently at the tab i, she can close all the tabs with indices from segment [a, i - 1] or from segment [i + 1, b]). In the aforementioned expressions a and b denote the minimum and maximum index of an unclosed tab, respectively. For example, if there were 7 tabs initially and tabs 1, 2 and 7 are closed, then a = 3, b = 6.
What is the minimum number of seconds Luba has to spend in order to leave only the tabs with initial indices from l to r inclusive opened?
Input
The only line of input contains four integer numbers n, pos, l, r (1 β€ n β€ 100, 1 β€ pos β€ n, 1 β€ l β€ r β€ n) β the number of the tabs, the cursor position and the segment which Luba needs to leave opened.
Output
Print one integer equal to the minimum number of seconds required to close all the tabs outside the segment [l, r].
Examples
Input
6 3 2 4
Output
5
Input
6 3 1 3
Output
1
Input
5 2 1 5
Output
0
Note
In the first test Luba can do the following operations: shift the mouse cursor to the tab 2, close all the tabs to the left of it, shift the mouse cursor to the tab 3, then to the tab 4, and then close all the tabs to the right of it.
In the second test she only needs to close all the tabs to the right of the current position of the cursor.
In the third test Luba doesn't need to do anything.
Submitted Solution:
```
n, pos, l, r = map(int, input().split())
left = False
right = False
if l != 1:
left = True
if r != n:
right = True
ans = 0
if left:
pos = max(pos - 1, l)
ans += 2
if right:
if pos != r:
pos = min(pos + 1, r)
ans += 1
while pos + 1 <= r:
pos = min(pos + 1, r)
ans += 1
ans += 1
print(ans)
``` | instruction | 0 | 19,087 | 3 | 38,174 |
No | output | 1 | 19,087 | 3 | 38,175 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Luba is surfing the Internet. She currently has n opened tabs in her browser, indexed from 1 to n from left to right. The mouse cursor is currently located at the pos-th tab. Luba needs to use the tabs with indices from l to r (inclusive) for her studies, and she wants to close all the tabs that don't belong to this segment as fast as possible.
Each second Luba can either try moving the cursor to the left or to the right (if the cursor is currently at the tab i, then she can move it to the tab max(i - 1, a) or to the tab min(i + 1, b)) or try closing all the tabs to the left or to the right of the cursor (if the cursor is currently at the tab i, she can close all the tabs with indices from segment [a, i - 1] or from segment [i + 1, b]). In the aforementioned expressions a and b denote the minimum and maximum index of an unclosed tab, respectively. For example, if there were 7 tabs initially and tabs 1, 2 and 7 are closed, then a = 3, b = 6.
What is the minimum number of seconds Luba has to spend in order to leave only the tabs with initial indices from l to r inclusive opened?
Input
The only line of input contains four integer numbers n, pos, l, r (1 β€ n β€ 100, 1 β€ pos β€ n, 1 β€ l β€ r β€ n) β the number of the tabs, the cursor position and the segment which Luba needs to leave opened.
Output
Print one integer equal to the minimum number of seconds required to close all the tabs outside the segment [l, r].
Examples
Input
6 3 2 4
Output
5
Input
6 3 1 3
Output
1
Input
5 2 1 5
Output
0
Note
In the first test Luba can do the following operations: shift the mouse cursor to the tab 2, close all the tabs to the left of it, shift the mouse cursor to the tab 3, then to the tab 4, and then close all the tabs to the right of it.
In the second test she only needs to close all the tabs to the right of the current position of the cursor.
In the third test Luba doesn't need to do anything.
Submitted Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
from math import gcd, ceil
def pre(s):
n = len(s)
pi = [0] * n
for i in range(1, n):
j = pi[i - 1]
while j and s[i] != s[j]:
j = pi[j - 1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def prod(a):
ans = 1
for each in a:
ans = (ans * each)
return ans
def lcm(a, b): return a * b // gcd(a, b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
from math import ceil
for _ in range(int(input()) if not True else 1):
#n = int(input())
#n, k = map(int, input().split())
n, pos, l, r = map(int, input().split())
#c, d = map(int, input().split())
#a = list(map(int, input().split()))
#b = list(map(int, input().split()))
#s = input()
if l == 1:
if r == n:
print(0)
continue
else:
print(1 + abs(pos-l))
continue
if r == n:
print(1 + abs(r - pos))
continue
print(2 + min(pos-l, r-pos) + r - l)
``` | instruction | 0 | 19,088 | 3 | 38,176 |
No | output | 1 | 19,088 | 3 | 38,177 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Luba is surfing the Internet. She currently has n opened tabs in her browser, indexed from 1 to n from left to right. The mouse cursor is currently located at the pos-th tab. Luba needs to use the tabs with indices from l to r (inclusive) for her studies, and she wants to close all the tabs that don't belong to this segment as fast as possible.
Each second Luba can either try moving the cursor to the left or to the right (if the cursor is currently at the tab i, then she can move it to the tab max(i - 1, a) or to the tab min(i + 1, b)) or try closing all the tabs to the left or to the right of the cursor (if the cursor is currently at the tab i, she can close all the tabs with indices from segment [a, i - 1] or from segment [i + 1, b]). In the aforementioned expressions a and b denote the minimum and maximum index of an unclosed tab, respectively. For example, if there were 7 tabs initially and tabs 1, 2 and 7 are closed, then a = 3, b = 6.
What is the minimum number of seconds Luba has to spend in order to leave only the tabs with initial indices from l to r inclusive opened?
Input
The only line of input contains four integer numbers n, pos, l, r (1 β€ n β€ 100, 1 β€ pos β€ n, 1 β€ l β€ r β€ n) β the number of the tabs, the cursor position and the segment which Luba needs to leave opened.
Output
Print one integer equal to the minimum number of seconds required to close all the tabs outside the segment [l, r].
Examples
Input
6 3 2 4
Output
5
Input
6 3 1 3
Output
1
Input
5 2 1 5
Output
0
Note
In the first test Luba can do the following operations: shift the mouse cursor to the tab 2, close all the tabs to the left of it, shift the mouse cursor to the tab 3, then to the tab 4, and then close all the tabs to the right of it.
In the second test she only needs to close all the tabs to the right of the current position of the cursor.
In the third test Luba doesn't need to do anything.
Submitted Solution:
```
from math import *
n,pos,l,r=map(int,input().split(' '))
a,b=1,1
if l==1:
a=0
if r==n:
b=0
if (a,b)==(0,0):
print(0)
elif b==0:
print((abs(pos-l)+1))
elif a==0:
print((abs(pos-r)+1))
else:
print((abs(pos-l)+1)+(r-l+1))
``` | instruction | 0 | 19,089 | 3 | 38,178 |
No | output | 1 | 19,089 | 3 | 38,179 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Luba is surfing the Internet. She currently has n opened tabs in her browser, indexed from 1 to n from left to right. The mouse cursor is currently located at the pos-th tab. Luba needs to use the tabs with indices from l to r (inclusive) for her studies, and she wants to close all the tabs that don't belong to this segment as fast as possible.
Each second Luba can either try moving the cursor to the left or to the right (if the cursor is currently at the tab i, then she can move it to the tab max(i - 1, a) or to the tab min(i + 1, b)) or try closing all the tabs to the left or to the right of the cursor (if the cursor is currently at the tab i, she can close all the tabs with indices from segment [a, i - 1] or from segment [i + 1, b]). In the aforementioned expressions a and b denote the minimum and maximum index of an unclosed tab, respectively. For example, if there were 7 tabs initially and tabs 1, 2 and 7 are closed, then a = 3, b = 6.
What is the minimum number of seconds Luba has to spend in order to leave only the tabs with initial indices from l to r inclusive opened?
Input
The only line of input contains four integer numbers n, pos, l, r (1 β€ n β€ 100, 1 β€ pos β€ n, 1 β€ l β€ r β€ n) β the number of the tabs, the cursor position and the segment which Luba needs to leave opened.
Output
Print one integer equal to the minimum number of seconds required to close all the tabs outside the segment [l, r].
Examples
Input
6 3 2 4
Output
5
Input
6 3 1 3
Output
1
Input
5 2 1 5
Output
0
Note
In the first test Luba can do the following operations: shift the mouse cursor to the tab 2, close all the tabs to the left of it, shift the mouse cursor to the tab 3, then to the tab 4, and then close all the tabs to the right of it.
In the second test she only needs to close all the tabs to the right of the current position of the cursor.
In the third test Luba doesn't need to do anything.
Submitted Solution:
```
def main():
N, POS, L, R = map(int, input().split())
if L == 1 and R == N:
print(0)
return
step = abs(min(POS - L, R - POS)) + R - L
if POS < L or POS > R:
if L == 1 or R == N:
step += 1
else:
step += 2
elif L <= POS <= R:
if L == 1:
step -= POS - L - 1
elif R == N:
step = R - POS + 1
else:
step += 2
print(step)
main()
``` | instruction | 0 | 19,090 | 3 | 38,180 |
No | output | 1 | 19,090 | 3 | 38,181 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have to handle a very complex water distribution system. The system consists of n junctions and m pipes, i-th pipe connects junctions x_i and y_i.
The only thing you can do is adjusting the pipes. You have to choose m integer numbers f_1, f_2, ..., f_m and use them as pipe settings. i-th pipe will distribute f_i units of water per second from junction x_i to junction y_i (if f_i is negative, then the pipe will distribute |f_i| units of water per second from junction y_i to junction x_i). It is allowed to set f_i to any integer from -2 β
10^9 to 2 β
10^9.
In order for the system to work properly, there are some constraints: for every i β [1, n], i-th junction has a number s_i associated with it meaning that the difference between incoming and outcoming flow for i-th junction must be exactly s_i (if s_i is not negative, then i-th junction must receive s_i units of water per second; if it is negative, then i-th junction must transfer |s_i| units of water per second to other junctions).
Can you choose the integers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied?
Input
The first line contains an integer n (1 β€ n β€ 2 β
10^5) β the number of junctions.
The second line contains n integers s_1, s_2, ..., s_n (-10^4 β€ s_i β€ 10^4) β constraints for the junctions.
The third line contains an integer m (0 β€ m β€ 2 β
10^5) β the number of pipes.
i-th of the next m lines contains two integers x_i and y_i (1 β€ x_i, y_i β€ n, x_i β y_i) β the description of i-th pipe. It is guaranteed that each unordered pair (x, y) will appear no more than once in the input (it means that there won't be any pairs (x, y) or (y, x) after the first occurrence of (x, y)). It is guaranteed that for each pair of junctions there exists a path along the pipes connecting them.
Output
If you can choose such integer numbers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied, then output "Possible" in the first line. Then output m lines, i-th line should contain f_i β the chosen setting numbers for the pipes. Pipes are numbered in order they appear in the input.
Otherwise output "Impossible" in the only line.
Examples
Input
4
3 -10 6 1
5
1 2
3 2
2 4
3 4
3 1
Output
Possible
4
-6
8
-7
7
Input
4
3 -10 6 4
5
1 2
3 2
2 4
3 4
3 1
Output
Impossible | instruction | 0 | 19,113 | 3 | 38,226 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
from time import time
t0 = time()
#sys.setrecursionlimit(300000)
def i_ints():
return list(map(int, sys.stdin.readline().split()))
#purvikaurraina
def main():
limit =10**10
n, = i_ints()
s = [0] + i_ints()
if sum(s):
print("Impossible")
return
print("Possible")
if n == limit: print(int(1000000*(time()-t0)))
m, = i_ints()
es = [i_ints() for _ in range(m)]
if n == limit: print(int(1000000*(time()-t0)))
nb = [[] for i in range(n+1)]
for i, (x, y) in enumerate(es):
nb[x].append((y, i, 1))
nb[y].append((x, i, -1))
if n == limit: print(int(1000000*(time()-t0)))
f = [0] * m
path = []
def make_path():
stack = []
seen = [False] * (n+1)
stack.append(1)
seen[1] = True
while stack:
x = stack.pop()
for y, i, factor in nb[x]:
if not seen[y]:
seen[y] = True
stack.append(y)
path.append((x, y, i, factor))
make_path()
# print(path)
if n == limit: print(int(1000000*(time()-t0)))
for x, y, i,factor in reversed(path):
f[i] = factor * s[y]
s[x] += s[y]
s[y] = 0
if n == limit: print(int(1000000*(time()-t0)))
print("\n".join(map(str, f)))
return
# def walk_tree(x, seen):
# seen.add(x)
# for y, i, factor in nb[x]:
# if y not in seen:
# walk_tree(y, seen)
# f[i] = factor * s[y]
# s[x] += s[y]
# s[y] = 0
# walk_tree(1, set())
#
# if n > limit: print(int(1000000*(time()-t0)))
#
# print("\n".join(map(str, f)))
main()
``` | output | 1 | 19,113 | 3 | 38,227 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have to handle a very complex water distribution system. The system consists of n junctions and m pipes, i-th pipe connects junctions x_i and y_i.
The only thing you can do is adjusting the pipes. You have to choose m integer numbers f_1, f_2, ..., f_m and use them as pipe settings. i-th pipe will distribute f_i units of water per second from junction x_i to junction y_i (if f_i is negative, then the pipe will distribute |f_i| units of water per second from junction y_i to junction x_i). It is allowed to set f_i to any integer from -2 β
10^9 to 2 β
10^9.
In order for the system to work properly, there are some constraints: for every i β [1, n], i-th junction has a number s_i associated with it meaning that the difference between incoming and outcoming flow for i-th junction must be exactly s_i (if s_i is not negative, then i-th junction must receive s_i units of water per second; if it is negative, then i-th junction must transfer |s_i| units of water per second to other junctions).
Can you choose the integers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied?
Input
The first line contains an integer n (1 β€ n β€ 2 β
10^5) β the number of junctions.
The second line contains n integers s_1, s_2, ..., s_n (-10^4 β€ s_i β€ 10^4) β constraints for the junctions.
The third line contains an integer m (0 β€ m β€ 2 β
10^5) β the number of pipes.
i-th of the next m lines contains two integers x_i and y_i (1 β€ x_i, y_i β€ n, x_i β y_i) β the description of i-th pipe. It is guaranteed that each unordered pair (x, y) will appear no more than once in the input (it means that there won't be any pairs (x, y) or (y, x) after the first occurrence of (x, y)). It is guaranteed that for each pair of junctions there exists a path along the pipes connecting them.
Output
If you can choose such integer numbers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied, then output "Possible" in the first line. Then output m lines, i-th line should contain f_i β the chosen setting numbers for the pipes. Pipes are numbered in order they appear in the input.
Otherwise output "Impossible" in the only line.
Examples
Input
4
3 -10 6 1
5
1 2
3 2
2 4
3 4
3 1
Output
Possible
4
-6
8
-7
7
Input
4
3 -10 6 4
5
1 2
3 2
2 4
3 4
3 1
Output
Impossible | instruction | 0 | 19,114 | 3 | 38,228 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
from time import time
t0 = time()
#sys.setrecursionlimit(300000)
def i_ints():
return list(map(int, sys.stdin.readline().split()))
def main():
limit =10**10
n, = i_ints()
s = [0] + i_ints()
if sum(s):
print("Impossible")
return
print("Possible")
if n == limit: print(int(1000000*(time()-t0)))
m, = i_ints()
es = [i_ints() for _ in range(m)]
if n == limit: print(int(1000000*(time()-t0)))
nb = [[] for i in range(n+1)]
for i, (x, y) in enumerate(es):
nb[x].append((y, i, 1))
nb[y].append((x, i, -1))
if n == limit: print(int(1000000*(time()-t0)))
f = [0] * m
path = []
def make_path():
stack = []
seen = [False] * (n+1)
stack.append(1)
seen[1] = True
while stack:
x = stack.pop()
for y, i, factor in nb[x]:
if not seen[y]:
seen[y] = True
stack.append(y)
path.append((x, y, i, factor))
make_path()
if n == limit: print(int(1000000*(time()-t0)))
for x, y, i,factor in reversed(path):
f[i] = factor * s[y]
s[x] += s[y]
s[y] = 0
if n == limit: print(int(1000000*(time()-t0)))
print("\n".join(map(str, f)))
return
main()
``` | output | 1 | 19,114 | 3 | 38,229 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have to handle a very complex water distribution system. The system consists of n junctions and m pipes, i-th pipe connects junctions x_i and y_i.
The only thing you can do is adjusting the pipes. You have to choose m integer numbers f_1, f_2, ..., f_m and use them as pipe settings. i-th pipe will distribute f_i units of water per second from junction x_i to junction y_i (if f_i is negative, then the pipe will distribute |f_i| units of water per second from junction y_i to junction x_i). It is allowed to set f_i to any integer from -2 β
10^9 to 2 β
10^9.
In order for the system to work properly, there are some constraints: for every i β [1, n], i-th junction has a number s_i associated with it meaning that the difference between incoming and outcoming flow for i-th junction must be exactly s_i (if s_i is not negative, then i-th junction must receive s_i units of water per second; if it is negative, then i-th junction must transfer |s_i| units of water per second to other junctions).
Can you choose the integers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied?
Input
The first line contains an integer n (1 β€ n β€ 2 β
10^5) β the number of junctions.
The second line contains n integers s_1, s_2, ..., s_n (-10^4 β€ s_i β€ 10^4) β constraints for the junctions.
The third line contains an integer m (0 β€ m β€ 2 β
10^5) β the number of pipes.
i-th of the next m lines contains two integers x_i and y_i (1 β€ x_i, y_i β€ n, x_i β y_i) β the description of i-th pipe. It is guaranteed that each unordered pair (x, y) will appear no more than once in the input (it means that there won't be any pairs (x, y) or (y, x) after the first occurrence of (x, y)). It is guaranteed that for each pair of junctions there exists a path along the pipes connecting them.
Output
If you can choose such integer numbers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied, then output "Possible" in the first line. Then output m lines, i-th line should contain f_i β the chosen setting numbers for the pipes. Pipes are numbered in order they appear in the input.
Otherwise output "Impossible" in the only line.
Examples
Input
4
3 -10 6 1
5
1 2
3 2
2 4
3 4
3 1
Output
Possible
4
-6
8
-7
7
Input
4
3 -10 6 4
5
1 2
3 2
2 4
3 4
3 1
Output
Impossible | instruction | 0 | 19,115 | 3 | 38,230 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
from time import time
t1 = time()
#sys.setrecursionlimit(300000)
def i_ints():
return list(map(int, sys.stdin.readline().split()))
def main():
limit =10**10
n, = i_ints()
s = [0] + i_ints()
if sum(s):
print("Impossible")
return
print("Possible")
if n == limit: print(int(1000000*(time()-t1)))
m, = i_ints()
es = [i_ints() for _ in range(m)]
if n == limit: print(int(1000000*(time()-t1)))
nb = [[] for i in range(n+1)]
for i, (x, y) in enumerate(es):
nb[x].append((y, i, 1))
nb[y].append((x, i, -1))
if n == limit: print(int(1000000*(time()-t1)))
f = [0] * m
path = []
def make_path():
stack = []
seen = [False] * (n+1)
stack.append(1)
seen[1] = True
while stack:
x = stack.pop()
for y, i, factor in nb[x]:
if not seen[y]:
seen[y] = True
stack.append(y)
path.append((x, y, i, factor))
make_path()
# print(path)
if n == limit: print(int(1000000*(time()-t1)))
for x, y, i,factor in reversed(path):
f[i] = factor * s[y]
s[x] += s[y]
s[y] = 0
if n == limit: print(int(1000000*(time()-t1)))
print("\n".join(map(str, f)))
return
# def walk_tree(x, seen):
# seen.add(x)
# for y, i, factor in nb[x]:
# if y not in seen:
# walk_tree(y, seen)
# f[i] = factor * s[y]
# s[x] += s[y]
# s[y] = 0
# walk_tree(1, set())
#
# if n > limit: print(int(1000000*(time()-t1)))
#
# print("\n".join(map(str, f)))
main()
``` | output | 1 | 19,115 | 3 | 38,231 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have to handle a very complex water distribution system. The system consists of n junctions and m pipes, i-th pipe connects junctions x_i and y_i.
The only thing you can do is adjusting the pipes. You have to choose m integer numbers f_1, f_2, ..., f_m and use them as pipe settings. i-th pipe will distribute f_i units of water per second from junction x_i to junction y_i (if f_i is negative, then the pipe will distribute |f_i| units of water per second from junction y_i to junction x_i). It is allowed to set f_i to any integer from -2 β
10^9 to 2 β
10^9.
In order for the system to work properly, there are some constraints: for every i β [1, n], i-th junction has a number s_i associated with it meaning that the difference between incoming and outcoming flow for i-th junction must be exactly s_i (if s_i is not negative, then i-th junction must receive s_i units of water per second; if it is negative, then i-th junction must transfer |s_i| units of water per second to other junctions).
Can you choose the integers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied?
Input
The first line contains an integer n (1 β€ n β€ 2 β
10^5) β the number of junctions.
The second line contains n integers s_1, s_2, ..., s_n (-10^4 β€ s_i β€ 10^4) β constraints for the junctions.
The third line contains an integer m (0 β€ m β€ 2 β
10^5) β the number of pipes.
i-th of the next m lines contains two integers x_i and y_i (1 β€ x_i, y_i β€ n, x_i β y_i) β the description of i-th pipe. It is guaranteed that each unordered pair (x, y) will appear no more than once in the input (it means that there won't be any pairs (x, y) or (y, x) after the first occurrence of (x, y)). It is guaranteed that for each pair of junctions there exists a path along the pipes connecting them.
Output
If you can choose such integer numbers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied, then output "Possible" in the first line. Then output m lines, i-th line should contain f_i β the chosen setting numbers for the pipes. Pipes are numbered in order they appear in the input.
Otherwise output "Impossible" in the only line.
Examples
Input
4
3 -10 6 1
5
1 2
3 2
2 4
3 4
3 1
Output
Possible
4
-6
8
-7
7
Input
4
3 -10 6 4
5
1 2
3 2
2 4
3 4
3 1
Output
Impossible | instruction | 0 | 19,116 | 3 | 38,232 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
from time import time
t0 = time()
#sys.setrecursionlimit(300000)
def i_ints():
return list(map(int, sys.stdin.readline().split()))
def main():
limit =10**10
n, = i_ints()
s = [0] + i_ints()
if sum(s):
print("Impossible")
return
print("Possible")
if n == limit: print(int(1000000*(time()-t0)))
m, = i_ints()
es = [i_ints() for _ in range(m)]
if n == limit: print(int(1000000*(time()-t0)))
nb = [[] for i in range(n+1)]
for i, (x, y) in enumerate(es):
nb[x].append((y, i, 1))
nb[y].append((x, i, -1))
if n == limit: print(int(1000000*(time()-t0)))
f = [0] * m
path = []
def make_path():
stack = []
seen = [False] * (n+1)
stack.append(1)
seen[1] = True
while stack:
x = stack.pop()
for y, i, factor in nb[x]:
if not seen[y]:
seen[y] = True
stack.append(y)
path.append((x, y, i, factor))
make_path()
# print(path)
if n == limit: print(int(1000000*(time()-t0)))
for x, y, i,factor in reversed(path):
f[i] = factor * s[y]
s[x] += s[y]
s[y] = 0
if n == limit: print(int(1000000*(time()-t0)))
print("\n".join(map(str, f)))
return
# def walk_tree(x, seen):
# seen.add(x)
# for y, i, factor in nb[x]:
# if y not in seen:
# walk_tree(y, seen)
# f[i] = factor * s[y]
# s[x] += s[y]
# s[y] = 0
# walk_tree(1, set())
#
# if n > limit: print(int(1000000*(time()-t0)))
#
# print("\n".join(map(str, f)))
main()
``` | output | 1 | 19,116 | 3 | 38,233 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have to handle a very complex water distribution system. The system consists of n junctions and m pipes, i-th pipe connects junctions x_i and y_i.
The only thing you can do is adjusting the pipes. You have to choose m integer numbers f_1, f_2, ..., f_m and use them as pipe settings. i-th pipe will distribute f_i units of water per second from junction x_i to junction y_i (if f_i is negative, then the pipe will distribute |f_i| units of water per second from junction y_i to junction x_i). It is allowed to set f_i to any integer from -2 β
10^9 to 2 β
10^9.
In order for the system to work properly, there are some constraints: for every i β [1, n], i-th junction has a number s_i associated with it meaning that the difference between incoming and outcoming flow for i-th junction must be exactly s_i (if s_i is not negative, then i-th junction must receive s_i units of water per second; if it is negative, then i-th junction must transfer |s_i| units of water per second to other junctions).
Can you choose the integers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied?
Input
The first line contains an integer n (1 β€ n β€ 2 β
10^5) β the number of junctions.
The second line contains n integers s_1, s_2, ..., s_n (-10^4 β€ s_i β€ 10^4) β constraints for the junctions.
The third line contains an integer m (0 β€ m β€ 2 β
10^5) β the number of pipes.
i-th of the next m lines contains two integers x_i and y_i (1 β€ x_i, y_i β€ n, x_i β y_i) β the description of i-th pipe. It is guaranteed that each unordered pair (x, y) will appear no more than once in the input (it means that there won't be any pairs (x, y) or (y, x) after the first occurrence of (x, y)). It is guaranteed that for each pair of junctions there exists a path along the pipes connecting them.
Output
If you can choose such integer numbers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied, then output "Possible" in the first line. Then output m lines, i-th line should contain f_i β the chosen setting numbers for the pipes. Pipes are numbered in order they appear in the input.
Otherwise output "Impossible" in the only line.
Examples
Input
4
3 -10 6 1
5
1 2
3 2
2 4
3 4
3 1
Output
Possible
4
-6
8
-7
7
Input
4
3 -10 6 4
5
1 2
3 2
2 4
3 4
3 1
Output
Impossible | instruction | 0 | 19,117 | 3 | 38,234 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
from time import time
def i_ints():
return list(map(int, sys.stdin.readline().split()))
def main():
limit =10**10
n, = i_ints()
s = [0] + i_ints()
if sum(s):
print("Impossible")
return
print("Possible")
m, = i_ints()
es = [i_ints() for _ in range(m)]
nb = [[] for i in range(n+1)]
for i, (x, y) in enumerate(es):
nb[x].append((y, i, 1))
nb[y].append((x, i, -1))
path = []
def make_path():
stack = []
seen = [False] * (n+1)
stack.append(1)
seen[1] = True
while stack:
x = stack.pop()
for y, i, factor in nb[x]:
if not seen[y]:
seen[y] = True
stack.append(y)
path.append((x, y, i, factor))
make_path()
f = [0] * m
for x, y, i,factor in reversed(path):
f[i] = factor * s[y]
s[x] += s[y]
s[y] = 0
print("\n".join(map(str, f)))
return
main()
``` | output | 1 | 19,117 | 3 | 38,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have to handle a very complex water distribution system. The system consists of n junctions and m pipes, i-th pipe connects junctions x_i and y_i.
The only thing you can do is adjusting the pipes. You have to choose m integer numbers f_1, f_2, ..., f_m and use them as pipe settings. i-th pipe will distribute f_i units of water per second from junction x_i to junction y_i (if f_i is negative, then the pipe will distribute |f_i| units of water per second from junction y_i to junction x_i). It is allowed to set f_i to any integer from -2 β
10^9 to 2 β
10^9.
In order for the system to work properly, there are some constraints: for every i β [1, n], i-th junction has a number s_i associated with it meaning that the difference between incoming and outcoming flow for i-th junction must be exactly s_i (if s_i is not negative, then i-th junction must receive s_i units of water per second; if it is negative, then i-th junction must transfer |s_i| units of water per second to other junctions).
Can you choose the integers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied?
Input
The first line contains an integer n (1 β€ n β€ 2 β
10^5) β the number of junctions.
The second line contains n integers s_1, s_2, ..., s_n (-10^4 β€ s_i β€ 10^4) β constraints for the junctions.
The third line contains an integer m (0 β€ m β€ 2 β
10^5) β the number of pipes.
i-th of the next m lines contains two integers x_i and y_i (1 β€ x_i, y_i β€ n, x_i β y_i) β the description of i-th pipe. It is guaranteed that each unordered pair (x, y) will appear no more than once in the input (it means that there won't be any pairs (x, y) or (y, x) after the first occurrence of (x, y)). It is guaranteed that for each pair of junctions there exists a path along the pipes connecting them.
Output
If you can choose such integer numbers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied, then output "Possible" in the first line. Then output m lines, i-th line should contain f_i β the chosen setting numbers for the pipes. Pipes are numbered in order they appear in the input.
Otherwise output "Impossible" in the only line.
Examples
Input
4
3 -10 6 1
5
1 2
3 2
2 4
3 4
3 1
Output
Possible
4
-6
8
-7
7
Input
4
3 -10 6 4
5
1 2
3 2
2 4
3 4
3 1
Output
Impossible
Submitted Solution:
```
import sys
from time import time
t0 = time()
sys.setrecursionlimit(200000)
def i_ints():
return list(map(int, input().split()))
#############
def main():
n, = i_ints()
s = [0] + i_ints()
if sum(s):
print("Impossible")
return
print("Possible")
if n > 10000: print(int(1000000*(time()-t0)))
m, = i_ints()
es = [i_ints() for _ in range(m)]
nb = [[] for i in range(n+1)]
for i, (x, y) in enumerate(es):
nb[x].append((y, i, 1))
nb[y].append((x, i, -1))
if n > 10000: print(int(1000000*(time()-t0)))
f = [0] * m
def walk_tree(x, seen):
seen.add(x)
for y, i, factor in nb[x]:
if y not in seen:
walk_tree(y, seen)
f[i] = factor * s[y]
s[x] += s[y]
s[y] = 0
walk_tree(1, set())
if n > 10000: print(int(1000000*(time()-t0)))
for x in f:
print(x)
``` | instruction | 0 | 19,118 | 3 | 38,236 |
No | output | 1 | 19,118 | 3 | 38,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have to handle a very complex water distribution system. The system consists of n junctions and m pipes, i-th pipe connects junctions x_i and y_i.
The only thing you can do is adjusting the pipes. You have to choose m integer numbers f_1, f_2, ..., f_m and use them as pipe settings. i-th pipe will distribute f_i units of water per second from junction x_i to junction y_i (if f_i is negative, then the pipe will distribute |f_i| units of water per second from junction y_i to junction x_i). It is allowed to set f_i to any integer from -2 β
10^9 to 2 β
10^9.
In order for the system to work properly, there are some constraints: for every i β [1, n], i-th junction has a number s_i associated with it meaning that the difference between incoming and outcoming flow for i-th junction must be exactly s_i (if s_i is not negative, then i-th junction must receive s_i units of water per second; if it is negative, then i-th junction must transfer |s_i| units of water per second to other junctions).
Can you choose the integers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied?
Input
The first line contains an integer n (1 β€ n β€ 2 β
10^5) β the number of junctions.
The second line contains n integers s_1, s_2, ..., s_n (-10^4 β€ s_i β€ 10^4) β constraints for the junctions.
The third line contains an integer m (0 β€ m β€ 2 β
10^5) β the number of pipes.
i-th of the next m lines contains two integers x_i and y_i (1 β€ x_i, y_i β€ n, x_i β y_i) β the description of i-th pipe. It is guaranteed that each unordered pair (x, y) will appear no more than once in the input (it means that there won't be any pairs (x, y) or (y, x) after the first occurrence of (x, y)). It is guaranteed that for each pair of junctions there exists a path along the pipes connecting them.
Output
If you can choose such integer numbers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied, then output "Possible" in the first line. Then output m lines, i-th line should contain f_i β the chosen setting numbers for the pipes. Pipes are numbered in order they appear in the input.
Otherwise output "Impossible" in the only line.
Examples
Input
4
3 -10 6 1
5
1 2
3 2
2 4
3 4
3 1
Output
Possible
4
-6
8
-7
7
Input
4
3 -10 6 4
5
1 2
3 2
2 4
3 4
3 1
Output
Impossible
Submitted Solution:
```
def i_ints():
return list(map(int, input().split()))
#############
n, = i_ints()
s = [0] + i_ints()
if sum(s):
print("Impossible")
else:
print("Possible")
m, = i_ints()
es = [i_ints() for _ in range(m)]
nb = [[] for i in range(n+1)]
for i, (x, y) in enumerate(es):
nb[x].append((y, i, 1))
nb[y].append((x, i, -1))
f = [0] * m
def walk_tree(x, seen):
print("A:", x, seen)
seen.add(x)
for y, i, factor in nb[x]:
if y not in seen:
walk_tree(y, seen)
f[i] = factor * s[y]
s[x] += s[y]
s[y] = 0
walk_tree(1, set())
for x in f:
print(x)
``` | instruction | 0 | 19,119 | 3 | 38,238 |
No | output | 1 | 19,119 | 3 | 38,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have to handle a very complex water distribution system. The system consists of n junctions and m pipes, i-th pipe connects junctions x_i and y_i.
The only thing you can do is adjusting the pipes. You have to choose m integer numbers f_1, f_2, ..., f_m and use them as pipe settings. i-th pipe will distribute f_i units of water per second from junction x_i to junction y_i (if f_i is negative, then the pipe will distribute |f_i| units of water per second from junction y_i to junction x_i). It is allowed to set f_i to any integer from -2 β
10^9 to 2 β
10^9.
In order for the system to work properly, there are some constraints: for every i β [1, n], i-th junction has a number s_i associated with it meaning that the difference between incoming and outcoming flow for i-th junction must be exactly s_i (if s_i is not negative, then i-th junction must receive s_i units of water per second; if it is negative, then i-th junction must transfer |s_i| units of water per second to other junctions).
Can you choose the integers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied?
Input
The first line contains an integer n (1 β€ n β€ 2 β
10^5) β the number of junctions.
The second line contains n integers s_1, s_2, ..., s_n (-10^4 β€ s_i β€ 10^4) β constraints for the junctions.
The third line contains an integer m (0 β€ m β€ 2 β
10^5) β the number of pipes.
i-th of the next m lines contains two integers x_i and y_i (1 β€ x_i, y_i β€ n, x_i β y_i) β the description of i-th pipe. It is guaranteed that each unordered pair (x, y) will appear no more than once in the input (it means that there won't be any pairs (x, y) or (y, x) after the first occurrence of (x, y)). It is guaranteed that for each pair of junctions there exists a path along the pipes connecting them.
Output
If you can choose such integer numbers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied, then output "Possible" in the first line. Then output m lines, i-th line should contain f_i β the chosen setting numbers for the pipes. Pipes are numbered in order they appear in the input.
Otherwise output "Impossible" in the only line.
Examples
Input
4
3 -10 6 1
5
1 2
3 2
2 4
3 4
3 1
Output
Possible
4
-6
8
-7
7
Input
4
3 -10 6 4
5
1 2
3 2
2 4
3 4
3 1
Output
Impossible
Submitted Solution:
```
import sys
from time import time
t0 = time()
sys.setrecursionlimit(20000)
def i_ints():
return list(map(int, input().split()))
#############
def main():
limit =10**4
n, = i_ints()
s = [0] + i_ints()
if sum(s):
print("Impossible")
return
print("Possible")
if n > limit: print(int(1000000*(time()-t0)))
m, = i_ints()
es = [i_ints() for _ in range(m)]
if n > limit: print(int(1000000*(time()-t0)))
nb = [[] for i in range(n+1)]
for i, (x, y) in enumerate(es):
nb[x].append((y, i, 1))
nb[y].append((x, i, -1))
if n > limit: print(int(1000000*(time()-t0)))
f = [0] * m
def walk_tree(x, seen):
seen.add(x)
for y, i, factor in nb[x]:
if y not in seen:
walk_tree(y, seen)
f[i] = factor * s[y]
s[x] += s[y]
s[y] = 0
walk_tree(1, set())
if n > limit: print(int(1000000*(time()-t0)))
for x in f:
print(x)
main()
``` | instruction | 0 | 19,120 | 3 | 38,240 |
No | output | 1 | 19,120 | 3 | 38,241 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.