message stringlengths 2 22.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 16 109k | cluster float64 1 1 | __index_level_0__ int64 32 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The construction of subway in Bertown is almost finished! The President of Berland will visit this city soon to look at the new subway himself.
There are n stations in the subway. It was built according to the Bertown Transport Law:
1. For each station i there exists exactly one train that goes from this station. Its destination station is pi, possibly pi = i;
2. For each station i there exists exactly one station j such that pj = i.
The President will consider the convenience of subway after visiting it. The convenience is the number of ordered pairs (x, y) such that person can start at station x and, after taking some subway trains (possibly zero), arrive at station y (1 ≤ x, y ≤ n).
The mayor of Bertown thinks that if the subway is not convenient enough, then the President might consider installing a new mayor (and, of course, the current mayor doesn't want it to happen). Before President visits the city mayor has enough time to rebuild some paths of subway, thus changing the values of pi for not more than two subway stations. Of course, breaking the Bertown Transport Law is really bad, so the subway must be built according to the Law even after changes.
The mayor wants to do these changes in such a way that the convenience of the subway is maximized. Help him to calculate the maximum possible convenience he can get!
Input
The first line contains one integer number n (1 ≤ n ≤ 100000) — the number of stations.
The second line contains n integer numbers p1, p2, ..., pn (1 ≤ pi ≤ n) — the current structure of the subway. All these numbers are distinct.
Output
Print one number — the maximum possible value of convenience.
Examples
Input
3
2 1 3
Output
9
Input
5
1 5 4 3 2
Output
17
Note
In the first example the mayor can change p2 to 3 and p3 to 1, so there will be 9 pairs: (1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3).
In the second example the mayor can change p2 to 4 and p3 to 5.
Submitted Solution:
```
#!/usr/bin/env python3
n = int(input())
P = [int(p)-1 for p in input().split()] # permutation
seen = [False]*n
res = m0 = m1 = 0
for i in range(n):
if not seen[i]:
seen[i] = True
j = P[i]
c = 1 # taille du cycle
while j!=i:
seen[j] = True
j = P[j]
c += 1
res += c*c
if c>m0:
m0,m1 = c,m0
elif c>m1:
m1 = c
# on fusionne les 2 plus grands cycles
res += (m0+m1)*(m0+m1)-m0*m0-m1*m1
print(res)
``` | instruction | 0 | 9,627 | 1 | 19,254 |
Yes | output | 1 | 9,627 | 1 | 19,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The construction of subway in Bertown is almost finished! The President of Berland will visit this city soon to look at the new subway himself.
There are n stations in the subway. It was built according to the Bertown Transport Law:
1. For each station i there exists exactly one train that goes from this station. Its destination station is pi, possibly pi = i;
2. For each station i there exists exactly one station j such that pj = i.
The President will consider the convenience of subway after visiting it. The convenience is the number of ordered pairs (x, y) such that person can start at station x and, after taking some subway trains (possibly zero), arrive at station y (1 ≤ x, y ≤ n).
The mayor of Bertown thinks that if the subway is not convenient enough, then the President might consider installing a new mayor (and, of course, the current mayor doesn't want it to happen). Before President visits the city mayor has enough time to rebuild some paths of subway, thus changing the values of pi for not more than two subway stations. Of course, breaking the Bertown Transport Law is really bad, so the subway must be built according to the Law even after changes.
The mayor wants to do these changes in such a way that the convenience of the subway is maximized. Help him to calculate the maximum possible convenience he can get!
Input
The first line contains one integer number n (1 ≤ n ≤ 100000) — the number of stations.
The second line contains n integer numbers p1, p2, ..., pn (1 ≤ pi ≤ n) — the current structure of the subway. All these numbers are distinct.
Output
Print one number — the maximum possible value of convenience.
Examples
Input
3
2 1 3
Output
9
Input
5
1 5 4 3 2
Output
17
Note
In the first example the mayor can change p2 to 3 and p3 to 1, so there will be 9 pairs: (1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3).
In the second example the mayor can change p2 to 4 and p3 to 5.
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
b=[0]*n
k1=0
s=[]
for i in range (n):
if b[i]==0:
j=a[i]-1
k=1
b[i]=1
sp=[i]
while b[j] == 0:
sp.append(j)
k+=1
j=a[j]-1
k1=max(k,k1)
if k > k1:
s.append(k1)
k1=int(k)
else:
s.append(k)
for u in sp:
b[u]=k
print(s,b,k1)
print(sum(list(map(lambda x: x*x,s)))+k1*max(s))
``` | instruction | 0 | 9,628 | 1 | 19,256 |
No | output | 1 | 9,628 | 1 | 19,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The construction of subway in Bertown is almost finished! The President of Berland will visit this city soon to look at the new subway himself.
There are n stations in the subway. It was built according to the Bertown Transport Law:
1. For each station i there exists exactly one train that goes from this station. Its destination station is pi, possibly pi = i;
2. For each station i there exists exactly one station j such that pj = i.
The President will consider the convenience of subway after visiting it. The convenience is the number of ordered pairs (x, y) such that person can start at station x and, after taking some subway trains (possibly zero), arrive at station y (1 ≤ x, y ≤ n).
The mayor of Bertown thinks that if the subway is not convenient enough, then the President might consider installing a new mayor (and, of course, the current mayor doesn't want it to happen). Before President visits the city mayor has enough time to rebuild some paths of subway, thus changing the values of pi for not more than two subway stations. Of course, breaking the Bertown Transport Law is really bad, so the subway must be built according to the Law even after changes.
The mayor wants to do these changes in such a way that the convenience of the subway is maximized. Help him to calculate the maximum possible convenience he can get!
Input
The first line contains one integer number n (1 ≤ n ≤ 100000) — the number of stations.
The second line contains n integer numbers p1, p2, ..., pn (1 ≤ pi ≤ n) — the current structure of the subway. All these numbers are distinct.
Output
Print one number — the maximum possible value of convenience.
Examples
Input
3
2 1 3
Output
9
Input
5
1 5 4 3 2
Output
17
Note
In the first example the mayor can change p2 to 3 and p3 to 1, so there will be 9 pairs: (1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3).
In the second example the mayor can change p2 to 4 and p3 to 5.
Submitted Solution:
```
n = int(input())
p = list(map(int, input().split()))
c = []
visited = [0]*(n+1)
for i in range(n):
if visited[p[i]] == 0:
ct = 1
t = p[p[i]-1]
visited[p[i]] = 1
while t != p[i]:
t = p[t-1]
visited[t-1] = 1
ct += 1
c.append(ct)
c.sort()
if len(c) == 1:
print(c[0]**2)
else:
aux = c[-1] + c[-2]
c = c[:-2] + [aux]
print(sum(i**2 for i in c))
``` | instruction | 0 | 9,629 | 1 | 19,258 |
No | output | 1 | 9,629 | 1 | 19,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The construction of subway in Bertown is almost finished! The President of Berland will visit this city soon to look at the new subway himself.
There are n stations in the subway. It was built according to the Bertown Transport Law:
1. For each station i there exists exactly one train that goes from this station. Its destination station is pi, possibly pi = i;
2. For each station i there exists exactly one station j such that pj = i.
The President will consider the convenience of subway after visiting it. The convenience is the number of ordered pairs (x, y) such that person can start at station x and, after taking some subway trains (possibly zero), arrive at station y (1 ≤ x, y ≤ n).
The mayor of Bertown thinks that if the subway is not convenient enough, then the President might consider installing a new mayor (and, of course, the current mayor doesn't want it to happen). Before President visits the city mayor has enough time to rebuild some paths of subway, thus changing the values of pi for not more than two subway stations. Of course, breaking the Bertown Transport Law is really bad, so the subway must be built according to the Law even after changes.
The mayor wants to do these changes in such a way that the convenience of the subway is maximized. Help him to calculate the maximum possible convenience he can get!
Input
The first line contains one integer number n (1 ≤ n ≤ 100000) — the number of stations.
The second line contains n integer numbers p1, p2, ..., pn (1 ≤ pi ≤ n) — the current structure of the subway. All these numbers are distinct.
Output
Print one number — the maximum possible value of convenience.
Examples
Input
3
2 1 3
Output
9
Input
5
1 5 4 3 2
Output
17
Note
In the first example the mayor can change p2 to 3 and p3 to 1, so there will be 9 pairs: (1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3).
In the second example the mayor can change p2 to 4 and p3 to 5.
Submitted Solution:
```
from collections import defaultdict as dd
g=dd(list)
def addE(u,v):
g[u].append(v)
g[v].append(u)
n=int(input())
l=[int(x) for x in input().split()]
for i in range(n):
addE(i+1,l[i])
visited=[False]*(n+1)
def dfs(v,count):
visited[v]=True
for ch in g[v]:
if visited[ch]:
continue
count+=1
count=dfs(ch,count)
return count
ans=[]
for i in range(1,n+1):
if not visited[i]:
ans.append(dfs(i,1))
ans=sorted(ans,reverse=True)
if len(ans) > 1:
ans2=ans[0]+ans[1]
else:
ans2=ans[0]
ans2*=ans2
if len(ans) > 2:
ans2+=sum(ans[2:])
print(ans2)
``` | instruction | 0 | 9,630 | 1 | 19,260 |
No | output | 1 | 9,630 | 1 | 19,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The construction of subway in Bertown is almost finished! The President of Berland will visit this city soon to look at the new subway himself.
There are n stations in the subway. It was built according to the Bertown Transport Law:
1. For each station i there exists exactly one train that goes from this station. Its destination station is pi, possibly pi = i;
2. For each station i there exists exactly one station j such that pj = i.
The President will consider the convenience of subway after visiting it. The convenience is the number of ordered pairs (x, y) such that person can start at station x and, after taking some subway trains (possibly zero), arrive at station y (1 ≤ x, y ≤ n).
The mayor of Bertown thinks that if the subway is not convenient enough, then the President might consider installing a new mayor (and, of course, the current mayor doesn't want it to happen). Before President visits the city mayor has enough time to rebuild some paths of subway, thus changing the values of pi for not more than two subway stations. Of course, breaking the Bertown Transport Law is really bad, so the subway must be built according to the Law even after changes.
The mayor wants to do these changes in such a way that the convenience of the subway is maximized. Help him to calculate the maximum possible convenience he can get!
Input
The first line contains one integer number n (1 ≤ n ≤ 100000) — the number of stations.
The second line contains n integer numbers p1, p2, ..., pn (1 ≤ pi ≤ n) — the current structure of the subway. All these numbers are distinct.
Output
Print one number — the maximum possible value of convenience.
Examples
Input
3
2 1 3
Output
9
Input
5
1 5 4 3 2
Output
17
Note
In the first example the mayor can change p2 to 3 and p3 to 1, so there will be 9 pairs: (1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3).
In the second example the mayor can change p2 to 4 and p3 to 5.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Fri Oct 27 19:33:34 2017
@author: savit
"""
n=int(input())
a=list(map(int,input().split()))
b=[]
chains=[]
for i in range(n):
b.append(True)
for i in range(n):
if(b[i]):
chains.append([i,])
j=i
b[j]=False
while((a[j]-1)!=chains[-1][0]):
chains[-1].append(a[j]-1)
j=a[j]-1
b[j]=False
chainlen=list(map(len,chains))
if(len(chains)<1):
#print("entered")
max1=max(chainlen)
max1=chainlen.index(max1)
chainlen[max1]*=-1
max2=max(chainlen)
max2=chainlen.index(max2)
#print(max1,max2,chainlen)
chainlen[max2]=chainlen[max2]+(-1*chainlen[max1])
del chainlen[max1]
con=0
#print(chains)
#print(chainlen)
for i in chainlen:
con+=i*i
print(con)
``` | instruction | 0 | 9,631 | 1 | 19,262 |
No | output | 1 | 9,631 | 1 | 19,263 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3 | instruction | 0 | 10,243 | 1 | 20,486 |
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
#More es mi pastor nada me faltara
import sys
from collections import defaultdict
from typing import NamedTuple
class EdgeNode(NamedTuple):
vertex: int
weight: int
#vertex1: int
class Graph:
def __init__(self, n):
self.graph = d = {i: [] for i in range(n + 1)}
self.distance = [0] * (n + 1)
self.distance[0] = sys.maxsize
self.min_dist = sys.maxsize
self.summation = (n * (n + 1)) / 2
def dfs(self, root, visited=defaultdict(bool)):
stack, path = [root], []
rev = 0
visited[root] = True
while stack:
s = stack.pop()
visited[s] = True
for v in self.graph[s]:
if v[0] not in visited:
dist = self.distance[s] + v[1]
if dist < self.min_dist:
self.min_dist = dist
self.distance[v[0]] = dist
self.summation -= v[0]
if v[1] == -1:
rev += 1
path.append(s)
stack.append(v[0])
return rev
def get_min_distance(self):
return min(self.distance)
def main():
n = int(input())
g = Graph(n)
for i in range(n - 1):
x, y = map(int, input().split())
g.graph[x].append([y, 1])
g.graph[y].append([x, -1])
total_rev = g.dfs(1)
min_distance = 0 if (g.summation > 0 and g.min_dist > 0) else g.min_dist
print(total_rev + min_distance)
join = ' '.join(map(str, [i for i in range(n + 1) if g.distance[i] == min_distance]))
print(join)
main()
``` | output | 1 | 10,243 | 1 | 20,487 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3 | instruction | 0 | 10,244 | 1 | 20,488 |
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
from collections import defaultdict
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")
sys.setrecursionlimit(2*10**5)
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
@bootstrap
def dfs(u,p):
for j in adj[u]:
if j!=p:
yield dfs(j, u)
val[u]+=(val[j]+d[u,j])
yield
@bootstrap
def dfs2(u,p,v):
ans[u]=val[u]+v
for j in adj[u]:
if j != p:
yield dfs2(j,u,val[u]-val[j]-d[u,j]+v+d[j,u])
yield
n=int(input())
adj=[[] for i in range(n+1)]
d=dict()
for j in range(n-1):
u,v=map(int,input().split())
adj[u].append(v)
adj[v].append(u)
d[u,v]=0
d[v,u]=1
val=[0]*(n+1)
dfs(1,0)
ans=[0]*(n+1)
d[1,0]=0
dfs2(1,0,0)
m=min(ans[1:])
res=[]
for j in range(1,n+1):
if ans[j]==m:
res.append(j)
print(m)
print(*res)
``` | output | 1 | 10,244 | 1 | 20,489 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3 | instruction | 0 | 10,245 | 1 | 20,490 |
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
from collections import deque
def main():
n=int(input())
tree=[[] for _ in range(n+1)]
path=[set() for _ in range(n+1)]
straight=[0]*(n+1)
reverse=[0]*(n+1)
for _ in range(n-1):
a,b=map(int,input().split())
tree[a].append(b)
tree[b].append(a)
path[a].add(b)
idx=[0]*(n+1)
root=[(1,0)]
totalrev=0
while root:
x,p=root[-1]
y=idx[x]
if y==len(tree[x]):
root.pop()
else:
z=tree[x][y]
if z!=p:
root.append((z,x))
if z not in path[x]:
reverse[z]=1+reverse[x]
straight[z]=straight[x]
totalrev+=1
else:
reverse[z]=reverse[x]
straight[z]=1+straight[x]
idx[x]+=1
ans=totalrev
arr=[1]
# print(totalrev)
# print(*reverse)
# print(*straight)
# now using parent go from each node to other
for i in range(2,n+1):
temp=totalrev-reverse[i]+straight[i]
if ans>temp:
ans=temp
arr=[i]
elif ans==temp:
arr.append(i)
print(ans)
print(*arr)
#----------------------------------------------------------------------------------------
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# endregion
if __name__ == '__main__':
main()
``` | output | 1 | 10,245 | 1 | 20,491 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3 | instruction | 0 | 10,246 | 1 | 20,492 |
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
import sys
from collections import defaultdict
from typing import NamedTuple
class EdgeNode(NamedTuple):
vertex: int
weight: int
class Graph:
def __init__(self, n):
self.graph = d = {i: [] for i in range(n + 1)}
self.distance = [0] * (n + 1)
self.distance[0] = sys.maxsize
self.min_dist = sys.maxsize
self.summation = (n * (n + 1)) / 2
def dfs(self, root, visited=defaultdict(bool)):
stack, path = [root], []
rev = 0
visited[root] = True
while stack:
s = stack.pop()
visited[s] = True
for v in self.graph[s]:
if v[0] not in visited:
dist = self.distance[s] + v[1]
if dist < self.min_dist:
self.min_dist = dist
self.distance[v[0]] = dist
self.summation -= v[0]
if v[1] == -1:
rev += 1
path.append(s)
stack.append(v[0])
return rev
def get_min_distance(self):
return min(self.distance)
def main():
n = int(input())
g = Graph(n)
for i in range(n - 1):
x, y = map(int, input().split())
g.graph[x].append([y, 1])
g.graph[y].append([x, -1])
total_rev = g.dfs(1)
min_distance = 0 if (g.summation > 0 and g.min_dist > 0) else g.min_dist
print(total_rev + min_distance)
join = ' '.join(map(str, [i for i in range(n + 1) if g.distance[i] == min_distance]))
print(join)
main()
``` | output | 1 | 10,246 | 1 | 20,493 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3 | instruction | 0 | 10,247 | 1 | 20,494 |
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
#More es mi pastor nada me faltara
import sys
from collections import defaultdict
from typing import NamedTuple
class EdgeNode(NamedTuple):
vertex: int
weight: int
class Graph:
def __init__(self, n):
self.graph = d = {i: [] for i in range(n + 1)}
self.distance = [0] * (n + 1)
self.distance[0] = sys.maxsize
self.min_dist = sys.maxsize
self.summation = (n * (n + 1)) / 2
def dfs(self, root, visited=defaultdict(bool)):
stack, path = [root], []
rev = 0
visited[root] = True
while stack:
s = stack.pop()
visited[s] = True
for v in self.graph[s]:
if v[0] not in visited:
dist = self.distance[s] + v[1]
if dist < self.min_dist:
self.min_dist = dist
self.distance[v[0]] = dist
self.summation -= v[0]
if v[1] == -1:
rev += 1
path.append(s)
stack.append(v[0])
return rev
def get_min_distance(self):
return min(self.distance)
def main():
n = int(input())
g = Graph(n)
for i in range(n - 1):
x, y = map(int, input().split())
g.graph[x].append([y, 1])
g.graph[y].append([x, -1])
total_rev = g.dfs(1)
min_distance = 0 if (g.summation > 0 and g.min_dist > 0) else g.min_dist
print(total_rev + min_distance)
join = ' '.join(map(str, [i for i in range(n + 1) if g.distance[i] == min_distance]))
print(join)
main()
``` | output | 1 | 10,247 | 1 | 20,495 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3 | instruction | 0 | 10,248 | 1 | 20,496 |
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
from math import sqrt,gcd,ceil,floor,log,factorial
from itertools import permutations,combinations
from collections import Counter, defaultdict
import collections,sys,threading
import collections,sys,threading
sys.setrecursionlimit(10**9)
threading.stack_size(10**8)
def solve():
def dfs_red(node,par,dire,undire,dist,path_red,red):
dist[node]=1+dist[par]
if par in dire[node]:
path_red[node]=1+path_red[par]
red.append(1)
else:
path_red[node]=path_red[par]
for i in undire[node]:
if i!=par:
dfs_red(i,node,dire,undire,dist,path_red,red)
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().split())
def msi(): return map(str,input().split())
def li(): return list(mi())
n=ii()
dire=defaultdict(list)
undire=defaultdict(list)
dist,path_red={},{}
dist[0]=-1;path_red[0]=0
#totred=0
for _ in range(n-1):
u,v=mi()
dire[u].append(v)
undire[u].append(v)
undire[v].append(u)
#visited[i]=[0]*(n+1)
red=[]
dfs_red(1,0,dire,undire,dist,path_red,red)
totred=len(red)
ans=10**9
res=[0];fin=[]
for i in range(1,n+1):
res.append(totred-2*path_red[i]+dist[i])
ans=min(ans,totred-2*path_red[i]+dist[i])
for i in range(1,n+1):
if res[i]==ans:
fin.append(i)
print(ans)
print(*fin)
threading.Thread(target=solve).start()
``` | output | 1 | 10,248 | 1 | 20,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3 | instruction | 0 | 10,249 | 1 | 20,498 |
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 1/13/20
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def redOfTree(node, parent, g):
count = 0
for v, c in g[node]:
if v != parent:
count += c + redOfTree(v, node, g)
return count
def solve(N, A):
INF = N+100
flips = [INF for _ in range(N + 1)]
q = [(1, 0, 0)]
redCount = 0
flips[1] = 0
while q:
nq = []
for node, red, dist in q:
for v, c in A[node]:
if flips[v] == INF:
redCount += c
ndist, nred = dist + 1, red + c
flips[v] = ndist - 2 * nred
nq.append((v, nred, ndist))
q = nq
# def dfs(node, parent, red, dist):
# x = dist - 2 * red
# flips[node] = x
# ans = x
#
# for v, c in A[node]:
# if v != parent:
# ans = min(ans, dfs(v, node, red + c, dist + 1))
#
# return ans
#
# mf = dfs(1, -1, 0, 0)
mf = min(flips)
# redCount = redOfTree(1, -1, A)
vertex = [i for i, v in enumerate(flips) if v == mf]
# print(redCount)
# print(flips)
# print(vertex)
print(redCount + mf)
print(' '.join(map(str, vertex)))
N = int(input())
A = [[] for _ in range(N+1)]
for i in range(N - 1):
u, v = map(int, input().split())
A[u].append((v, 0))
A[v].append((u, 1))
solve(N, A)
``` | output | 1 | 10,249 | 1 | 20,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3 | instruction | 0 | 10,250 | 1 | 20,500 |
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
n=int(input())
t=[0]*(n+1)
u,v=[[]for i in range(n+1)],[[]for i in range(n+1)]
for i in range(n-1):
x,y=map(int,input().split())
t[y]=1
u[x].append(y)
v[y].append(x)
d, s = u[1] + v[1], len(v[1])
for i in u[1]:
t[i]=1
v[i].remove(1)
for i in v[1]:
t[i]=-1
u[i].remove(1)
while d:
b=d.pop()
for i in u[b]:
t[i]=t[b]+1
v[i].remove(b)
for i in v[b]:
t[i]=t[b]-1
u[i].remove(b)
d+=u[b]+v[b]
s+=len(v[b])
m=min(t)
print(s+m)
print(' '.join(map(str,[i for i in range(1,n+1) if t[i]==m])))
``` | output | 1 | 10,250 | 1 | 20,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3
Submitted Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
mod=10**9+7
from collections import defaultdict
def main():
n=int(input())
tree=[[] for _ in range(n+1)]
path=[set() for _ in range(n+1)]
for _ in range(n-1):
a,b=map(int,input().split())
tree[a].append(b)
tree[b].append(a)
path[a].add(b)
dist=[0]*(n+1)
d=defaultdict(int)
stack=[(1,0,0)]
# assuming root 1
idx=[0]*(n+1)
totalGreen=0
while stack:
x,p,g=stack[-1]
y=idx[x]
if y==len(tree[x]):
d[x]=g
stack.pop()
else:
z=tree[x][y]
if z!=p:
if z in path[x]:
g+=1
totalGreen+=1
stack.append((z,x,g))
dist[z]=1+dist[x]
idx[x]+=1
totalRed=n-1-totalGreen
res=[0]*(n+1)
ans=10**10
for i in range(1,n+1):
res[i]=(d[i]<<1)+totalRed-dist[i]
ans=min(ans,res[i])
print(ans)
for i in range(1,n+1):
if res[i]==ans:
print(i,end=" ")
print()
#----------------------------------------------------------------------------------------
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# endregion
if __name__ == '__main__':
main()
``` | instruction | 0 | 10,251 | 1 | 20,502 |
Yes | output | 1 | 10,251 | 1 | 20,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
#range = xrange # not for python 3.0+
# main code
n=int(raw_input())
d=[[] for i in range(n+1)]
for i in range(n-1):
u,v=in_arr()
d[u].append((v,0))
d[v].append((u,1))
totr=0
dp=[[0,0] for i in range(n+1)]
q=[1]
vis=[0]*(n+1)
vis[1]=1
q=[1]
pos=0
while pos<n:
x=q[pos]
pos+=1
for i,w in d[x]:
if not vis[i]:
vis[i]=1
q.append(i)
dp[i][0]=dp[x][0]+1
dp[i][1]=dp[x][1]
if w:
totr+=1
dp[i][1]+=1
#ans=defaultdict(list)
mn=10**18
for i in range(1,n+1):
temp=totr-(2*dp[i][1])+dp[i][0]
#ans[temp].append(i)
mn=min(mn,temp)
pr_num(mn)
for i in range(1,n+1):
temp=totr-(2*dp[i][1])+dp[i][0]
#ans[temp].append(i)
if temp==mn:
pr(str(i)+' ')
#pr_arr(ans[mn])
``` | instruction | 0 | 10,252 | 1 | 20,504 |
Yes | output | 1 | 10,252 | 1 | 20,505 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3
Submitted Solution:
```
#TESTING ANOTHER SOLUTION FOR TIME LIMIT
n = int(input())
t = [0] * (n + 1)
u, v = [[] for i in range(n + 1)], [[] for i in range(n + 1)]
for i in range(n - 1):
a, b = map(int, input().split())
t[b] = 1
u[a].append(b)
v[b].append(a)
d, s = u[1] + v[1], len(v[1])
for i in u[1]:
t[i] = 1
v[i].remove(1)
for i in v[1]:
t[i] = -1
u[i].remove(1)
while d:
b = d.pop()
x, y = t[b] + 1, t[b] - 1
for i in u[b]:
t[i] = x
v[i].remove(b)
for i in v[b]:
t[i] = y
u[i].remove(b)
d += u[b] + v[b]
s += len(v[b])
m = min(t)
print(s + m)
print(' '.join(map(str, [i for i in range(1, n + 1) if t[i] == m])))
``` | instruction | 0 | 10,253 | 1 | 20,506 |
Yes | output | 1 | 10,253 | 1 | 20,507 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3
Submitted Solution:
```
from sys import stdin, stdout
input = stdin.readline
n = int(input())
mn = n
e, down, up = {(1, 0)}, [0] * (n + 1), [0] * (n + 1)
g = {x: [] for x in range(1, n + 1)}
for i in range(n - 1):
a, b = map(int, input().split())
e.add((a, b))
g[a].append(b)
g[b].append(a)
q = [(0, 1)]
trav = [(0, 1)]
while q:
p, v = q.pop()
for ch in g[v]:
if ch != p:
q.append((v, ch))
trav.append((v, ch))
for p, v in trav[::-1]:
down[v] = sum(down[ch] + ((v, ch) not in e) for ch in g[v] if ch != p)
up[0] = down[1] + 1
q = [(0, 1)]
while q:
p, v = q.pop()
up[v] = down[p] + up[p] - down[v] + [1, -1][(v, p) in e]
if down[v] + up[v] < mn:
ans, mn = [v], down[v] + up[v]
elif down[v] + up[v] == mn:
ans.append(v)
for ch in g[v]:
if ch != p:
q.append((v, ch))
print(mn)
stdout.write(' '.join(str(i) for i in sorted(ans)))
``` | instruction | 0 | 10,254 | 1 | 20,508 |
Yes | output | 1 | 10,254 | 1 | 20,509 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3
Submitted Solution:
```
import sys
from collections import defaultdict
from typing import NamedTuple
class EdgeNode(NamedTuple):
vertex: int
weight: int
class Graph:
def __init__(self, n):
self.graph = defaultdict(list)
self.distance = (n + 1) * [0]
self.distance[0] = sys.maxsize
def add_edge(self, u, v, weight=0):
self.graph[u].append(EdgeNode(vertex=v, weight=weight))
def dfs(self, root, visited=defaultdict(bool)):
stack, path = [root], []
rev = 0
while stack:
s = stack.pop()
if s in path:
continue
path.append(s)
for v in self.graph[s]:
stack.append(v.vertex)
self.distance[v.vertex] = self.distance[s] + v.weight
if v.weight == -1:
rev = rev + 1
return rev
def get_min_distance(self):
return min(self.distance)
#sys.stdin = open('input.txt', 'r')
n = int(input())
g = Graph(n)
for i in range(n - 1):
x, y = map(int, input().split())
g.add_edge(x, y, 1)
g.add_edge(y, x, -1)
total_rev = g.dfs(1)
min_distance = g.get_min_distance()
print(total_rev + min_distance - 1)
print(' '.join(map(str, [i for i in range(n + 1) if g.distance[i] == min_distance])))
``` | instruction | 0 | 10,255 | 1 | 20,510 |
No | output | 1 | 10,255 | 1 | 20,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3
Submitted Solution:
```
import typing
#219D
totalRed = 0
t = 0
#adj(u)= <v,1> = v en sentido directo (u,v), <j,0> = j en
# sentido opuesto (j, u)
def dfs(u):
global t,totalRed
t += 1
d[u] = t
for p in adj[u]: #adj[]son <v, (0 v 1)> v el vert adj y el 2do valor si la arista es roja
v = p[0]
red = p[1] == 0;
if d[v] == 0:
dist[v] = dist[u] + 1
if red :#aumento actualizo total y rojas de raiz a v
totalRed += 1
redsUntil[v] = redsUntil[u] + 1
dfs(v)
t += 1
f[u] = t
def solve():
dfs(0)
min = 1e9
list = []
for i in range(0, n):
toChange = dist[i] + totalRed - 2*redsUntil[i]
if toChange < min:
min = toChange
list = [i]
elif toChange == min:
list.append(i)
return (min, list)
#read/////////////////////
n = input()
n = int(n)
t = 0
dist = [0 for x in range(0, n)]
f = [0 for x in range(0, n)]
d = [0 for x in range(0, n)]
redsUntil = [0 for x in range(0, n)]
adj = [[] for x in range(0, n)]
for i in range(0, n-1):
a, b = [x for x in input().split()]
a = int(a)
b = int(b)
a-=1
b-=1
adj[a].append((b, 1))
adj[b].append((a, 0))
#/////////////----////////
#Process
dfs(0)
min = 1e9
list = []
for i in range(0, n):
toChange = dist[i] + totalRed - 2*redsUntil[i]#Calculo aristas a cambiar para cada vert
if toChange < min:#nuevo min
min = toChange
list = [i]
elif toChange == min:
list.append(i)
#Out//////////////////////
print(min)
print(' '.join([str(a+1) for a in list]))
# out = []
# for i in range(0, len(list)):
# print(list[i] + 1)
``` | instruction | 0 | 10,256 | 1 | 20,512 |
No | output | 1 | 10,256 | 1 | 20,513 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3
Submitted Solution:
```
#TESTING @Emberald for time limit
# w, h = map(int, input().split())
# to_zero_based = lambda x: int(x) - 1
def main():
n = int(input())
cities = {i : {} for i in range(n)}
to_zero_based = lambda x: int(x) - 1
for _ in range(n - 1):
s, t = map(to_zero_based, input().split())
cities[s][t] = True
cities[t][s] = False
ipivot = 0
invs_if_capital = 0
stack = [ipivot]
visited = set()
path = []
while stack:
icity = stack.pop()
visited.add(icity)
path.append((icity, None))
for ineighbor, goto in cities[icity].items():
if ineighbor in visited:
continue
if not goto:
invs_if_capital += 1
stack.append(ineighbor)
path.append((ineighbor, goto))
invs_if_capitals = {ipivot : invs_if_capital}
icity = None
for index, goto in path:
if goto is None:
icity = index
else:
invs_if_capitals[index] = invs_if_capitals[icity] + (1 if goto else -1)
min_invs = min(invs_if_capitals.values())
mins = [str(i + 1) for i, invs in invs_if_capitals.items() if invs == min_invs]
print(min_invs)
print(' '.join(mins))
main()
``` | instruction | 0 | 10,257 | 1 | 20,514 |
No | output | 1 | 10,257 | 1 | 20,515 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3
Submitted Solution:
```
import sys
from collections import defaultdict
from typing import NamedTuple
class EdgeNode(NamedTuple):
vertex: int
weight: int
class Graph:
def __init__(self, n):
self.graph = d = {i: [] for i in range(n + 1)}
self.distance = [0] * (n + 1)
self.distance[0] = sys.maxsize
self.min_dist = sys.maxsize
self.summation = (n * (n + 1)) / 2
def add_edge(self, u, v, weight=0):
self.graph[u].append(EdgeNode(vertex=v, weight=weight))
def dfs(self, root, visited=defaultdict(bool)):
stack, path = [root], []
rev = 0
visited[root] = True
while stack:
s = stack.pop()
visited[s] = True
for v in self.graph[s]:
if v.vertex not in visited:
dist = self.distance[s] + v.weight
if dist < self.min_dist:
self.min_dist = dist
self.distance[v.vertex] = dist
self.summation -= v.vertex
if v.weight == -1:
rev += 1
path.append(s)
stack.append(v.vertex)
return rev
def get_min_distance(self):
return min(self.distance)
# sys.stdin = open('input.txt', 'r')
n = int(input())
g = Graph(n)
for i in range(n - 1):
x, y = map(int, input().split())
g.add_edge(x, y, 1)
g.add_edge(y, x, -1)
total_rev = g.dfs(1)
min_distance = 0 if g.summation > 0 else g.min_dist
print(total_rev + min_distance)
print(' '.join(map(str, [i for i in range(n + 1) if g.distance[i] == min_distance])))
``` | instruction | 0 | 10,258 | 1 | 20,516 |
No | output | 1 | 10,258 | 1 | 20,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353 | instruction | 0 | 10,354 | 1 | 20,708 |
Tags: implementation, math
Correct Solution:
```
#!/usr/bin/env python
from sys import stdin, stderr
from math import sqrt
EPS = 1e-9
def position_at_time(t, acceletarion, initial_speed, initial_position):
return 0.5*acceletarion*t*t + initial_speed*t + initial_position
def time_to_reach_speed(final_speed, initial_speed, acceletarion):
return abs(float(final_speed - initial_speed)) / acceletarion
def time_to_travel_distance(distance_to_travel, initial_speed, acceletarion):
return ( -initial_speed +
sqrt(initial_speed*initial_speed + 2*acceletarion*distance_to_travel)
) / acceletarion
#
# Main
#
a, v = map(int, stdin.readline().split())
l, d, w = map(int, stdin.readline().split())
res = 0.0
vd = w
if w >= v:
t = time_to_reach_speed(v, 0, a)
x = position_at_time(t, a, 0, 0)
if x >= d - EPS:
t = time_to_travel_distance(d, 0, a)
res += t
vd = a*t
else:
res += t + (d - x)/v
vd = v
else:
t = time_to_reach_speed(w, 0, a)
x = position_at_time(t, a, 0, 0)
if x >= d - EPS:
t = time_to_travel_distance(d, 0, a)
res += t
vd = a*t
else:
ts = time_to_reach_speed(v, 0, a)
ds = position_at_time(ts, a, 0, 0)
tf = time_to_reach_speed(v, w, a)
df = position_at_time(tf, a, w, 0)
if ds + df <= d + EPS:
res = ts + (d - ds - df) / v + tf
else:
lo = w
hi = v
for tt in range(80):
mid = (lo + hi)/2.0
ts = time_to_reach_speed(mid, 0, a)
ds = position_at_time(ts, a, 0, 0)
tf = time_to_reach_speed(mid, w, a)
df = position_at_time(tf, -a, mid, 0)
if ds + df > d + EPS:
hi = mid
else:
lo = mid
res = time_to_reach_speed(lo, 0, a) + time_to_reach_speed(lo, w, a)
vd = w
t = time_to_reach_speed(v, vd, a)
x = position_at_time(t, a, vd, d)
if x >= l - EPS:
res += time_to_travel_distance(l-d, vd, a)
else:
res += t + (l - x)/v
print("%.12f" % (res))
``` | output | 1 | 10,354 | 1 | 20,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353 | instruction | 0 | 10,355 | 1 | 20,710 |
Tags: implementation, math
Correct Solution:
```
from math import sqrt
a, v = map(int, input().split())
l, d, w = map(int, input().split())
w = min(v, w)
lowtime = (v - w) / a
lowdist = v * lowtime - a * lowtime**2 / 2
startdist = v**2 / (2 * a)
if startdist + lowdist <= d:
ans = v / a + (d - startdist - lowdist) / v + lowtime
elif w**2 <= 2 * d * a:
u = sqrt(a * d + w**2 / 2)
ans = (2 * u - w) / a
else:
ans = sqrt(2 * d / a)
w = ans * a
hightime = (v - w) / a
highdist = w * hightime + a * hightime**2 / 2
if highdist <= l - d:
ans += hightime + (l - d - highdist) / v
else:
disc = sqrt(w**2 + 2 * a * (l - d))
ans += (disc - w) / a
print('%.7f' % ans)
``` | output | 1 | 10,355 | 1 | 20,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353 | instruction | 0 | 10,356 | 1 | 20,712 |
Tags: implementation, math
Correct Solution:
```
a, v = map(int, input().split())
l, d, w = map(int, input().split())
t1, t2 = 0, 0
vt = (d * 2 * a) ** 0.5
v_max = min(v, w)
if vt < min(v, w):
t1 = (2 * d / a) ** 0.5
v_max = v
v0 = vt
else:
v_mid = min((((2 * a * d) + v_max ** 2) * 0.5) ** 0.5, v)
t1 = v_mid / a + (v_max - v_mid) / (-a)
s1 = d - (2 * v_mid ** 2 - v_max ** 2) / 2 / a
t1 += s1 / v_mid
v0 = v_max
v_max = v
d = l - d
vt = (v0 ** 2 + 2 * a * d) ** 0.5
if vt < v_max:
t2 = 2 * d / (v0 + vt)
else:
t2 = (v_max - v0) / a
d -= (v_max + v0) / 2 * t2
t2 += d / v_max
print('%.8f' %(t1 + t2))
``` | output | 1 | 10,356 | 1 | 20,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353 | instruction | 0 | 10,357 | 1 | 20,714 |
Tags: implementation, math
Correct Solution:
```
a,v=map(int,input().split())
l,d,w=map(int,input().split())
t=0
def gett(a,b,c):
delta=b**2-4*a*c
t1=(-b+delta**(1/2))/(2*a)
t2=(-b-delta**(1/2))/(2*a)
if min(t1,t2)>0:
return min(t1,t2)
else:
return max(t1,t2)
if 2*a*d<=w*w or v<=w:
if 2*a*l<=v*v:
t=(2*l/a)**(1/2)
else:
t=l/v+v/a/2
else:
tmp=d-1/2*v*v/a+1/2*(v-w)**2/a-v*(v-w)/a
if tmp<=0:
tmp2=l-d-(1/2*(v-w)**2/a+w*(v-w)/a)
if tmp2>=0:
t=tmp2/v+(v-w)/a+2*gett(a,2*w,w*w/(2*a)-d)+w/a
else:
t=gett(a/2,w,d-l)+2*gett(a,2*w,w*w/(2*a)-d)+w/a
else:
tmp2=l-d-(1/2*(v-w)**2/a+w*(v-w)/a)
if tmp2>=0:
t=tmp2/v+(v-w)/a+(2*v-w)/a+tmp/v
else:
t=gett(a/2,w,d-l)+(2*v-w)/a+tmp/v
print("%.12f" %(t))
``` | output | 1 | 10,357 | 1 | 20,715 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353 | instruction | 0 | 10,358 | 1 | 20,716 |
Tags: implementation, math
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sun Mar 4 22:28:47 2018
@author: hp
"""
[a,v] = [eval(x) for x in str.split(input())]
[l,d,w] = [eval(x) for x in str.split(input())]
if v <= w:
if v ** 2 >= 2 * a *l:
#accer all the way
t = (2 * l / a) ** 0.5
else:
#accer to v,then drive with v
s1 = v ** 2 / (2 * a)
t1 = v / a
s2 = l - s1
t2 = s2 / v
t = t1 + t2
else:
if w ** 2 >= 2 * a * d:
#accer all the way to d
if v ** 2 >= 2 * a *l:
#accer all the way
t = (2 * l / a) ** 0.5
else:
#accer to v,then drive with v
s1 = v ** 2 / (2 * a)
t1 = v / a
s2 = l - s1
t2 = s2 / v
t = t1 + t2
else:
if (2 * a * d + w ** 2) / 2 <= v ** 2:
#drive to speed v1 and dec to w,after drive to d,then accer
v1 = ((2 * a * d + w ** 2) / 2) ** 0.5
t1 = v1 / a
t2 = (v1 - w) / a
else:
#accer to v,then keep,then dec to w
t1 = v / a + (v - w) / a
t2 = (d - v ** 2 / (2 * a) - (v ** 2 - w ** 2) / (2 * a)) / v
#judge if we can accer to v
if v ** 2 - w ** 2 >= 2 * a * (l - d):
#accer all the left
t3 = ( -w + (w ** 2 + 2 * a * (l - d)) ** 0.5) / a
t = t1 + t2 + t3
else:
#accert to v,then v
t3 = (v - w) / a
s3 = w * t3 + a * t3 ** 2 / 2
t4 = (l - d - s3) / v
t = t1 + t2 + t3 + t4
print("%.10f" %(t))
``` | output | 1 | 10,358 | 1 | 20,717 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353 | instruction | 0 | 10,359 | 1 | 20,718 |
Tags: implementation, math
Correct Solution:
```
import math
a, v = map(float, input().split())
l, d, w = map(float, input().split())
res = 0.0
if v <= w:
t1 = v / a
d1 = 0.5*a*t1*t1
if d1 >= l:
res = math.sqrt(l*2/a)
else:
t2 = (l - d1) / v
res = t1 + t2
else:
t1 = w / a
d1 = 0.5*a*t1*t1
# print(d1)
if d1 >= d:
t1 = math.sqrt(d*2/a)
cur = t1 * a
t2 = (v - cur) / a
d2 = 0.5*a*t2*t2 + cur*t2
if d2 >= l - d:
# print('A')
res = math.sqrt(l*2/a)
else:
# print('B')
t1 = v / a
t2 = (l - 0.5*a*t1*t1) / v
res = t1 + t2
else:
t1 = math.sqrt(d/a + w*w/(2*a*a))
t2 = (t1*a - w) / a
if t1 * a > v:
t1 = v / a
tx = (v - w) / a
mid = d - 0.5*a*t1*t1 - (0.5*(-a)*tx*tx+v*tx)
t2 = tx + mid / v
t3 = (v - w) / a
d3 = 0.5*a*t3*t3 + w*t3
if d3 >= l - d:
# print('C')
t3 = (-w + math.sqrt(w*w - 4*0.5*a*(-(l-d)))) / a
# print(t1, t2, t3)
# t3 = 8.965874696353 - 8.0 - 0.24
# print(0.5*a*t3*t3 + w*t3, l-d)
res = t1 + t2 + t3
else:
# print('D')
t3 = (v - w) / a
d3 = 0.5*a*t3*t3 + w*t3
t4 = (l - d - d3) / v
# print(t1, t2, t3, t4)
res = t1 + t2 + t3 + t4
print(res)
``` | output | 1 | 10,359 | 1 | 20,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353 | instruction | 0 | 10,360 | 1 | 20,720 |
Tags: implementation, math
Correct Solution:
```
import math
def getdt():
return map(int, input().split())
def calc(v0, v, a, x):
t = (v - v0) / a
x0 = v0 * t + 0.5 * a * t * t
if x0 >= x:
return (x, (math.sqrt(v0 * v0 + 2 * a * x) - v0) / a)
return (x0, t)
def go(v0, v, a, x):
x0, t = calc(v0, v, a, x)
return t + (x - x0) / v
a, v = getdt()
l, d, w = getdt()
if w > v:
w = v
x, t = calc(0, w, a, d)
if x == d:
print(go(0, v, a, l))
else:
print(t + go(w, v, a, (d - x) * 0.5) * 2 + go(w, v, a, l - d))
``` | output | 1 | 10,360 | 1 | 20,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353 | instruction | 0 | 10,361 | 1 | 20,722 |
Tags: implementation, math
Correct Solution:
```
from math import sqrt
a, v = map(int, input().split())
l, d, w = map(int, input().split())
def findt(u, v, a, dist):
front = (v*v-u*u)/(2*a)
if front > dist:
return (sqrt(u*u+2*a*dist)-u)/a
return (v-u)/a + (dist-front)/v
def solve(a, v, l, d, w):
if v <= w or 2*a*d <= w*w:
return findt(0, v, a, l)
after = findt(w, v, a, l-d)
peak = sqrt(a*d + w*w/2)
if peak > v:
travel = (v*v-w*w/2)/a
before = (2*v-w)/a + (d-travel)/v
else:
before = (2*peak-w)/a
return before + after
print(f'{solve(a, v, l, d, w):.8f}')
``` | output | 1 | 10,361 | 1 | 20,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353
Submitted Solution:
```
__author__ = 'Darren'
def solve():
a, v = map(int, input().split())
l, d, w = map(int, input().split())
total_time = 0.0
if v >= w:
if w*w >= 2*a*d:
x = (2*a*d) ** 0.5
total_time = x / a
if v*v - x*x >= 2*a*(l-d):
total_time += (-2*x + (4*x*x + 8*a*(l-d)) ** 0.5) / (2*a)
else:
total_time += (v-x)/a + (l-d-(v*v-x*x)/(2*a))/v
else:
if 2*v*v - w*w <= 2*a*d:
total_time = v/a + (v-w)/a + (d-(2*v*v-w*w)/(2*a))/v
else:
x = ((2*a*d+w*w)/2) ** 0.5
total_time = x/a + (x-w)/a
if v*v - w*w >= 2*a*(l-d):
total_time += (-2*w + (4*w*w+8*a*(l-d)) ** 0.5) / (2*a)
else:
total_time += (v-w)/a + (l-d-(v*v-w*w)/(2*a))/v
else:
if v*v >= 2*a*l:
total_time = (l*2/a) ** 0.5
else:
total_time = v/a + (l-v*v/(2*a))/v
print('%.10f' % total_time)
if __name__ == '__main__':
solve()
``` | instruction | 0 | 10,362 | 1 | 20,724 |
Yes | output | 1 | 10,362 | 1 | 20,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353
Submitted Solution:
```
from math import sqrt
import sys
from typing import List, Union
def rl(int_: bool = True, is_split: bool = True) -> Union[List[str], List[int]]:
if int_:
return [int(w) for w in sys.stdin.readline().split()]
if is_split:
return [w for w in sys.stdin.readline().split()]
return sys.stdin.readline().strip()
a, v = rl()
l, d, w = rl()
def time(u, s, a, v):
vs = sqrt(u * u + 2 * a * s)
# print("vs", vs)
if vs <= v:
return (vs - u) / a
elif vs > v:
dv = (v * v - u * u) / (2 * a)
# print("dv", dv)
if dv >= s:
vd = sqrt(u * u + 2 * a * s)
# print(vd)
return (vd - u) / a
else:
return ((v - u) / a) + ((s - dv) / v)
if w >= v:
print(time(0, l, a, v))
elif w < v:
vd = sqrt(2 * a * d)
# print("vd", vd)
if vd <= w:
print(time(0, l, a, v))
elif vd > w:
v_ = sqrt((w * w + 2 * a * d) / 2)
# print(v_)
if v_ <= v:
td = (v_ / a) + ((v_ - w) / a)
elif v_ > v:
td = (v / a) + ((d - ((2 * v * v - w * w) / (2 * a))) / v) + ((v - w) / a)
print(td + time(w, l - d, a, v))
``` | instruction | 0 | 10,363 | 1 | 20,726 |
Yes | output | 1 | 10,363 | 1 | 20,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353
Submitted Solution:
```
import logging
logging.basicConfig(level=logging.INFO)
def readintGenerator():
while (True):
n=0
tmp=list(map(lambda x:int(x), input().split()))
m=len(tmp)
while (n<m):
yield(tmp[n])
n+=1
readint=readintGenerator()
a=next(readint)
v=next(readint)
l=next(readint)
d=next(readint)
w=next(readint)
def sqrt(x): return x**0.5
def cost(v0,l,v,a):
s0=(v**2 - v0**2)/(2*a)
if (s0<=l):
return (v-v0)/a + (l-s0)/v
else:
v1=sqrt(v0**2+2*a*l)
return (v1-v0)/a
def calc(a,v,l,d,w):
if (v<=w):
return cost(0,l,v,a)
else:
v0=sqrt(2*a*d)
if (v0<=w):
return cost(0,l,v,a)
else:
v1=sqrt((2*a*d+w**2)/2)
t0=(2*v1-w)/a
if (v1<=v):
return t0+cost(w,l-d,v,a)
else:
t0=(d+(2*v**2-2*v*w+w**2)/(2*a))/v
return t0+cost(w,l-d,v,a)
print("%.8f" %calc(a,v,l,d,w))
``` | instruction | 0 | 10,364 | 1 | 20,728 |
Yes | output | 1 | 10,364 | 1 | 20,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353
Submitted Solution:
```
#!/usr/bin/env python
"""
CodeForces: 5D Follow Trafic Rules
Basic equations for acceleration, distance and velocity (speed):
eqn-1) final velocity: v = v0 + a * t
eqn-2) distance traveled: d = v0 * t + a * t * t / 2
eqn-3) acceleration: v * v - v0 * v0 = 2 * a * d
Symbols stand for:
a: acceleration
d: distance traveled
t: travel time
v0: initial speed
v: final speed
"""
from math import sqrt
def main():
a, v = map(int, input().split())
l, d, w = map(int, input().split())
# if v <= w, virtually no speed limit
if v <= w:
w = v
# there are three cases before reaching the sign:
# Case 1: unable to drive over the speed limit
# i.e. no need to decelerate during the travel
# Case 2: able to drive over the speed limit
# Case 2a: able to drive at the max speed
# i.e. accelerate and deceleration
# Case 2b: unable to drive at the max speed
# i.e. find the possible max speed, then same as case 2a
ax2 = a * 2
vxv = v * v
wxw = w * w
ax2xd = ax2 * d
# eqn-3:
# d1 = travel distance to reach the speed limit
# w * w - 0 * 0 = 2 * a * d1
# if d1 >= d or v == w, then Case 1
# otherwise Case 2
if wxw >= ax2xd or v == w:
# Case 1: unable to drive over the speed limit
# check if able to drive at the max spped before reaching the goal
# eqn-3:
# m = distance to reach the max speed
# v * v - 0 * 0 = 2 * a * m
# if m <= l (distance to the goal), then
# 2 * a * s <= 2 * a * l
# v * v <= 2 * a * l
if vxv <= ax2 * l:
# able to drive at the max speed
# eqn-1:
# t1 = time to reach the max speed
# v = a * t1
# eqn-3:
# d1 = distance traveled to reach the max speed
# v * v = 2 * a * d1
# equation:
# d2 = remaining distance = l - d1
# t2 = remaining time
# d2 = v * t2
hours = (v / a) + ((l - (vxv / ax2)) / v)
else:
# unable to drive at the max speed
# eqn-2: time of the entire travel
# l = a * t * t / 2
hours = sqrt(2.0 * l / a)
else:
# Case 2: able to drive over the speed limit
# there are three steps:
# Step 1: find the possible max speed and
# travel distance at that speed
# Step 1a: Case 2a
# Step 1b: Case 2b
# Step 2: calculate the time to the sing
# Step 3: calculate the time after the sign
# Step 1: find the possible max speed (p)
# and the distance travels (r) at the possible max speed
# eqn-3:
# d1 = distance to the max speed (acceleration)
# d2 = distance to the speed limit (deceleration)
# v * v - 0 * 0 = 2 * a * d1
# v * v - w * w = 2 * a * d2 <-- w * w - v * v = 2 * (-a) * d2
# add two equations:
# v * v + (v * v - w * w) = 2 * a * (d1 + d2)
# if (d1 + d2) <= d, then Case 2a
# otherwise Case 2b
vxv_wxw = vxv - wxw
s = vxv + vxv_wxw
if s <= ax2xd:
# Case 2a: able to drive at the max speed
# i.e. find the distance travels (r) at the max speed
# eqn-3:
# v * v + (v * v - w * w) = 2 * a * (d1 + d2)
# d1 + d2 + r = d
p = v
r = d - (s / ax2)
else:
# Case 2b: unable to drive at the max speed
# i.e. find the possible max speed (p)
# eqn-3:
# d1 = distance to reach the possible max speed
# d2 = distance to reach the speed limit
# p = possible max speed when d1 + d2 == d
# p * p - 0 * 0 = 2 * a * d1
# p * p - w * w = 2 * a * d2 <-- w * w - p * p = 2 * (-a) * d2
# add two equation
# 2 * (p * p) - (w * w) = 2 * a * (d1 + d2)
p = sqrt((ax2xd + wxw) * 0.5)
r = 0
# Step 2: calculate the time to the sign
# Time to reach the sign
# eqn-2:
# t1, d1 = time and distance to reach the possible max speed
# t2, d2 = time and distance to reach the speed limit
# p = 0 + a * t1
# p - w = a * t2 <-- w = p + (-a) * t2
# add two equations:
# p + (p - w) = a * (t1 + t2)
# equation:
# r = travel distance at the possible max speed
# t3 = travel time at the possible max speed
# r = p * t3
hours = ((p + (p - w)) / a) + (r / p)
# Step 3: time after the sign
# Check if able to drive at the max speed
# eqn-2:
# d1 = distance to reach the max speed
# v * v - w * w = 2 * a * d1
# if d1 >= d, able to drive at the max speed
# else possible reach the max speed
g = l - d
s = ax2 * g
if vxv_wxw >= s:
# reach the goal before reaching the max speed
# eqn-2:
# g = remaining distance
# t1 = time to the goal
# g = l - d = w * t1 + a * t1 * t1 / 2
# solve the equation for t1 (positive):
# t1 = (sqrt(2 * a * g - w * w) - w) / a
hours += (sqrt(s + wxw) - w) / a
else:
# possible to reach the max before reaching the goal
# eqn-1:
# t1 = time to reach the max speed
# v = w + a * t1
# eqn-3:
# d1 = distance to reach the max speed
# v * v - w * w = 2 * a * d1
# equation:
# d2 = remaining distance after reaching the max speed
# t2 = time after reaching the max speed
# d2 = g - d1 = v * t2
hours += ((v - w) / a) + ((g - (vxv_wxw / ax2)) / v)
print("{:.12f}".format(hours))
if __name__ == '__main__':
main()
``` | instruction | 0 | 10,365 | 1 | 20,730 |
Yes | output | 1 | 10,365 | 1 | 20,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353
Submitted Solution:
```
from math import *
a,v=list(map(int,input().split()))
l,d,w=list(map(int,input().split()))
if v>w:
s1=w**2/2/a
if d<=s1:
t=sqrt(2*d/a)
else:
t=sqrt(2*s1/a)
s2=min((d-s1)/2,(v**2-w**2)/(2*a))
if s2==(d-s1)/2:
t+=2*(sqrt(2*(s1+s2)/a)-sqrt(2*s1/a))
else:
t+=2*(v-w)/a+(d-s1-2*s1)/v
s3=min((v**2-w**2)/2/a,l-d)
t+=sqrt(2*(s3+s1)/a)-sqrt(2*s1/a)+(l-d-s3)/v
else:
s=min(v**2/2/a,l)
t=sqrt(2*s/a)+(l-s)/v
print(t)
``` | instruction | 0 | 10,366 | 1 | 20,732 |
No | output | 1 | 10,366 | 1 | 20,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353
Submitted Solution:
```
from math import sqrt
import sys
from typing import List, Union
def rl(int_: bool = True, is_split: bool = True) -> Union[List[str], List[int]]:
if int_:
return [int(w) for w in sys.stdin.readline().split()]
if is_split:
return [w for w in sys.stdin.readline().split()]
return sys.stdin.readline().strip()
a, v = rl()
l, d, w = rl()
def time(u, s, a, v):
vs = sqrt(u * u + 2 * a * s)
# print("vs", vs)
if vs <= v:
return (vs - u) / a
elif vs > v:
dv = (v * v - u * u) / (2 * a)
# print("dv", dv)
if dv >= s:
vd = sqrt(u * u + 2 * a * s)
# print(vd)
return (vd - u) / a
else:
return ((v - u) / a) + ((s - dv) / v)
if w >= v:
print(time(0, l, a, v))
elif w < v:
vd = sqrt(2 * a * d)
# print("vd", vd)
if vd <= w:
print(time(0, l, a, v))
elif vd > w:
v_ = sqrt((w * w + 2 * a * d) / 2)
# print(v_)
if v_ <= v:
td = (v_ / a) + ((v_ - w) / a)
elif v_ > v:
td = (v / a) + ((d - ((2 * v * v - w * w) / 2 * a)) / v) + ((v - w) / a)
print(td + time(w, l - d, a, v))
``` | instruction | 0 | 10,367 | 1 | 20,734 |
No | output | 1 | 10,367 | 1 | 20,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353
Submitted Solution:
```
# -*-coding:utf-8 -*-
import math
a,v=map(float,input().split())
l,d,w=map(float,input().split())
ans=0
if v<w:
t0=v/float(a)
t1=(l-(a*t0**2)/2.0)/float(v)
ans=t0+t1
elif a*math.sqrt(2.0*d/a)<w:
t0=v/float(a)
l1=(a*t0**2)/2
if l1>=l:
ans=math.sqrt(2.0*l/a)
else:
t1=(l-l1)/float(v)
ans=t0+t1
else:
t0=(-3*w+math.sqrt(5*w**2+8*a*d))/(2*a)
t1=(w+a*t0)/float(a)
t2=(v-w)/float(a)
if ((w+a*t1)/2)*t1<(l-d):
t3=((l-d)-(((w+a*t1)/2)*t1))/float(v)
ans=t0+t1+t2+t3
else:
t2=((-w)+math.sqrt(w**2+8*a*(l-d)))/(2*a)
ans=t0+t1+t2
print(ans)
``` | instruction | 0 | 10,368 | 1 | 20,736 |
No | output | 1 | 10,368 | 1 | 20,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353
Submitted Solution:
```
from math import sqrt
a, v = map(int, input().split())
l, d, w = map(int, input().split())
lowtime = max(0, v - w) / a
lowdist = v * lowtime - a * lowtime**2 / 2
startdist = v**2 / (2 * a)
if startdist + lowdist <= d:
ans = v / a + (d - startdist - lowdist) / v + lowtime
else:
u = sqrt(a * d + w**2 / 2)
ans = u / a
if u > w:
ans += (u - w) / a
w = min(u, w)
highdist = min(v, w) * lowtime + a * lowtime**2 / 2
if highdist <= l - d:
ans += lowtime + (l - d - highdist) / v
else:
disc = sqrt(w**2 + 2 * a * (l - d))
ans += (disc - w) / a
print('%.7f' % ans)
``` | instruction | 0 | 10,369 | 1 | 20,738 |
No | output | 1 | 10,369 | 1 | 20,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second). | instruction | 0 | 10,402 | 1 | 20,804 |
Tags: brute force, data structures, implementation, trees
Correct Solution:
```
#!/usr/bin/env python3
import collections
def lca(u, v):
ub = bin(u)[2:]
vb = bin(v)[2:]
r = 0
for i, (a, b) in enumerate(zip(ub, vb)):
if a != b:
break
r = r * 2 + int(a)
return r
def add(cost, n, root, w):
while n > root:
cost[n] += w
n //= 2
def get(cost, n, root):
r = 0
while n > root:
r += cost[n]
n //= 2
return r
if __name__ == '__main__':
q = int(input())
cost = collections.Counter()
for _ in range(q):
cmd = list(map(int, input().split()))
if cmd[0] == 1:
v, u, w = cmd[1:]
root = lca(v, u)
add(cost, v, root, w)
add(cost, u, root, w)
else:
v, u = cmd[1:]
root = lca(v, u)
print(get(cost, v, root) + get(cost, u, root))
``` | output | 1 | 10,402 | 1 | 20,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second). | instruction | 0 | 10,403 | 1 | 20,806 |
Tags: brute force, data structures, implementation, trees
Correct Solution:
```
#########################################################################################################\
#########################################################################################################
###################################The_Apurv_Rathore#####################################################
#########################################################################################################
#########################################################################################################
import sys,os,io
from sys import stdin
from collections import defaultdict
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
else:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = 1
t = int(input())
costEdge = defaultdict(lambda:0)
for _ in range(t):
query = [int(x) for x in input().split()]
u = query[1]
v = query[2]
parents = {}
while(u):
parents[u]=1
u//=2
lca = -1
path1 = []
while(v):
path1.append(v)
if v in parents:
lca = v
break
v//=2
u = query[1]
path2 = []
while(u!=lca):
path2.append(u)
u//=2
path2.append(lca)
if query[0]==1:
w = query[3]
for i in range(len(path2)-1):
costEdge[(path2[i],path2[i+1])]+=w
costEdge[(path2[i+1],path2[i])]+=w
for i in range(len(path1)-1):
costEdge[(path1[i],path1[i+1])]+=w
costEdge[(path1[i+1],path1[i])]+=w
else:
ans = 0
for i in range(len(path2)-1):
ans+=costEdge[(path2[i],path2[i+1])]
for i in range(len(path1)-1):
ans+=costEdge[(path1[i],path1[i+1])]
print(ans)
``` | output | 1 | 10,403 | 1 | 20,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second). | instruction | 0 | 10,404 | 1 | 20,808 |
Tags: brute force, data structures, implementation, trees
Correct Solution:
```
n=int(input())
d={}
def lca(u,v,w) :
res=0
while u!=v :
if u<v :
v,u=u,v
d[u]=d.get(u,0)+w
res+=d[u]
u=u//2
return res
for i in range(n) :
l=list(map(int,input().split()))
if l[0]==1 :
lca(l[1],l[2],l[3])
else :
print(lca(l[1],l[2],0))
``` | output | 1 | 10,404 | 1 | 20,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second). | instruction | 0 | 10,405 | 1 | 20,810 |
Tags: brute force, data structures, implementation, trees
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 15 23:50:55 2020
@author: shailesh
"""
from collections import defaultdict
def find_cost(node_1,node_2,intersect_dict):
new_dict = defaultdict(lambda : 0)
cost = 0
while node_1 != 0:
new_dict[node_1] = 1
cost+= intersect_dict[node_1]
# print(node_1,cost)
node_1 //= 2
while node_2!=0:
if new_dict[node_2]:
cost -= intersect_dict[node_2]
# print(node_2)
break
else:
new_dict[node_2] = 1
cost += intersect_dict[node_2]
node_2 //= 2
# print(node_2,cost)
while node_2 != 0:
node_2 //= 2
cost -= intersect_dict[node_2]
return cost
def increase_cost_on_path(node_1,node_2,inc_cost,intersect_dict):
new_dict = defaultdict(lambda :0)
while node_1 != 0:
new_dict[node_1] = 1
intersect_dict[node_1] += inc_cost
node_1 //= 2
while node_2 != 0 :
if new_dict[node_2]:
break
else:
intersect_dict[node_2] += inc_cost
node_2//=2
while node_2 != 0:
intersect_dict[node_2] -= inc_cost
node_2 //= 2
return intersect_dict
Q = int(input())
#arr = [0 for i in range(n+1)]
intersect_dict = defaultdict(lambda : 0)
for q in range(Q):
query = [int(i) for i in input().split()]
if query[0] == 1:
v,u,w = query[1:]
intersect_dict = increase_cost_on_path(v,u,w,intersect_dict)
else:
v,u = query[1:]
cost = find_cost(u,v,intersect_dict)
print(cost)
``` | output | 1 | 10,405 | 1 | 20,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second). | instruction | 0 | 10,406 | 1 | 20,812 |
Tags: brute force, data structures, implementation, trees
Correct Solution:
```
def path_to_root(n):
path = [n]
while n != 1:
if n % 2:
path.append((n - 1) // 2)
n = (n - 1) // 2
else:
path.append(n // 2)
n //= 2
return path
def path_beetwen(a, b):
p1 = path_to_root(a)
p2 = path_to_root(b)
l1 = len(p1)
l2 = len(p2)
x = 0
while x < l2:
if p2[x] in p1:
break
x += 1
path = p1[:p1.index(p2[x]) + 1] + p2[:x][::-1]
return path
def fee_on_path(fees, a, b):
path = path_beetwen(a, b)
total_fee = 0
for x in range(len(path) - 1):
fee = str(path[x]) + "_" + str(path[x + 1])
if fee in fees.keys():
total_fee += fees[fee]
return total_fee
def update_fees(fees, a, b, w):
path = path_beetwen(a, b)
for x in range(len(path) - 1):
fee = str(path[x]) + "_" + str(path[x + 1])
fee2 = str(path[x + 1]) + "_" + str(path[x])
if fee in fees.keys():
fees[fee] += w
else:
fees[fee] = w
if fee2 in fees.keys():
fees[fee2] += w
else:
fees[fee2] = w
class CodeforcesTask696ASolution:
def __init__(self):
self.result = ''
self.events_count = 0
self.events = []
def read_input(self):
self.events_count = int(input())
for x in range(self.events_count):
self.events.append([int(y) for y in input().split(" ")])
def process_task(self):
fees = {}
for x in range(self.events_count):
if self.events[x][0] == 1:
update_fees(fees, self.events[x][1], self.events[x][2], self.events[x][3])
else:
print(fee_on_path(fees, self.events[x][1], self.events[x][2]))
#print(fees)
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask696ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
``` | output | 1 | 10,406 | 1 | 20,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second). | instruction | 0 | 10,407 | 1 | 20,814 |
Tags: brute force, data structures, implementation, trees
Correct Solution:
```
from collections import defaultdict
arr=defaultdict(int)
for i in range(int(input())):
t=list(map(int,input().strip().split()))
if t[0]==1:
type,a,b,w=t
if b>a:
a,b=b,a
while a!=b:
# print(a,b)
if a>b:
# a//=2
# if a>0:
arr[a]+=w
a//=2
else:
# b//=2
# if b>0:
arr[b]+=w
b//=2
if t[0]==2:
type,a,b=t
res=0
st=set()
if a<b:
a,b=b,a
res=0
while a!=b:
if a>b:
# st.add(a)
res+=arr[a]
a//=2
# st.add(a)
else:
# if b//2 not in st or (b not in st):
# st.add(b)
res+=arr[b]
b//=2
# st.add(b)
print(res)
``` | output | 1 | 10,407 | 1 | 20,815 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second). | instruction | 0 | 10,408 | 1 | 20,816 |
Tags: brute force, data structures, implementation, trees
Correct Solution:
```
def main():
d = {}
for _ in range(int(input())):
c, *l = input().split()
if c == "1":
v, u, w = map(int, l)
while u != v:
if u < v:
d[v] = d.get(v, 0) + w
u, v = v // 2, u
else:
d[u] = d.get(u, 0) + w
u //= 2
else:
res = 0
v, u = map(int, l)
while u != v:
if u < v:
res += d.get(v, 0)
u, v = v // 2, u
else:
res += d.get(u, 0)
u //= 2
print(res)
if __name__ == "__main__":
main()
``` | output | 1 | 10,408 | 1 | 20,817 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second). | instruction | 0 | 10,409 | 1 | 20,818 |
Tags: brute force, data structures, implementation, trees
Correct Solution:
```
d = {}
def lca(x, y, w):
res = 0
while x != y:
if x < y:
x, y = y, x;
d[x] = d.get(x, 0) + w
res += d[x]
x //= 2
return res
q = int(input())
while (q > 0):
q -= 1
a = list(map(int, input().split()))
if a[0] == 1:
lca(a[1], a[2], a[3])
else:
(print(lca(a[1], a[2], 0)))
``` | output | 1 | 10,409 | 1 | 20,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second).
Submitted Solution:
```
def find_path(x,y):
p1,p2 = [],[]
while x!=0:
p1.append(x)
x = x//2
while y!=0:
p2.append(y)
y = y//2
p1 = p1[::-1]
p2 = p2[::-1]
# print (p1,p2)
for i in range(min(len(p1),len(p2))):
if p1[i]==p2[i]:
ind = i
else:
break
path = []
for i in range(ind,len(p1)):
path.append(p1[i])
path = path[::-1]
for i in range(ind+1,len(p2)):
path.append(p2[i])
return path
q = int(input())
cost = {}
for i in range(q):
a = list(map(int,input().split()))
b = find_path(a[1],a[2])
# print (b)
if a[0] == 1:
w = a[-1]
for j in range(1,len(b)):
if (b[j],b[j-1]) not in cost:
cost[(b[j],b[j-1])] = w
cost[(b[j-1],b[j])] = w
else:
cost[(b[j],b[j-1])] += w
cost[(b[j-1],b[j])] += w
else:
ans = 0
for j in range(1,len(b)):
if (b[j],b[j-1]) in cost:
ans += cost[(b[j],b[j-1])]
print (ans)
``` | instruction | 0 | 10,410 | 1 | 20,820 |
Yes | output | 1 | 10,410 | 1 | 20,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second).
Submitted Solution:
```
import sys,os,io
from collections import defaultdict
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
cost = defaultdict(lambda: 0)
q = int(input())
for _ in range (q):
qi = [int(i) for i in input().split()]
u,v = qi[1],qi[2]
vis = defaultdict(lambda: 0)
path1 = []
while(u>0):
path1.append(u)
vis[u]=1
u//=2
path2 = []
inter = -1
while(v>0):
if vis[v]:
inter = v
break
path2.append(v)
v//=2
path = []
for i in path1:
path.append(i)
if i==inter:
break
for i in path2[::-1]:
path.append(i)
if qi[0]==1:
w = qi[3]
for i in range (1,len(path)):
cost[(path[i],path[i-1])]+=w
cost[(path[i-1], path[i])]+=w
else:
ans = 0
for i in range (1,len(path)):
ans += cost[(path[i],path[i-1])]
print(ans)
``` | instruction | 0 | 10,411 | 1 | 20,822 |
Yes | output | 1 | 10,411 | 1 | 20,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second).
Submitted Solution:
```
I= input
n = int(I())
d = {}
def lca(u,v,w):
res = 0
while u != v:
if u < v: u, v = v , u
d[u] = d.get(u,0) + w
res += d[u]
u = u//2
return res
for i in range(n):
l = list(map(int, I().split()))
if l[0] == 1: # To add
lca(l[1],l[2],l[3])
else: print(lca(l[1],l[2],0))
# Made By Mostafa_Khaled
``` | instruction | 0 | 10,412 | 1 | 20,824 |
Yes | output | 1 | 10,412 | 1 | 20,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second).
Submitted Solution:
```
# from debug import debug
import sys; input = sys.stdin.readline
from math import log2
from collections import defaultdict
d = defaultdict(int)
for i in range(int(input().strip())):
l = list(map(int, input().strip().split()))
if l[0] == 1:
u, v, w = l[1:]
while u != v:
if int(log2(u)) < int(log2(v)): u, v = v, u
d[(u, u//2)] += w
u = u//2
else:
u, v = l[1:]
ans = 0
while u != v:
if int(log2(u)) < int(log2(v)): u, v = v, u
ans += d[(u, u//2)]
u = u//2
print(ans)
``` | instruction | 0 | 10,413 | 1 | 20,826 |
Yes | output | 1 | 10,413 | 1 | 20,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second).
Submitted Solution:
```
from functools import lru_cache
from collections import defaultdict
from itertools import tee
price = defaultdict(dict)
def add(start, end, w):
for x, y in get_way(start, end):
if x in price:
price[x][y] += w
else:
price[x] = defaultdict(lambda: 0)
price[x][y] = w
if y in price:
price[y][x] += w
else:
price[y] = defaultdict(lambda: 0)
price[y][x] = w
def get_price(start, end):
result = 0
for x, y in get_way(start, end):
if x not in price:
price[x] = defaultdict(lambda: 0)
result += price[x][y]
return result
@lru_cache(maxsize=1000)
def get_way(start, end):
def _get_raw_way():
nonlocal start, end
l_way, r_way = [start], [end]
while True:
l = l_way[-1] // 2
if l: l_way.append(l)
r = r_way[-1] // 2
if r: r_way.append(r)
if r_way[-1] == start:
return r_way
if set(l_way) & set(r_way):
del r_way[-1]
r_way.reverse()
return l_way + r_way
a, b = tee(_get_raw_way())
next(b, None)
return list(zip(a, b))
q = int(input())
for _ in range(q):
data = list(map(int, input().split(' ')))
if data[0] == 1:
add(data[1], data[2], data[3])
else:
print(get_price(data[1], data[2]))
``` | instruction | 0 | 10,414 | 1 | 20,828 |
No | output | 1 | 10,414 | 1 | 20,829 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.