message
stringlengths 2
45.8k
| message_type
stringclasses 2
values | message_id
int64 0
1
| conversation_id
int64 254
108k
| cluster
float64 3
3
| __index_level_0__
int64 508
217k
|
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
|
instruction
| 0
| 95,707
| 3
| 191,414
|
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
def glen(x1,y1,x2,y2):
return ((x1-x2)**2+(y1-y2)**2)**0.5
xa, ya, xb, yb, xt, yt = map(int,input().split())
n = int(input())
x = [0]*n
y = [0]*n
for i in range(n):
x[i], y[i] = map(int,input().split())
inf = 10**10
afmin = [0, 0]
asmin = [0, 0]
for i in range(n):
a = glen(xa,ya,x[i],y[i])-glen(xa,ya,xt,yt)-glen(xt,yt,x[i],y[i])
if asmin[0] > a:
asmin[0] = a
asmin[1] = i
if asmin[0] < afmin[0]: asmin,afmin = afmin, asmin
bfmin = [0, 0]
bsmin = [0, 0]
for i in range(n):
b = glen(xb,yb,x[i],y[i])-glen(xb,yb,xt,yt)-glen(xt,yt,x[i],y[i])
if bsmin[0] > b:
bsmin[0] = b
bsmin[1] = i
if bsmin[0] < bfmin[0]: bsmin,bfmin = bfmin, bsmin
res = 0
b = bfmin[1]
a = afmin[1]
b1 = bsmin[1]
a1 = asmin[1]
res1 = min(glen(x[a], y[a], xa, ya) - glen(x[a],y[a],xt,yt),
glen(x[b], y[b], xb, yb) - glen(x[b],y[b],xt,yt))
if b != a:
res += glen(x[a], y[a], xa, ya) - glen(x[a],y[a],xt,yt)
res += glen(x[b], y[b], xb, yb) - glen(x[b],y[b],xt,yt)
else:
res += min(glen(x[a], y[a], xa, ya) - glen(x[a],y[a],xt,yt) + glen(x[b1], y[b1], xb, yb) - glen(x[b1],y[b1],xt,yt),
glen(x[a1], y[a1], xa, ya) - glen(x[a],y[a],xt,yt) + glen(x[b], y[b], xb, yb) - glen(x[b1],y[b1],xt,yt))
for i in range(n):
res += 2*glen(xt,yt,x[i],y[i])
res1 += 2*glen(xt,yt,x[i],y[i])
if n == 1:
res = 10**11
print(min(res, res1))
```
|
output
| 1
| 95,707
| 3
| 191,415
|
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
|
instruction
| 0
| 95,708
| 3
| 191,416
|
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
read = lambda : map(int, input().split())
def dis(x1, y1, x2, y2):
return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
ax, ay, bx, by, tx, ty = read()
n = int(input())
a, b = [], []
sum = 0
for i in range(n):
x, y = read()
dist = dis(tx, ty, x, y)
a.append((dis(ax, ay, x, y) - dist, i))
b.append((dis(bx, by, x, y) - dist, i))
sum += dist * 2
a.sort()
b.sort()
if n > 1 and a[0][1] == b[0][1]:
ans = min(a[0][0], b[0][0], a[0][0] + b[1][0], a[1][0] + b[0][0])
else:
ans = min(a[0][0], b[0][0])
if (n > 1) :
ans = min(a[0][0] + b[0][0], ans)
print(ans + sum)
```
|
output
| 1
| 95,708
| 3
| 191,417
|
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
|
instruction
| 0
| 95,709
| 3
| 191,418
|
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
import math
def dist(x1, y1, x2, y2):
res = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)
res = math.sqrt(res)
return res
ax, ay, bx, by, tx, ty = list(map(int, input().split()))
n = int(input())
ans = 0
bottles = [(0, 0) for i in range(n)]
da = [(0, -1) for i in range(n + 1)]
db = [(0, -1) for i in range(n + 1)]
for i in range(n):
xi, yi = list(map(int, input().split()))
bottles.append((xi, yi))
# We compute the dist from xi, yi to tx ty and add the double to the ans
dt = dist(xi, yi, tx, ty)
ans += 2 * dt
# We now compute dist from ax, ay to xi, yi and dt (the path to collect the bottle and go to the center)
dist_a = dist(ax, ay, xi, yi) - dt
da[i] = (dist_a, i)
# Same for b
dist_b = dist(bx, by, xi, yi) - dt
db[i] = (dist_b, i)
best = 10 ** 18
da = sorted(da)
db = sorted(db)
for i in range(min(3, n + 1)):
for j in range(min(3, n + 1)):
if da[i][1] == db[j][1]:
continue
if da[i][1] == -1 and db[j][1] == -1:
continue
best = min(best, da[i][0] + db[j][0])
print(ans + best)
# Now we just need to know if a and b can pick something up
# For that, several cases
# If both min_dist_a and min_dist_b are greater than the distance needed to collect the corresponding bottle
# Only one of them will, the one with the least distance
# If one of them has a min_dist greater than the distance needed to collect, it won't
# If both of them can collect one (less then their distance), they both do
# We suppose for now this happen all the time
# print(s)
```
|
output
| 1
| 95,709
| 3
| 191,419
|
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
|
instruction
| 0
| 95,710
| 3
| 191,420
|
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
import math
ax,ay,bx,by,tx,ty = map(float,input().split(" "))
n = int(input())
dis = 0.0
a1Dis = 100000000000.0**2
a2Dis = 100000000000.0**2
b1Dis = 100000000000.0**2
b2Dis = 100000000000.0**2
a1=0
b1=0
rec=0.0
for i in range(n):
x,y = map(float,input().split(" "))
rec=math.sqrt((x-tx)**2+(y-ty)**2)
dis+=rec*2
aDis = math.sqrt((x-ax)**2+(y-ay)**2)
if aDis-rec < a1Dis:
a1 = i
a2Dis = a1Dis
a1Dis = aDis-rec
elif aDis-rec<a2Dis:
a2Dis=aDis-rec
bDis = math.sqrt((x-bx)**2+(y-by)**2)
if bDis-rec < b1Dis:
b1=i
b2Dis = b1Dis
b1Dis = bDis-rec
elif bDis-rec<b2Dis:
b2Dis=bDis-rec
options=[a1Dis+b2Dis,b1Dis+a2Dis,a1Dis,b1Dis]
if a1!=b1:
options.append(b1Dis+a1Dis)
print(dis+min(options))
```
|
output
| 1
| 95,710
| 3
| 191,421
|
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
|
instruction
| 0
| 95,711
| 3
| 191,422
|
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
import math
def getdist(x,y,a,c):
return math.sqrt((x-a)**2+(c-y)**2)
def main(n,points,start):
x1,y1=start[0],start[1]
x2,y2=start[2],start[3]
x3,y3=start[4],start[5]
dist=[]
dist_p1=[]
dist_p2=[]
for i in range(len(points)):
x4,y4=points[i]
dist.append(getdist(x4,y4,x3,y3))
dist_p1.append((i,getdist(x4,y4,x1,y1)-dist[i]))
dist_p2.append((i,getdist(x4,y4,x2,y2)-dist[i]))
dist_p2.sort(key=lambda x:x[1])
dist_p1.sort(key=lambda x:x[1])
val1=dist_p2[0]
if len(dist_p2)>1:
val2=dist_p2[1]
else:
val2=(None,float('inf'))
sum_dist=sum(dist)
ans=float('inf')
for i in range(len(dist_p1)):
i1,d1=dist_p1[i]
i2,d2=val1
i3,d3=val2
if i1!=i2:
ans=min(ans,d1+d2+2*sum_dist)
elif i3!=None:
ans=min(ans,d1+d3+2*sum_dist)
i1,d1=dist_p1[0]
i2,d2=val1
ans=min(ans,d1+2*sum_dist)
ans=min(ans,d2+2*sum_dist)
return ans
start=list(map(int,input().split()))
n=int(input())
arr=[]
for i in range(n):
arr.append(list(map(int,input().split())))
print(main(n,arr,start))
```
|
output
| 1
| 95,711
| 3
| 191,423
|
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
|
instruction
| 0
| 95,712
| 3
| 191,424
|
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
import math
import sys
def dist(u, v):
return math.hypot(u[0] - v[0], u[1] - v[1])
ax, ay, bx, by, tx, ty = [int(x) for x in input().split()]
a, b, t = (ax, ay), (bx, by), (tx, ty)
n = int(input())
bottles = [tuple(int(x) for x in line.split()) for line in sys.stdin]
S = sum(2*dist(t, bottle) for bottle in bottles)
a_dist = [(dist(a, bottle) - dist(t, bottle), i)
for (i, bottle) in enumerate(bottles)]
b_dist = [(dist(b, bottle) - dist(t, bottle), i)
for (i, bottle) in enumerate(bottles)]
a_dist.sort()
b_dist.sort()
if a_dist[0][0] > 0 or b_dist[0][0] > 0 or n == 1:
k = min(a_dist[0][0], b_dist[0][0])
elif a_dist[0][1] == b_dist[0][1]:
k = min(a_dist[1][0] + b_dist[0][0],
a_dist[0][0] + b_dist[1][0],
a_dist[0][0], b_dist[0][0])
else:
k = min(a_dist[0][0] + b_dist[0][0],
a_dist[0][0], b_dist[0][0])
print(k + S)
```
|
output
| 1
| 95,712
| 3
| 191,425
|
Provide tags and a correct Python 3 solution for this coding contest problem.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
|
instruction
| 0
| 95,713
| 3
| 191,426
|
Tags: dp, geometry, greedy, implementation
Correct Solution:
```
ax,ay,bx,by,rx,ry=map(int,input().split())
a,b=[],[]
from math import sqrt
n=int(input())
#print(n)
for i in range(n):
m,rn=map(int,input().split())
a.append(m)
b.append(rn)
#print(a,b)
ra,rb=[],[]
ans=0
for i in range(n):
#print('i m i')
da=sqrt((ax-a[i])**2+(ay-b[i])**2)
db=sqrt((bx-a[i])**2+(by-b[i])**2)
dr=sqrt((rx-a[i])**2+(ry-b[i])**2)
##print(da,db,dr)
ra.append(dr-da)
rb.append(dr-db)
ans+=(2*dr)
#print(ans)
l=range(n)
ran1=sorted(zip(ra,l))[::-1]
ran2=sorted(zip(rb,l))[::-1]
if(n==1):
print(ans-max(ran1[0][0],ran2[0][0]))
else:
if(ran1[0][0]>=0 and ran2[0][0]>=0):
if(ran1[0][1]!=ran2[0][1]):
print(ans-(ran1[0][0]+ran2[0][0]))
else:
print(ans-max(max(0,ran1[1][0])+ran2[0][0],max(0,ran2[1][0])+ran1[0][0]))
else:
print(ans-max(ran1[0][0],ran2[0][0]))
```
|
output
| 1
| 95,713
| 3
| 191,427
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
read = lambda: map(int, input().split())
ax, ay, bx, by, tx, ty = read()
n = int(input())
p = [tuple(read()) for i in range(n)]
a, b = [], []
for i in range(n):
x, y = p[i]
pt = ((tx - x) ** 2 + (ty - y) ** 2) ** 0.5
pa = ((ax - x) ** 2 + (ay - y) ** 2) ** 0.5
pb = ((bx - x) ** 2 + (by - y) ** 2) ** 0.5
a.append((pa - pt, i))
b.append((pb - pt, i))
a.sort()
b.sort()
if a[0][1] == b[0][1] and n > 1:
ans = min(a[0][0], b[0][0], a[0][0] + b[1][0], a[1][0] + b[0][0])
else:
ans = min(a[0][0], b[0][0])
if a[0][1] != b[0][1]: ans = min(ans, a[0][0] + b[0][0])
ans += sum(2 * ((tx - x) ** 2 + (ty - y) ** 2) ** 0.5 for x, y in p)
print(ans)
```
|
instruction
| 0
| 95,714
| 3
| 191,428
|
Yes
|
output
| 1
| 95,714
| 3
| 191,429
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
import math
def dis(x1, y1, x2, y2):
return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
str = input().split()
argu = []
for i in str:
argu.append(int(i))
n = int(input())
total = 0
array = [[], []]
for i in range(n):
x, y = input().split()
x = int(x)
y = int(y)
td = dis(x, y, argu[4], argu[5])
ad = dis(x, y, argu[0], argu[1])
bd = dis(x, y, argu[2], argu[3])
total += 2 * td
array[0].append((i, ad - td))
array[1].append((i, bd - td))
if n == 1:
print("%.12f" % (total + min(array[0][0][1], array[1][0][1])))
else:
def sortkey(x):
return x[1]
array[0].sort(key = sortkey)
array[1].sort(key = sortkey)
ans = total + array[0][0][1]
ans = min(ans, total + array[1][0][1])
for i in range(2):
for j in range(2):
tmpa = array[0][i]
tmpb = array[1][j]
if tmpa[0] != tmpb[0]:
ans = min(ans, total + tmpa[1] + tmpb[1])
print("%.12f" % ans)
```
|
instruction
| 0
| 95,715
| 3
| 191,430
|
Yes
|
output
| 1
| 95,715
| 3
| 191,431
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
import math
ax,ay,bx,by,tx,ty = list(map(int,input().split()))
n = int(input())
p = [0,0] * n
s = [0.] * n
ma = [0.] * n
mb = [0.] * n
for i in range(n):
p[i] = list(map(int,input().split()))
s[i] = math.hypot(tx - p[i][0], ty - p[i][1])
ma[i] = math.hypot(ax - p[i][0], ay - p[i][1]) - s[i]
mb[i] = math.hypot(bx - p[i][0], by - p[i][1]) - s[i]
ma = sorted(dict(zip(range(n),ma)).items(), key = lambda t:t[1])
mb = sorted(dict(zip(range(n),mb)).items(), key = lambda t:t[1])
if ma[0][1] > 0 and mb[0][1] > 0:
ans = min(ma[0][1],mb[0][1])
elif ma[0][0] == mb[0][0]:
if n == 1:
ans = min(ma[0][1],mb[0][1],0)
else:
a1,a2,b1,b2 = min(ma[0][1],0), min(ma[1][1],0), min(mb[0][1],0), min(mb[1][1],0)
ans = min(a1+b2, a2+b1,0)
else:
ans = min(ma[0][1],0) + min(mb[0][1],0)
print(2 * sum(s) + ans)
```
|
instruction
| 0
| 95,716
| 3
| 191,432
|
Yes
|
output
| 1
| 95,716
| 3
| 191,433
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
import sys
sys.stderr = sys.stdout
import heapq
def dist(p1, p2):
return ((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2) ** 0.5
def bottles(A, B, T, n, P):
d_A = dist(A, T)
d_B = dist(B, T)
DP = [dist(p, T) for p in P]
DA = [dist(p, A) for p in P]
DB = [dist(p, B) for p in P]
S = sum(DP) * 2
if n == 1:
d3 = min(da - dp for da, dp in zip(DA, DP))
d4 = min(db - dp for db, dp in zip(DB, DP))
log("d3", d3, "d4", d4)
return S + min(d_A, d_B, d3, d4)
(dap1, a1), (dap2, a2) = heapq.nsmallest(2,
(((da - dp), i) for (i, (da, dp)) in enumerate(zip(DA, DP))))
(dbp1, b1), (dbp2, b2) = heapq.nsmallest(2,
(((db - dp), i) for (i, (db, dp)) in enumerate(zip(DB, DP))))
d3 = dap1
d4 = dbp1
if a1 == b1:
d5 = min(dap1 + dbp2, dap2 + dbp1)
else:
d5 = dap1 + dbp1
return S + min(d_A, d_B, d3, d4, d5)
def main():
ax, ay, bx, by, tx, ty = readinti()
n = readint()
P = readinttl(n)
print(bottles((ax, ay), (bx, by), (tx, ty), n, P))
##########
def readint():
return int(input())
def readinti():
return map(int, input().split())
def readintt():
return tuple(readinti())
def readintl():
return list(readinti())
def readinttl(k):
return [readintt() for _ in range(k)]
def readintll(k):
return [readintl() for _ in range(k)]
def log(*args, **kwargs):
print(*args, **kwargs, file=sys.__stderr__)
if __name__ == '__main__':
main()
```
|
instruction
| 0
| 95,717
| 3
| 191,434
|
Yes
|
output
| 1
| 95,717
| 3
| 191,435
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
import math
def dist(x1, y1, x2, y2):
res = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)
res = math.sqrt(res)
return res
ax, ay, bx, by, tx, ty = list(map(int, input().split()))
n = int(input())
ans = 0
bottles = [(0, 0) for i in range(n)]
da = [(0, -1) for i in range(n + 1)]
db = [(0, -1) for i in range(n + 1)]
for i in range(n):
xi, yi = list(map(int, input().split()))
bottles.append((xi, yi))
# We compute the dist from xi, yi to tx ty and add the double to the ans
dt = dist(xi, yi, tx, ty)
ans += 2 * dt
# We now compute dist from ax, ay to xi, yi and dt (the path to collect the bottle and go to the center)
dist_a = dist(ax, ay, xi, yi) - dt
da[i] = (dist_a, i)
# Same for b
dist_b = dist(bx, by, xi, yi) - dt
db[i] = (dist_b, i)
best = 10 ** 18
da = sorted(da)
db = sorted(db)
for i in range(min(3, n)):
for j in range(min(3, n)):
if da[i][1] == db[j][1]:
continue
if da[i][1] == -1 and db[j][1] == -1:
continue
best = min(best, da[i][0] + db[j][0])
print(ans + best)
# Now we just need to know if a and b can pick something up
# For that, several cases
# If both min_dist_a and min_dist_b are greater than the distance needed to collect the corresponding bottle
# Only one of them will, the one with the least distance
# If one of them has a min_dist greater than the distance needed to collect, it won't
# If both of them can collect one (less then their distance), they both do
# We suppose for now this happen all the time
# print(s)
```
|
instruction
| 0
| 95,718
| 3
| 191,436
|
No
|
output
| 1
| 95,718
| 3
| 191,437
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
ax, ay, bx, by, tx, ty = map(int, input().split())
def dd(x0, y0, x1, y1):
return ((x0 - x1)**2 + (y0 - y1)**2)**0.5
n = int(input())
arr = [list(map(int, input().split())) for i in range(n)]
dist = [dd(x, y, tx, ty) for x, y in arr]
ans = sum(dist) * 2
a_dists = sorted((dd(*x, ax, ay) - dd(*x, tx, ty), i) for i, x in enumerate(arr))
b_dists = sorted((dd(*x, bx, by) - dd(*x, tx, ty), i) for i, x in enumerate(arr))
a_dists = a_dists[:5]
b_dists = b_dists[:5]
mi = 10**100
for dx, x in a_dists:
for dy, y in b_dists:
if x != y:
mi = min(mi, ans + dx + dy)
if mi > ans:
mi = min(ans + a_dists[0][0], ans + b_dists[0][0])
print(mi)
```
|
instruction
| 0
| 95,719
| 3
| 191,438
|
No
|
output
| 1
| 95,719
| 3
| 191,439
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
ax, ay, bx, by, tx, ty = map(int, input().split())
def dd(x0, y0, x1, y1):
return ((x0 - x1)**2 + (y0 - y1)**2)**0.5
n = int(input())
arr = [list(map(int, input().split())) for i in range(n)]
dist = [dd(x, y, tx, ty) for x, y in arr]
ans = sum(dist) * 2
a_dists = [(dd(*x, ax, ay) - dd(*x, tx, ty), i) for i, x in enumerate(arr)]
b_dists = [(dd(*x, bx, by) - dd(*x, tx, ty), i) for i, x in enumerate(arr)]
a_dists.sort(reverse=True)
b_dists.sort(reverse=True)
a_dists = a_dists[:10]
b_dists = b_dists[:10]
mi = 10**100
for dx, x in a_dists:
for dy, y in b_dists:
if x != y:
mi = min(mi, ans + dx + dy)
print(mi)
```
|
instruction
| 0
| 95,720
| 3
| 191,440
|
No
|
output
| 1
| 95,720
| 3
| 191,441
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin.
We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can carry only one bottle at once each.
For both Adil and Bera the process looks as follows:
1. Choose to stop or to continue to collect bottles.
2. If the choice was to continue then choose some bottle and walk towards it.
3. Pick this bottle and walk to the recycling bin.
4. Go to step 1.
Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles.
They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.
Input
First line of the input contains six integers ax, ay, bx, by, tx and ty (0 β€ ax, ay, bx, by, tx, ty β€ 109) β initial positions of Adil, Bera and recycling bin respectively.
The second line contains a single integer n (1 β€ n β€ 100 000) β the number of bottles on the ground.
Then follow n lines, each of them contains two integers xi and yi (0 β€ xi, yi β€ 109) β position of the i-th bottle.
It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.
Output
Print one real number β the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
3 1 1 2 0 0
3
1 1
2 1
2 3
Output
11.084259940083
Input
5 0 4 2 2 0
5
5 2
3 0
5 5
3 5
3 3
Output
33.121375178000
Note
Consider the first sample.
Adil will use the following path: <image>.
Bera will use the following path: <image>.
Adil's path will be <image> units long, while Bera's path will be <image> units long.
Submitted Solution:
```
# -*- coding: utf-8 -*-
def get_dist_vec(loc, loc_vec):
dist_vec = []
for loc2 in loc_vec:
dist = (loc[0] - loc2[0])**2 + (loc[1] - loc2[1])**2
dist_vec.append(dist ** 0.5)
return dist_vec
def get_travel_saved(a_vec, r_vec):
travel_saved_vec = []
for i in range(len(a_vec)):
travel_saved_vec.append(r_vec[i] - a_vec[i])
idx_vec = sorted(range(len(travel_saved_vec)), key = lambda k: travel_saved_vec[k], reverse = True)
return idx_vec
def get_dist_traveled(a_vec, b_vec, r_vec, i, j):
dist_traveled = (a_vec[i] + r_vec[i]) + (b_vec[j] + r_vec[j])
for k in range(len(r_vec)):
if k == i or k == j:
continue
else:
dist_traveled += 2 * r_vec[k]
return dist_traveled
def main():
args = [int(x) for x in input().split()]
a_loc = (args[0], args[1])
b_loc = (args[2], args[3])
r_loc = (args[4], args[5])
n = int(input())
# a_loc = (107, 50)
# b_loc = (116, 37)
# b_loc = (104, 118)
# r_loc = (104, 118)
# bottle_vec = [(16, 78), (95, 113), (112, 84), (5, 88), (54, 85), (112, 80), (19, 98), (25, 14), (48, 76), (95, 70), (77, 94), (38, 32) ]
bottle_vec = []
for i in range(n):
bottle_coord = [int(x) for x in input().split()]
bottle_vec.append((bottle_coord[0], bottle_coord[1]))
a_vec = get_dist_vec(a_loc, bottle_vec)
b_vec = get_dist_vec(b_loc, bottle_vec)
r_vec = get_dist_vec(r_loc, bottle_vec)
travel_saved_idx_vec_a = get_travel_saved(a_vec, r_vec)
travel_saved_idx_vec_b = get_travel_saved(b_vec, r_vec)
a_max_i = travel_saved_idx_vec_a[0]
b_max_i = travel_saved_idx_vec_b[0]
if (a_max_i == b_max_i):
a_sec_max_i = travel_saved_idx_vec_a[1]
b_sec_max_i = travel_saved_idx_vec_b[1]
case1_saved = (r_vec[a_max_i] - a_vec[a_max_i]) + (r_vec[b_sec_max_i] - b_vec[b_sec_max_i])
case2_saved = (r_vec[b_max_i] - b_vec[b_max_i]) + (r_vec[a_sec_max_i] - a_vec[a_sec_max_i])
if case1_saved >= case2_saved:
b_max_i = travel_saved_idx_vec_b[1]
else:
a_max_i = travel_saved_idx_vec_a[1]
print(get_dist_traveled(a_vec, b_vec, r_vec, a_max_i, b_max_i))
main()
```
|
instruction
| 0
| 95,721
| 3
| 191,442
|
No
|
output
| 1
| 95,721
| 3
| 191,443
|
Provide tags and a correct Python 3 solution for this coding contest problem.
n people are standing on a coordinate axis in points with positive integer coordinates strictly less than 106. For each person we know in which direction (left or right) he is facing, and his maximum speed.
You can put a bomb in some point with non-negative integer coordinate, and blow it up. At this moment all people will start running with their maximum speed in the direction they are facing. Also, two strange rays will start propagating from the bomb with speed s: one to the right, and one to the left. Of course, the speed s is strictly greater than people's maximum speed.
The rays are strange because if at any moment the position and the direction of movement of some ray and some person coincide, then the speed of the person immediately increases by the speed of the ray.
You need to place the bomb is such a point that the minimum time moment in which there is a person that has run through point 0, and there is a person that has run through point 106, is as small as possible. In other words, find the minimum time moment t such that there is a point you can place the bomb to so that at time moment t some person has run through 0, and some person has run through point 106.
Input
The first line contains two integers n and s (2 β€ n β€ 105, 2 β€ s β€ 106) β the number of people and the rays' speed.
The next n lines contain the description of people. The i-th of these lines contains three integers xi, vi and ti (0 < xi < 106, 1 β€ vi < s, 1 β€ ti β€ 2) β the coordinate of the i-th person on the line, his maximum speed and the direction he will run to (1 is to the left, i.e. in the direction of coordinate decrease, 2 is to the right, i.e. in the direction of coordinate increase), respectively.
It is guaranteed that the points 0 and 106 will be reached independently of the bomb's position.
Output
Print the minimum time needed for both points 0 and 106 to be reached.
Your answer is considered correct if its absolute or relative error doesn't exceed 10 - 6. Namely, if your answer is a, and the jury's answer is b, then your answer is accepted, if <image>.
Examples
Input
2 999
400000 1 2
500000 1 1
Output
500000.000000000000000000000000000000
Input
2 1000
400000 500 1
600000 500 2
Output
400.000000000000000000000000000000
Note
In the first example, it is optimal to place the bomb at a point with a coordinate of 400000. Then at time 0, the speed of the first person becomes 1000 and he reaches the point 106 at the time 600. The bomb will not affect on the second person, and he will reach the 0 point at the time 500000.
In the second example, it is optimal to place the bomb at the point 500000. The rays will catch up with both people at the time 200. At this time moment, the first is at the point with a coordinate of 300000, and the second is at the point with a coordinate of 700000. Their speed will become 1500 and at the time 400 they will simultaneously run through points 0 and 106.
|
instruction
| 0
| 95,780
| 3
| 191,560
|
Tags: binary search, implementation, math
Correct Solution:
```
import math
leftpeople = set()
rightpeople = set()
n, vl = map(int, input().split())
def leftinterval(x0, v0, t):
if x0 / v0 <= t:
return (0, 10**6)
if x0 / (vl + v0) > t:
return (-1, -2)
leftbound = x0
rightbound = (vl * vl - v0 * v0) * t + x0 * v0
rightbound /= vl
rightbound = int(rightbound)
if rightbound > 10**6:
rightbound = 10**6
return (leftbound, rightbound)
def rightinterval(x0, v0, t):
if (10**6 - x0) / v0 <= t:
return (0, 10**6)
if (10**6 - x0) / (v0 + vl) > t:
return (-1, -2)
rightbound = x0
leftbound = v0 * x0 + (10**6) * (vl - v0) - t * (vl * vl - v0 * v0)
leftbound /= vl
leftbound = math.ceil(leftbound)
if(leftbound < 0):
leftbound = 0
return (leftbound, rightbound)
def check(t):
events = []
for item in leftpeople:
temp = leftinterval(item[0], item[1], t)
if(temp[0] > temp[1]):
continue
events.append((temp[0], 0, 0))
events.append((temp[1], 1, 0))
if(temp[1] - temp[0] == 10**6):
break
for item in rightpeople:
temp = rightinterval(item[0], item[1], t)
if(temp[0] > temp[1]):
continue
events.append((temp[0], 0, 1))
events.append((temp[1], 1, 1))
if(temp[1] - temp[0] == 10**6):
break
events.sort()
opened = [0, 0]
for item in events:
color = item[2]
action = item[1]
if action == 0:
if opened[(color + 1) % 2] > 0:
return True
opened[color] += 1
else:
opened[color] -= 1
return False
for i in range(n):
a, b, c = map(int, input().split())
if c == 1:
leftpeople.add((a, b))
if c == 2:
rightpeople.add((a, b))
l = 0
r = 1e9
for i in range(50):
m = (l + r) / 2
if(check(m)):
r = m
else:
l = m
print(m)
```
|
output
| 1
| 95,780
| 3
| 191,561
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n people are standing on a coordinate axis in points with positive integer coordinates strictly less than 106. For each person we know in which direction (left or right) he is facing, and his maximum speed.
You can put a bomb in some point with non-negative integer coordinate, and blow it up. At this moment all people will start running with their maximum speed in the direction they are facing. Also, two strange rays will start propagating from the bomb with speed s: one to the right, and one to the left. Of course, the speed s is strictly greater than people's maximum speed.
The rays are strange because if at any moment the position and the direction of movement of some ray and some person coincide, then the speed of the person immediately increases by the speed of the ray.
You need to place the bomb is such a point that the minimum time moment in which there is a person that has run through point 0, and there is a person that has run through point 106, is as small as possible. In other words, find the minimum time moment t such that there is a point you can place the bomb to so that at time moment t some person has run through 0, and some person has run through point 106.
Input
The first line contains two integers n and s (2 β€ n β€ 105, 2 β€ s β€ 106) β the number of people and the rays' speed.
The next n lines contain the description of people. The i-th of these lines contains three integers xi, vi and ti (0 < xi < 106, 1 β€ vi < s, 1 β€ ti β€ 2) β the coordinate of the i-th person on the line, his maximum speed and the direction he will run to (1 is to the left, i.e. in the direction of coordinate decrease, 2 is to the right, i.e. in the direction of coordinate increase), respectively.
It is guaranteed that the points 0 and 106 will be reached independently of the bomb's position.
Output
Print the minimum time needed for both points 0 and 106 to be reached.
Your answer is considered correct if its absolute or relative error doesn't exceed 10 - 6. Namely, if your answer is a, and the jury's answer is b, then your answer is accepted, if <image>.
Examples
Input
2 999
400000 1 2
500000 1 1
Output
500000.000000000000000000000000000000
Input
2 1000
400000 500 1
600000 500 2
Output
400.000000000000000000000000000000
Note
In the first example, it is optimal to place the bomb at a point with a coordinate of 400000. Then at time 0, the speed of the first person becomes 1000 and he reaches the point 106 at the time 600. The bomb will not affect on the second person, and he will reach the 0 point at the time 500000.
In the second example, it is optimal to place the bomb at the point 500000. The rays will catch up with both people at the time 200. At this time moment, the first is at the point with a coordinate of 300000, and the second is at the point with a coordinate of 700000. Their speed will become 1500 and at the time 400 they will simultaneously run through points 0 and 106.
Submitted Solution:
```
import math
leftpeople = set()
rightpeople = set()
n, vl = map(int, input().split())
def leftinterval(x0, v0, t):
if x0 / v0 <= t:
return (0, 10**6)
if x0 / (vl + v0) > t:
return (-1, -2)
leftbound = x0
rightbound = (vl * vl - v0 * v0) * t + x0 * v0
rightbound /= vl
rightbound = int(rightbound)
if rightbound > 10**6:
rightbound = 10**6
return (leftbound, rightbound)
def rightinterval(x0, v0, t):
if (10**6 - x0) / v0 <= t:
return (0, 10**6)
if (10**6 - x0) / (v0 + vl) > t:
return (-1, -2)
rightbound = x0
leftbound = v0 * x0 + (10**6) * (vl - v0) - t * (vl * vl - v0 * v0)
leftbound /= vl
leftbound = math.ceil(leftbound)
if(leftbound < 0):
leftbound = 0
return (leftbound, rightbound)
def check(t):
events = []
for item in leftpeople:
temp = leftinterval(item[0], item[1], t)
if(temp[0] > temp[1]):
continue
events.append((temp[0], 0, 0))
events.append((temp[1], 1, 0))
for item in rightpeople:
temp = rightinterval(item[0], item[1], t)
if(temp[0] > temp[1]):
continue
events.append((temp[0], 0, 1))
events.append((temp[1], 1, 1))
events.sort()
opened = [0, 0]
for item in events:
color = item[2]
action = item[1]
if action == 0:
if opened[(color + 1) % 2] > 0:
return True
opened[color] += 1
else:
opened[color] -= 1
return False
for i in range(n):
a, b, c = map(int, input().split())
if c == 1:
leftpeople.add((a, b))
if c == 2:
rightpeople.add((a, b))
l = 0
r = 1e30
for i in range(100):
m = (l + r) / 2
if(check(m)):
r = m
else:
l = m
print(m)
```
|
instruction
| 0
| 95,781
| 3
| 191,562
|
No
|
output
| 1
| 95,781
| 3
| 191,563
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n people are standing on a coordinate axis in points with positive integer coordinates strictly less than 106. For each person we know in which direction (left or right) he is facing, and his maximum speed.
You can put a bomb in some point with non-negative integer coordinate, and blow it up. At this moment all people will start running with their maximum speed in the direction they are facing. Also, two strange rays will start propagating from the bomb with speed s: one to the right, and one to the left. Of course, the speed s is strictly greater than people's maximum speed.
The rays are strange because if at any moment the position and the direction of movement of some ray and some person coincide, then the speed of the person immediately increases by the speed of the ray.
You need to place the bomb is such a point that the minimum time moment in which there is a person that has run through point 0, and there is a person that has run through point 106, is as small as possible. In other words, find the minimum time moment t such that there is a point you can place the bomb to so that at time moment t some person has run through 0, and some person has run through point 106.
Input
The first line contains two integers n and s (2 β€ n β€ 105, 2 β€ s β€ 106) β the number of people and the rays' speed.
The next n lines contain the description of people. The i-th of these lines contains three integers xi, vi and ti (0 < xi < 106, 1 β€ vi < s, 1 β€ ti β€ 2) β the coordinate of the i-th person on the line, his maximum speed and the direction he will run to (1 is to the left, i.e. in the direction of coordinate decrease, 2 is to the right, i.e. in the direction of coordinate increase), respectively.
It is guaranteed that the points 0 and 106 will be reached independently of the bomb's position.
Output
Print the minimum time needed for both points 0 and 106 to be reached.
Your answer is considered correct if its absolute or relative error doesn't exceed 10 - 6. Namely, if your answer is a, and the jury's answer is b, then your answer is accepted, if <image>.
Examples
Input
2 999
400000 1 2
500000 1 1
Output
500000.000000000000000000000000000000
Input
2 1000
400000 500 1
600000 500 2
Output
400.000000000000000000000000000000
Note
In the first example, it is optimal to place the bomb at a point with a coordinate of 400000. Then at time 0, the speed of the first person becomes 1000 and he reaches the point 106 at the time 600. The bomb will not affect on the second person, and he will reach the 0 point at the time 500000.
In the second example, it is optimal to place the bomb at the point 500000. The rays will catch up with both people at the time 200. At this time moment, the first is at the point with a coordinate of 300000, and the second is at the point with a coordinate of 700000. Their speed will become 1500 and at the time 400 they will simultaneously run through points 0 and 106.
Submitted Solution:
```
print('hello')
```
|
instruction
| 0
| 95,782
| 3
| 191,564
|
No
|
output
| 1
| 95,782
| 3
| 191,565
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n people are standing on a coordinate axis in points with positive integer coordinates strictly less than 106. For each person we know in which direction (left or right) he is facing, and his maximum speed.
You can put a bomb in some point with non-negative integer coordinate, and blow it up. At this moment all people will start running with their maximum speed in the direction they are facing. Also, two strange rays will start propagating from the bomb with speed s: one to the right, and one to the left. Of course, the speed s is strictly greater than people's maximum speed.
The rays are strange because if at any moment the position and the direction of movement of some ray and some person coincide, then the speed of the person immediately increases by the speed of the ray.
You need to place the bomb is such a point that the minimum time moment in which there is a person that has run through point 0, and there is a person that has run through point 106, is as small as possible. In other words, find the minimum time moment t such that there is a point you can place the bomb to so that at time moment t some person has run through 0, and some person has run through point 106.
Input
The first line contains two integers n and s (2 β€ n β€ 105, 2 β€ s β€ 106) β the number of people and the rays' speed.
The next n lines contain the description of people. The i-th of these lines contains three integers xi, vi and ti (0 < xi < 106, 1 β€ vi < s, 1 β€ ti β€ 2) β the coordinate of the i-th person on the line, his maximum speed and the direction he will run to (1 is to the left, i.e. in the direction of coordinate decrease, 2 is to the right, i.e. in the direction of coordinate increase), respectively.
It is guaranteed that the points 0 and 106 will be reached independently of the bomb's position.
Output
Print the minimum time needed for both points 0 and 106 to be reached.
Your answer is considered correct if its absolute or relative error doesn't exceed 10 - 6. Namely, if your answer is a, and the jury's answer is b, then your answer is accepted, if <image>.
Examples
Input
2 999
400000 1 2
500000 1 1
Output
500000.000000000000000000000000000000
Input
2 1000
400000 500 1
600000 500 2
Output
400.000000000000000000000000000000
Note
In the first example, it is optimal to place the bomb at a point with a coordinate of 400000. Then at time 0, the speed of the first person becomes 1000 and he reaches the point 106 at the time 600. The bomb will not affect on the second person, and he will reach the 0 point at the time 500000.
In the second example, it is optimal to place the bomb at the point 500000. The rays will catch up with both people at the time 200. At this time moment, the first is at the point with a coordinate of 300000, and the second is at the point with a coordinate of 700000. Their speed will become 1500 and at the time 400 they will simultaneously run through points 0 and 106.
Submitted Solution:
```
import sys
left = []
right = []
n, v = map(int,sys.stdin.readline().split())
for i in range(n):
x,vi,t = map(int,sys.stdin.readline().split())
if t==1:
left.append((x,vi))
else:
right.append((-x,vi))
left = sorted(left)
right = sorted(right)
def calc_left(x):
ans = 10**6
for i in range(len(left)):
xi = left[i][0]
vi = left[i][1]
if x<xi or xi/vi < x/v:
t = xi/vi
else:
t0 = (x-xi)/(v-vi)
t = t0+ (xi-t0*vi)/(v+vi)
if t < ans:
ans = t
return ans
def calc_right(x):
ans = 10**6
c = 10**6
x = c - x
for i in range(len(right)):
xi = c+right[i][0]
vi = right[i][1]
if x<xi or xi/vi < x/v:
t = xi/vi
else:
t0 = (x-xi)/(v-vi)
t = t0+ (xi-t0*vi)/(v+vi)
if t < ans:
ans = t
return ans
def both(x):
a = calc_left(x)
b = calc_right(x)
return max(a,b)
def main():
t = 10**6
l = 0
r = 10**6
a = both(left[0][0])
if a<t:
t = a
a = both(-right[0][0])
if a<t:
t = a
while l<=r:
m = int((l+r)/2)
a = calc_left(m)
b = calc_right(m)
if a<b:
l = m+1
if b<t:
t=b
else:
r = m-1
if a<t:
t=a
print(t)
main()
```
|
instruction
| 0
| 95,783
| 3
| 191,566
|
No
|
output
| 1
| 95,783
| 3
| 191,567
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n people are standing on a coordinate axis in points with positive integer coordinates strictly less than 106. For each person we know in which direction (left or right) he is facing, and his maximum speed.
You can put a bomb in some point with non-negative integer coordinate, and blow it up. At this moment all people will start running with their maximum speed in the direction they are facing. Also, two strange rays will start propagating from the bomb with speed s: one to the right, and one to the left. Of course, the speed s is strictly greater than people's maximum speed.
The rays are strange because if at any moment the position and the direction of movement of some ray and some person coincide, then the speed of the person immediately increases by the speed of the ray.
You need to place the bomb is such a point that the minimum time moment in which there is a person that has run through point 0, and there is a person that has run through point 106, is as small as possible. In other words, find the minimum time moment t such that there is a point you can place the bomb to so that at time moment t some person has run through 0, and some person has run through point 106.
Input
The first line contains two integers n and s (2 β€ n β€ 105, 2 β€ s β€ 106) β the number of people and the rays' speed.
The next n lines contain the description of people. The i-th of these lines contains three integers xi, vi and ti (0 < xi < 106, 1 β€ vi < s, 1 β€ ti β€ 2) β the coordinate of the i-th person on the line, his maximum speed and the direction he will run to (1 is to the left, i.e. in the direction of coordinate decrease, 2 is to the right, i.e. in the direction of coordinate increase), respectively.
It is guaranteed that the points 0 and 106 will be reached independently of the bomb's position.
Output
Print the minimum time needed for both points 0 and 106 to be reached.
Your answer is considered correct if its absolute or relative error doesn't exceed 10 - 6. Namely, if your answer is a, and the jury's answer is b, then your answer is accepted, if <image>.
Examples
Input
2 999
400000 1 2
500000 1 1
Output
500000.000000000000000000000000000000
Input
2 1000
400000 500 1
600000 500 2
Output
400.000000000000000000000000000000
Note
In the first example, it is optimal to place the bomb at a point with a coordinate of 400000. Then at time 0, the speed of the first person becomes 1000 and he reaches the point 106 at the time 600. The bomb will not affect on the second person, and he will reach the 0 point at the time 500000.
In the second example, it is optimal to place the bomb at the point 500000. The rays will catch up with both people at the time 200. At this time moment, the first is at the point with a coordinate of 300000, and the second is at the point with a coordinate of 700000. Their speed will become 1500 and at the time 400 they will simultaneously run through points 0 and 106.
Submitted Solution:
```
print('hello')
print('go')
print('testing')
```
|
instruction
| 0
| 95,784
| 3
| 191,568
|
No
|
output
| 1
| 95,784
| 3
| 191,569
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dr .: Peter, I've finally done it.
Peter: See you again? What kind of silly invention is this time?
Dr .: I finally came up with a revolutionary way to process mathematical formulas on a computer. Look at this table.
Ordinary notation | Dr.'s "breakthrough" notation
--- | ---
1 + 2 | 1 2 +
3 * 4 + 7 | 3 4 * 7 +
10 / (2 --12) | 10 2 12-/
(3-4) * (7 + 2 * 3) | 3 4 --7 2 3 * + *
Peter: Yeah.
Dr .: Fufufu. This alone won't tell you what it means to an inexperienced person. It's important from here.
Peter: I mean ...
Dr .: You know that computers have a data structure called a stack. Look, that's "first in, then out".
Peter: Yes. I know, that ...
Dr .: This groundbreaking notation uses that stack. For example, this 10 2 12-/, but process as follows.
Processing target | 10 | 2 | 12 |-| /
--- | --- | --- | --- | --- | ---
| β | β | β | β 2-12 | β 10 / -10
Stack | |.
---
..
Ten
| ..
---
2
Ten
| 12
---
2
Ten
| ..
---
-Ten
Ten
| ..
---
..
-1
Dr .: How is it? You don't have to worry about parentheses or operator precedence, right? The word order is also "10 divided by 2 minus 12", which is somewhat similar to his Far Eastern island nation, Japanese. With this epoch-making invention, our laboratory is safe. Fafafa.
Peter: I mean, Doctor. I learned this in the basic course at the University of Aizu when I was in Japan. Everyone had a simple program called "Reverse Polish Notation".
Dr .: ...
So, instead of Peter, I decided to teach this program to the doctor. Create a program that inputs the formula written in "Reverse Polish Notation" and outputs the calculation result.
input
Given multiple datasets. For each dataset, a formula in Reverse Polish Notation (a string of up to 80 characters with integers and arithmetic symbols separated by one blank character (half-width)) is given on one line. No formula is given that divides a value by 0 or a value that is as close to 0 as possible.
The number of datasets does not exceed 50.
output
Output the calculation result (real number) on one line for each data set. The calculation result may include an error of 0.00001 or less.
Example
Input
10 2 12 - /
3 4 - 7 2 3 * + *
-1 -2 3 + +
Output
-1.000000
-13.000000
0.000000
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
import math
for s in sys.stdin:
lst = s.split()
# stack
S = []
for c in lst:
if c == '+':
a = S.pop()
b = S.pop()
S.append(b + a)
elif c == '-':
a = S.pop()
b = S.pop()
S.append(b - a)
elif c == '*':
a = S.pop()
b = S.pop()
S.append(b * a)
elif c == '/':
a = S.pop()
b = S.pop()
S.append(b / a)
else:
S.append(float(c))
print(S[0])
```
|
instruction
| 0
| 95,990
| 3
| 191,980
|
Yes
|
output
| 1
| 95,990
| 3
| 191,981
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dr .: Peter, I've finally done it.
Peter: See you again? What kind of silly invention is this time?
Dr .: I finally came up with a revolutionary way to process mathematical formulas on a computer. Look at this table.
Ordinary notation | Dr.'s "breakthrough" notation
--- | ---
1 + 2 | 1 2 +
3 * 4 + 7 | 3 4 * 7 +
10 / (2 --12) | 10 2 12-/
(3-4) * (7 + 2 * 3) | 3 4 --7 2 3 * + *
Peter: Yeah.
Dr .: Fufufu. This alone won't tell you what it means to an inexperienced person. It's important from here.
Peter: I mean ...
Dr .: You know that computers have a data structure called a stack. Look, that's "first in, then out".
Peter: Yes. I know, that ...
Dr .: This groundbreaking notation uses that stack. For example, this 10 2 12-/, but process as follows.
Processing target | 10 | 2 | 12 |-| /
--- | --- | --- | --- | --- | ---
| β | β | β | β 2-12 | β 10 / -10
Stack | |.
---
..
Ten
| ..
---
2
Ten
| 12
---
2
Ten
| ..
---
-Ten
Ten
| ..
---
..
-1
Dr .: How is it? You don't have to worry about parentheses or operator precedence, right? The word order is also "10 divided by 2 minus 12", which is somewhat similar to his Far Eastern island nation, Japanese. With this epoch-making invention, our laboratory is safe. Fafafa.
Peter: I mean, Doctor. I learned this in the basic course at the University of Aizu when I was in Japan. Everyone had a simple program called "Reverse Polish Notation".
Dr .: ...
So, instead of Peter, I decided to teach this program to the doctor. Create a program that inputs the formula written in "Reverse Polish Notation" and outputs the calculation result.
input
Given multiple datasets. For each dataset, a formula in Reverse Polish Notation (a string of up to 80 characters with integers and arithmetic symbols separated by one blank character (half-width)) is given on one line. No formula is given that divides a value by 0 or a value that is as close to 0 as possible.
The number of datasets does not exceed 50.
output
Output the calculation result (real number) on one line for each data set. The calculation result may include an error of 0.00001 or less.
Example
Input
10 2 12 - /
3 4 - 7 2 3 * + *
-1 -2 3 + +
Output
-1.000000
-13.000000
0.000000
Submitted Solution:
```
import sys
f = sys.stdin
from collections import deque
import operator
func = {'+':operator.add,'-':operator.sub,'*':operator.mul,'/':operator.truediv }
for line in f:
stack = deque()
for element in line.strip().split():
if element in func:
b = stack.pop()
a = stack.pop()
stack.append(func[element](a, b))
else:
stack.append(float(element))
print('{:.6f}'.format(stack[0]))
```
|
instruction
| 0
| 95,991
| 3
| 191,982
|
Yes
|
output
| 1
| 95,991
| 3
| 191,983
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dr .: Peter, I've finally done it.
Peter: See you again? What kind of silly invention is this time?
Dr .: I finally came up with a revolutionary way to process mathematical formulas on a computer. Look at this table.
Ordinary notation | Dr.'s "breakthrough" notation
--- | ---
1 + 2 | 1 2 +
3 * 4 + 7 | 3 4 * 7 +
10 / (2 --12) | 10 2 12-/
(3-4) * (7 + 2 * 3) | 3 4 --7 2 3 * + *
Peter: Yeah.
Dr .: Fufufu. This alone won't tell you what it means to an inexperienced person. It's important from here.
Peter: I mean ...
Dr .: You know that computers have a data structure called a stack. Look, that's "first in, then out".
Peter: Yes. I know, that ...
Dr .: This groundbreaking notation uses that stack. For example, this 10 2 12-/, but process as follows.
Processing target | 10 | 2 | 12 |-| /
--- | --- | --- | --- | --- | ---
| β | β | β | β 2-12 | β 10 / -10
Stack | |.
---
..
Ten
| ..
---
2
Ten
| 12
---
2
Ten
| ..
---
-Ten
Ten
| ..
---
..
-1
Dr .: How is it? You don't have to worry about parentheses or operator precedence, right? The word order is also "10 divided by 2 minus 12", which is somewhat similar to his Far Eastern island nation, Japanese. With this epoch-making invention, our laboratory is safe. Fafafa.
Peter: I mean, Doctor. I learned this in the basic course at the University of Aizu when I was in Japan. Everyone had a simple program called "Reverse Polish Notation".
Dr .: ...
So, instead of Peter, I decided to teach this program to the doctor. Create a program that inputs the formula written in "Reverse Polish Notation" and outputs the calculation result.
input
Given multiple datasets. For each dataset, a formula in Reverse Polish Notation (a string of up to 80 characters with integers and arithmetic symbols separated by one blank character (half-width)) is given on one line. No formula is given that divides a value by 0 or a value that is as close to 0 as possible.
The number of datasets does not exceed 50.
output
Output the calculation result (real number) on one line for each data set. The calculation result may include an error of 0.00001 or less.
Example
Input
10 2 12 - /
3 4 - 7 2 3 * + *
-1 -2 3 + +
Output
-1.000000
-13.000000
0.000000
Submitted Solution:
```
while(1):
try:
a = [i for i in input().split()]
stack = []
l = len(stack)
for i in a:
if i == "+":
x = stack[l-2]
y = stack[l-1]
stack.pop()
stack.pop()
stack.append(x+y)
elif i == "-":
x = stack[l-2]
y = stack[l-1]
stack.pop()
stack.pop()
stack.append(x-y)
elif i == "*":
x = stack[l-2]
y = stack[l-1]
stack.pop()
stack.pop()
stack.append(x*y)
elif i == "/":
x = stack[l-2]
y = stack[l-1]
stack.pop()
stack.pop()
stack.append(x/y)
else:
stack.append(float(i))
print("{:.6f}".format(stack[0]))
except EOFError:
break
```
|
instruction
| 0
| 95,992
| 3
| 191,984
|
Yes
|
output
| 1
| 95,992
| 3
| 191,985
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dr .: Peter, I've finally done it.
Peter: See you again? What kind of silly invention is this time?
Dr .: I finally came up with a revolutionary way to process mathematical formulas on a computer. Look at this table.
Ordinary notation | Dr.'s "breakthrough" notation
--- | ---
1 + 2 | 1 2 +
3 * 4 + 7 | 3 4 * 7 +
10 / (2 --12) | 10 2 12-/
(3-4) * (7 + 2 * 3) | 3 4 --7 2 3 * + *
Peter: Yeah.
Dr .: Fufufu. This alone won't tell you what it means to an inexperienced person. It's important from here.
Peter: I mean ...
Dr .: You know that computers have a data structure called a stack. Look, that's "first in, then out".
Peter: Yes. I know, that ...
Dr .: This groundbreaking notation uses that stack. For example, this 10 2 12-/, but process as follows.
Processing target | 10 | 2 | 12 |-| /
--- | --- | --- | --- | --- | ---
| β | β | β | β 2-12 | β 10 / -10
Stack | |.
---
..
Ten
| ..
---
2
Ten
| 12
---
2
Ten
| ..
---
-Ten
Ten
| ..
---
..
-1
Dr .: How is it? You don't have to worry about parentheses or operator precedence, right? The word order is also "10 divided by 2 minus 12", which is somewhat similar to his Far Eastern island nation, Japanese. With this epoch-making invention, our laboratory is safe. Fafafa.
Peter: I mean, Doctor. I learned this in the basic course at the University of Aizu when I was in Japan. Everyone had a simple program called "Reverse Polish Notation".
Dr .: ...
So, instead of Peter, I decided to teach this program to the doctor. Create a program that inputs the formula written in "Reverse Polish Notation" and outputs the calculation result.
input
Given multiple datasets. For each dataset, a formula in Reverse Polish Notation (a string of up to 80 characters with integers and arithmetic symbols separated by one blank character (half-width)) is given on one line. No formula is given that divides a value by 0 or a value that is as close to 0 as possible.
The number of datasets does not exceed 50.
output
Output the calculation result (real number) on one line for each data set. The calculation result may include an error of 0.00001 or less.
Example
Input
10 2 12 - /
3 4 - 7 2 3 * + *
-1 -2 3 + +
Output
-1.000000
-13.000000
0.000000
Submitted Solution:
```
while 1:
try:s=list(input().split())
except:break
a=[]
for x in s:
if x in ['+','-','*','/']:
c,b=str(a.pop()),str(a.pop())
a+=[float(eval(b+x+c))]
else:a+=[float(x)]
print(*a)
```
|
instruction
| 0
| 95,993
| 3
| 191,986
|
Yes
|
output
| 1
| 95,993
| 3
| 191,987
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dr .: Peter, I've finally done it.
Peter: See you again? What kind of silly invention is this time?
Dr .: I finally came up with a revolutionary way to process mathematical formulas on a computer. Look at this table.
Ordinary notation | Dr.'s "breakthrough" notation
--- | ---
1 + 2 | 1 2 +
3 * 4 + 7 | 3 4 * 7 +
10 / (2 --12) | 10 2 12-/
(3-4) * (7 + 2 * 3) | 3 4 --7 2 3 * + *
Peter: Yeah.
Dr .: Fufufu. This alone won't tell you what it means to an inexperienced person. It's important from here.
Peter: I mean ...
Dr .: You know that computers have a data structure called a stack. Look, that's "first in, then out".
Peter: Yes. I know, that ...
Dr .: This groundbreaking notation uses that stack. For example, this 10 2 12-/, but process as follows.
Processing target | 10 | 2 | 12 |-| /
--- | --- | --- | --- | --- | ---
| β | β | β | β 2-12 | β 10 / -10
Stack | |.
---
..
Ten
| ..
---
2
Ten
| 12
---
2
Ten
| ..
---
-Ten
Ten
| ..
---
..
-1
Dr .: How is it? You don't have to worry about parentheses or operator precedence, right? The word order is also "10 divided by 2 minus 12", which is somewhat similar to his Far Eastern island nation, Japanese. With this epoch-making invention, our laboratory is safe. Fafafa.
Peter: I mean, Doctor. I learned this in the basic course at the University of Aizu when I was in Japan. Everyone had a simple program called "Reverse Polish Notation".
Dr .: ...
So, instead of Peter, I decided to teach this program to the doctor. Create a program that inputs the formula written in "Reverse Polish Notation" and outputs the calculation result.
input
Given multiple datasets. For each dataset, a formula in Reverse Polish Notation (a string of up to 80 characters with integers and arithmetic symbols separated by one blank character (half-width)) is given on one line. No formula is given that divides a value by 0 or a value that is as close to 0 as possible.
The number of datasets does not exceed 50.
output
Output the calculation result (real number) on one line for each data set. The calculation result may include an error of 0.00001 or less.
Example
Input
10 2 12 - /
3 4 - 7 2 3 * + *
-1 -2 3 + +
Output
-1.000000
-13.000000
0.000000
Submitted Solution:
```
import sys
def line():return sys.stdin.readline().strip()
ops = {"+":lambda a,b:b + a,
"-":lambda a,b:b - a,
"*":lambda a,b:b * a,
"/":lambda a,b:b / a}
while True:
stack = []
for s in line().split():
if s in ops:
stack.append(ops[s](stack.pop(),stack.pop()))
else:
stack.append(int(s))
print(stack[0])
```
|
instruction
| 0
| 95,994
| 3
| 191,988
|
No
|
output
| 1
| 95,994
| 3
| 191,989
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dr .: Peter, I've finally done it.
Peter: See you again? What kind of silly invention is this time?
Dr .: I finally came up with a revolutionary way to process mathematical formulas on a computer. Look at this table.
Ordinary notation | Dr.'s "breakthrough" notation
--- | ---
1 + 2 | 1 2 +
3 * 4 + 7 | 3 4 * 7 +
10 / (2 --12) | 10 2 12-/
(3-4) * (7 + 2 * 3) | 3 4 --7 2 3 * + *
Peter: Yeah.
Dr .: Fufufu. This alone won't tell you what it means to an inexperienced person. It's important from here.
Peter: I mean ...
Dr .: You know that computers have a data structure called a stack. Look, that's "first in, then out".
Peter: Yes. I know, that ...
Dr .: This groundbreaking notation uses that stack. For example, this 10 2 12-/, but process as follows.
Processing target | 10 | 2 | 12 |-| /
--- | --- | --- | --- | --- | ---
| β | β | β | β 2-12 | β 10 / -10
Stack | |.
---
..
Ten
| ..
---
2
Ten
| 12
---
2
Ten
| ..
---
-Ten
Ten
| ..
---
..
-1
Dr .: How is it? You don't have to worry about parentheses or operator precedence, right? The word order is also "10 divided by 2 minus 12", which is somewhat similar to his Far Eastern island nation, Japanese. With this epoch-making invention, our laboratory is safe. Fafafa.
Peter: I mean, Doctor. I learned this in the basic course at the University of Aizu when I was in Japan. Everyone had a simple program called "Reverse Polish Notation".
Dr .: ...
So, instead of Peter, I decided to teach this program to the doctor. Create a program that inputs the formula written in "Reverse Polish Notation" and outputs the calculation result.
input
Given multiple datasets. For each dataset, a formula in Reverse Polish Notation (a string of up to 80 characters with integers and arithmetic symbols separated by one blank character (half-width)) is given on one line. No formula is given that divides a value by 0 or a value that is as close to 0 as possible.
The number of datasets does not exceed 50.
output
Output the calculation result (real number) on one line for each data set. The calculation result may include an error of 0.00001 or less.
Example
Input
10 2 12 - /
3 4 - 7 2 3 * + *
-1 -2 3 + +
Output
-1.000000
-13.000000
0.000000
Submitted Solution:
```
s=list();[[[s.append(eval('{2}{1}{0}'.format(s.pop(),i,s.pop()))if(i in'+-*/')else i)for i in input().split(' ')]and print(s.pop())]for x in __import__('itertools').count()]
```
|
instruction
| 0
| 95,995
| 3
| 191,990
|
No
|
output
| 1
| 95,995
| 3
| 191,991
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dr .: Peter, I've finally done it.
Peter: See you again? What kind of silly invention is this time?
Dr .: I finally came up with a revolutionary way to process mathematical formulas on a computer. Look at this table.
Ordinary notation | Dr.'s "breakthrough" notation
--- | ---
1 + 2 | 1 2 +
3 * 4 + 7 | 3 4 * 7 +
10 / (2 --12) | 10 2 12-/
(3-4) * (7 + 2 * 3) | 3 4 --7 2 3 * + *
Peter: Yeah.
Dr .: Fufufu. This alone won't tell you what it means to an inexperienced person. It's important from here.
Peter: I mean ...
Dr .: You know that computers have a data structure called a stack. Look, that's "first in, then out".
Peter: Yes. I know, that ...
Dr .: This groundbreaking notation uses that stack. For example, this 10 2 12-/, but process as follows.
Processing target | 10 | 2 | 12 |-| /
--- | --- | --- | --- | --- | ---
| β | β | β | β 2-12 | β 10 / -10
Stack | |.
---
..
Ten
| ..
---
2
Ten
| 12
---
2
Ten
| ..
---
-Ten
Ten
| ..
---
..
-1
Dr .: How is it? You don't have to worry about parentheses or operator precedence, right? The word order is also "10 divided by 2 minus 12", which is somewhat similar to his Far Eastern island nation, Japanese. With this epoch-making invention, our laboratory is safe. Fafafa.
Peter: I mean, Doctor. I learned this in the basic course at the University of Aizu when I was in Japan. Everyone had a simple program called "Reverse Polish Notation".
Dr .: ...
So, instead of Peter, I decided to teach this program to the doctor. Create a program that inputs the formula written in "Reverse Polish Notation" and outputs the calculation result.
input
Given multiple datasets. For each dataset, a formula in Reverse Polish Notation (a string of up to 80 characters with integers and arithmetic symbols separated by one blank character (half-width)) is given on one line. No formula is given that divides a value by 0 or a value that is as close to 0 as possible.
The number of datasets does not exceed 50.
output
Output the calculation result (real number) on one line for each data set. The calculation result may include an error of 0.00001 or less.
Example
Input
10 2 12 - /
3 4 - 7 2 3 * + *
-1 -2 3 + +
Output
-1.000000
-13.000000
0.000000
Submitted Solution:
```
#!/usr/bin/env python3
import sys
def calc_inverse_polish_notation_string(s):
tokens = [token for token in s.split(' ') if token != '']
stack = []
for token in tokens:
if token in ['+', '-', '*', '/']:
val2 = stack.pop()
val1 = stack.pop()
result = eval("%s %s %s" % (val1, token, val2))
stack.append(result)
else:
stack.append(token)
return stack[0] # if len(stack) != 1, it should throw an exception
def main():
for line in sys.stdin.readlines():
print(calc_inverse_polish_notation_string(line))
if __name__ == "__main__":
main()
```
|
instruction
| 0
| 95,996
| 3
| 191,992
|
No
|
output
| 1
| 95,996
| 3
| 191,993
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dr .: Peter, I've finally done it.
Peter: See you again? What kind of silly invention is this time?
Dr .: I finally came up with a revolutionary way to process mathematical formulas on a computer. Look at this table.
Ordinary notation | Dr.'s "breakthrough" notation
--- | ---
1 + 2 | 1 2 +
3 * 4 + 7 | 3 4 * 7 +
10 / (2 --12) | 10 2 12-/
(3-4) * (7 + 2 * 3) | 3 4 --7 2 3 * + *
Peter: Yeah.
Dr .: Fufufu. This alone won't tell you what it means to an inexperienced person. It's important from here.
Peter: I mean ...
Dr .: You know that computers have a data structure called a stack. Look, that's "first in, then out".
Peter: Yes. I know, that ...
Dr .: This groundbreaking notation uses that stack. For example, this 10 2 12-/, but process as follows.
Processing target | 10 | 2 | 12 |-| /
--- | --- | --- | --- | --- | ---
| β | β | β | β 2-12 | β 10 / -10
Stack | |.
---
..
Ten
| ..
---
2
Ten
| 12
---
2
Ten
| ..
---
-Ten
Ten
| ..
---
..
-1
Dr .: How is it? You don't have to worry about parentheses or operator precedence, right? The word order is also "10 divided by 2 minus 12", which is somewhat similar to his Far Eastern island nation, Japanese. With this epoch-making invention, our laboratory is safe. Fafafa.
Peter: I mean, Doctor. I learned this in the basic course at the University of Aizu when I was in Japan. Everyone had a simple program called "Reverse Polish Notation".
Dr .: ...
So, instead of Peter, I decided to teach this program to the doctor. Create a program that inputs the formula written in "Reverse Polish Notation" and outputs the calculation result.
input
Given multiple datasets. For each dataset, a formula in Reverse Polish Notation (a string of up to 80 characters with integers and arithmetic symbols separated by one blank character (half-width)) is given on one line. No formula is given that divides a value by 0 or a value that is as close to 0 as possible.
The number of datasets does not exceed 50.
output
Output the calculation result (real number) on one line for each data set. The calculation result may include an error of 0.00001 or less.
Example
Input
10 2 12 - /
3 4 - 7 2 3 * + *
-1 -2 3 + +
Output
-1.000000
-13.000000
0.000000
Submitted Solution:
```
import sys
f = sys.stdin
from collections import deque
import operator
func = {'+':operator.add,'-':operator.sub,'*':operator.mul,'/':operator.div }
for line in f:
stack = deque()
for element in line.strip().split():
if element.isdigit():
stack.append(float(element))
else:
b = stack.pop()
a = stack.pop()
stack.append(func[element](a, b))
print('{:.6f}'.format(stack[0]))
```
|
instruction
| 0
| 95,997
| 3
| 191,994
|
No
|
output
| 1
| 95,997
| 3
| 191,995
|
Provide a correct Python 3 solution for this coding contest problem.
In the year 30XX, an expedition team reached a planet and found a warp machine suggesting the existence of a mysterious supercivilization. When you go through one of its entrance gates, you can instantaneously move to the exit irrespective of how far away it is. You can move even to the end of the universe at will with this technology!
The scientist team started examining the machine and successfully identified all the planets on which the entrances to the machine were located. Each of these N planets (identified by an index from $1$ to $N$) has an entrance to, and an exit from the warp machine. Each of the entrances and exits has a letter inscribed on it.
The mechanism of spatial mobility through the warp machine is as follows:
* If you go into an entrance gate labeled with c, then you can exit from any gate with label c.
* If you go into an entrance located on the $i$-th planet, then you can exit from any gate located on the $j$-th planet where $i < j$.
Once you have reached an exit of the warp machine on a planet, you can continue your journey by entering into the warp machine on the same planet. In this way, you can reach a faraway planet. Our human race has decided to dispatch an expedition to the star $N$, starting from Star $1$ and using the warp machine until it reaches Star $N$. To evaluate the possibility of successfully reaching the destination. it is highly desirable for us to know how many different routes are available for the expedition team to track.
Given information regarding the stars, make a program to enumerate the passages from Star $1$ to Star $N$.
Input
The input is given in the following format.
$N$
$s$
$t$
The first line provides the number of the stars on which the warp machine is located $N$ ($2 \leq N \leq 100,000$). The second line provides a string $s$ of length $N$, each component of which represents the letter inscribed on the entrance of the machine on the star. By the same token, the third line provides a string $t$ of length $N$ consisting of the letters inscribed on the exit of the machine. Two strings $s$ and $t$ consist all of lower-case alphabetical letters, and the $i$-th letter of these strings corresponds respectively to the entrance and exit of Star $i$ machine.
Output
Divide the number of possible routes from Star $1$ to Star $N$ obtained above by 1,000,000,007, and output the remainder.
Examples
Input
6
abbaba
baabab
Output
5
Input
25
neihsokcpuziafoytisrevinu
universityofaizupckoshien
Output
4
|
instruction
| 0
| 96,014
| 3
| 192,028
|
"Correct Solution:
```
N = int(input())
s = input()
t = input()
D = {t[-1]: 1}
for i in range(N-2, 0, -1):
si = s[i]; ti = t[i]
v = D.get(si, 0)
D[ti] = (D.get(ti, 0) + v) % (10**9+7)
print(D.get(s[0], 0))
```
|
output
| 1
| 96,014
| 3
| 192,029
|
Provide a correct Python 3 solution for this coding contest problem.
In the year 30XX, an expedition team reached a planet and found a warp machine suggesting the existence of a mysterious supercivilization. When you go through one of its entrance gates, you can instantaneously move to the exit irrespective of how far away it is. You can move even to the end of the universe at will with this technology!
The scientist team started examining the machine and successfully identified all the planets on which the entrances to the machine were located. Each of these N planets (identified by an index from $1$ to $N$) has an entrance to, and an exit from the warp machine. Each of the entrances and exits has a letter inscribed on it.
The mechanism of spatial mobility through the warp machine is as follows:
* If you go into an entrance gate labeled with c, then you can exit from any gate with label c.
* If you go into an entrance located on the $i$-th planet, then you can exit from any gate located on the $j$-th planet where $i < j$.
Once you have reached an exit of the warp machine on a planet, you can continue your journey by entering into the warp machine on the same planet. In this way, you can reach a faraway planet. Our human race has decided to dispatch an expedition to the star $N$, starting from Star $1$ and using the warp machine until it reaches Star $N$. To evaluate the possibility of successfully reaching the destination. it is highly desirable for us to know how many different routes are available for the expedition team to track.
Given information regarding the stars, make a program to enumerate the passages from Star $1$ to Star $N$.
Input
The input is given in the following format.
$N$
$s$
$t$
The first line provides the number of the stars on which the warp machine is located $N$ ($2 \leq N \leq 100,000$). The second line provides a string $s$ of length $N$, each component of which represents the letter inscribed on the entrance of the machine on the star. By the same token, the third line provides a string $t$ of length $N$ consisting of the letters inscribed on the exit of the machine. Two strings $s$ and $t$ consist all of lower-case alphabetical letters, and the $i$-th letter of these strings corresponds respectively to the entrance and exit of Star $i$ machine.
Output
Divide the number of possible routes from Star $1$ to Star $N$ obtained above by 1,000,000,007, and output the remainder.
Examples
Input
6
abbaba
baabab
Output
5
Input
25
neihsokcpuziafoytisrevinu
universityofaizupckoshien
Output
4
|
instruction
| 0
| 96,015
| 3
| 192,030
|
"Correct Solution:
```
from collections import defaultdict
MOD = 1000000007
n = int(input())
s = input()
t = input()
dic = defaultdict(int)
dic[s[0]] = 1
for cs, ct in zip(s[1:n-1], t[1:n-1]):
dic[cs] += dic[ct]
dic[cs] %= MOD
print(dic[t[-1]])
```
|
output
| 1
| 96,015
| 3
| 192,031
|
Provide a correct Python 3 solution for this coding contest problem.
An bydrocarbon is an organic compound which contains only carbons and hydrogens. An isomer is a compound that has the same number of carbons but different structures. Heptane, for example, is a hydrocarbon with 7 carbons. It has nine isomers. The structural formula of three are shown in Figure 1. Carbons are represented by the letter C, and bonds between carbons are represented by a straight line. In all figures, hydrogens are not represented for simplicity. Each carbon can be connected to a maximum of 4 carbons.
<image>
---
Figure 1: These three examples of isomers of heptane have the same number of carbons but different structures.
---
Let define a chain in an isomer as a sequence of connected carbons without branches. An isomer can have many chains of the same length. Figure 2 shows the longest chain of carbons for each of the represented isomer. Note that there can be many instances of longest chain in an isomer.
<image>
---
Figure 2: The figures shows one instance of longest chain of carbons in each isomer. The first and the second isomers show longest chains of 5 carbons. The longest chain in the third isomer has 4 carbons.
---
Your task is to identify the number of carbons of the largest possible carbon compound whose longest carbon chain has n (1 β€ n β€ 30) carbons.
Input
Each input contains a list of number of carbons, i.e. the length of a carbon chain.
The number of input lines is less than or equal to 30.
Output
For each number n in input, identify the number of carbons of the largest possible carbon compound whose longest carbon chain has n carbons.
Example
Input
1
4
Output
1
8
|
instruction
| 0
| 96,016
| 3
| 192,032
|
"Correct Solution:
```
# AOJ 1011: Finding the Largest Carbon Compound Give...
# Python3 2018.7.4 bal4u
a = [0]*32
a[1], a[2] = 1, 2
for i in range(3, 31): a[i] = 3*a[i-2] + 2
while True:
try: i = int(input())
except: break
print(a[i])
```
|
output
| 1
| 96,016
| 3
| 192,033
|
Provide a correct Python 3 solution for this coding contest problem.
After long studying how embryos of organisms become asymmetric during their development, Dr. Podboq, a famous biologist, has reached his new hypothesis. Dr. Podboq is now preparing a poster for the coming academic conference, which shows a tree representing the development process of an embryo through repeated cell divisions starting from one cell. Your job is to write a program that transforms given trees into forms satisfying some conditions so that it is easier for the audience to get the idea.
A tree representing the process of cell divisions has a form described below.
* The starting cell is represented by a circle placed at the top.
* Each cell either terminates the division activity or divides into two cells. Therefore, from each circle representing a cell, there are either no branch downward, or two branches down to its two child cells.
Below is an example of such a tree.
<image>
Figure F-1: A tree representing a process of cell divisions
According to Dr. Podboq's hypothesis, we can determine which cells have stronger or weaker asymmetricity by looking at the structure of this tree representation. First, his hypothesis defines "left-right similarity" of cells as follows:
1. The left-right similarity of a cell that did not divide further is 0.
2. For a cell that did divide further, we collect the partial trees starting from its child or descendant cells, and count how many kinds of structures they have. Then, the left-right similarity of the cell is defined to be the ratio of the number of structures that appear both in the right child side and the left child side. We regard two trees have the same structure if we can make them have exactly the same shape by interchanging two child cells of arbitrary cells.
For example, suppose we have a tree shown below:
<image>
Figure F-2: An example tree
The left-right similarity of the cell A is computed as follows. First, within the descendants of the cell B, which is the left child cell of A, the following three kinds of structures appear. Notice that the rightmost structure appears three times, but when we count the number of structures, we count it only once.
<image>
Figure F-3: Structures appearing within the descendants of the cell B
On the other hand, within the descendants of the cell C, which is the right child cell of A, the following four kinds of structures appear.
<image>
Figure F-4: Structures appearing within the descendants of the cell C
Among them, the first, second, and third ones within the B side are regarded as the same structure as the second, third, and fourth ones within the C side, respectively. Therefore, there are four structures in total, and three among them are common to the left side and the right side, which means the left-right similarity of A is 3/4.
Given the left-right similarity of each cell, Dr. Podboq's hypothesis says we can determine which of the cells X and Y has stronger asymmetricity by the following rules.
1. If X and Y have different left-right similarities, the one with lower left-right similarity has stronger asymmetricity.
2. Otherwise, if neither X nor Y has child cells, they have completely equal asymmetricity.
3. Otherwise, both X and Y must have two child cells. In this case, we compare the child cell of X with stronger (or equal) asymmetricity (than the other child cell of X) and the child cell of Y with stronger (or equal) asymmetricity (than the other child cell of Y), and the one having a child with stronger asymmetricity has stronger asymmetricity.
4. If we still have a tie, we compare the other child cells of X and Y with weaker (or equal) asymmetricity, and the one having a child with stronger asymmetricity has stronger asymmetricity.
5. If we still have a tie again, X and Y have completely equal asymmetricity.
When we compare child cells in some rules above, we recursively apply this rule set.
Now, your job is to write a program that transforms a given tree representing a process of cell divisions, by interchanging two child cells of arbitrary cells, into a tree where the following conditions are satisfied.
1. For every cell X which is the starting cell of the given tree or a left child cell of some parent cell, if X has two child cells, the one at left has stronger (or equal) asymmetricity than the one at right.
2. For every cell X which is a right child cell of some parent cell, if X has two child cells, the one at right has stronger (or equal) asymmetricity than the one at left.
In case two child cells have equal asymmetricity, their order is arbitrary because either order would results in trees of the same shape.
For example, suppose we are given the tree in Figure F-2. First we compare B and C, and because B has lower left-right similarity, which means stronger asymmetricity, we keep B at left and C at right. Next, because B is the left child cell of A, we compare two child cells of B, and the one with stronger asymmetricity is positioned at left. On the other hand, because C is the right child cell of A, we compare two child cells of C, and the one with stronger asymmetricity is positioned at right. We examine the other cells in the same way, and the tree is finally transformed into the tree shown below.
<image>
Figure F-5: The example tree after the transformation
Please be warned that the only operation allowed in the transformation of a tree is to interchange two child cells of some parent cell. For example, you are not allowed to transform the tree in Figure F-2 into the tree below.
<image>
Figure F-6: An example of disallowed transformation
Input
The input consists of n lines (1β€nβ€100) describing n trees followed by a line only containing a single zero which represents the end of the input. Each tree includes at least 1 and at most 127 cells. Below is an example of a tree description.
> `((x (x x)) x)`
This description represents the tree shown in Figure F-1. More formally, the description of a tree is in either of the following two formats.
> "`(`" <description of a tree starting at the left child> <single space> <description of a tree starting at the right child> ")"
or
> "`x`"
The former is the description of a tree whose starting cell has two child cells, and the latter is the description of a tree whose starting cell has no child cell.
Output
For each tree given in the input, print a line describing the result of the tree transformation. In the output, trees should be described in the same formats as the input, and the tree descriptions must appear in the same order as the input. Each line should have no extra character other than one tree description.
Sample Input
(((x x) x) ((x x) (x (x x))))
(((x x) (x x)) ((x x) ((x x) (x x))))
(((x x) ((x x) x)) (((x (x x)) x) (x x)))
(((x x) x) ((x x) (((((x x) x) x) x) x)))
(((x x) x) ((x (x x)) (x (x x))))
((((x (x x)) x) (x ((x x) x))) ((x (x x)) (x x)))
((((x x) x) ((x x) (x (x x)))) (((x x) (x x)) ((x x) ((x x) (x x)))))
0
Output for the Sample Input
((x (x x)) ((x x) ((x x) x)))
(((x x) ((x x) (x x))) ((x x) (x x)))
(((x ((x x) x)) (x x)) ((x x) ((x x) x)))
(((x ((x ((x x) x)) x)) (x x)) ((x x) x))
((x (x x)) ((x (x x)) ((x x) x)))
(((x (x x)) (x x)) ((x ((x x) x)) ((x (x x)) x)))
(((x (x x)) ((x x) ((x x) x))) (((x x) (x x)) (((x x) (x x)) (x x))))
Example
Input
(((x x) x) ((x x) (x (x x))))
(((x x) (x x)) ((x x) ((x x) (x x))))
(((x x) ((x x) x)) (((x (x x)) x) (x x)))
(((x x) x) ((x x) (((((x x) x) x) x) x)))
(((x x) x) ((x (x x)) (x (x x))))
((((x (x x)) x) (x ((x x) x))) ((x (x x)) (x x)))
((((x x) x) ((x x) (x (x x)))) (((x x) (x x)) ((x x) ((x x) (x x)))))
0
Output
((x (x x)) ((x x) ((x x) x)))
(((x x) ((x x) (x x))) ((x x) (x x)))
(((x ((x x) x)) (x x)) ((x x) ((x x) x)))
(((x ((x ((x x) x)) x)) (x x)) ((x x) x))
((x (x x)) ((x (x x)) ((x x) x)))
(((x (x x)) (x x)) ((x ((x x) x)) ((x (x x)) x)))
(((x (x x)) ((x x) ((x x) x))) (((x x) (x x)) (((x x) (x x)) (x x))))
|
instruction
| 0
| 96,017
| 3
| 192,034
|
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def parse(S):
S = S + "$"
cur = 0
mp = {"01": 0}
sp = {"01": {0}}
sv = {"01": (0, 1)}
lbl = 1
fmt = "0{}{}1".format
def comp(left, right):
lcs, lb = left
rcs, rb = right
a0, b0 = sv[lb]
a1, b1 = sv[rb]
if a1*b0 != a0*b1:
return a1*b0 - a0*b1
if lcs is None and rcs is None:
return 0
ll, lr = lcs
rl, rr = rcs
cl = comp(ll, rl)
if cl != 0:
return cl
cr = comp(lr, rr)
if cr != 0:
return cr
return 0
def expr():
nonlocal cur, lbl
if S[cur] == "x":
cur += 1 # "x"
return (None, "01")
cur += 1 # "("
left = expr()
cur += 1 # " "
right = expr()
cur += 1 # ")"
lb = left[1]; rb = right[1]
eb = fmt(lb, rb) if lb < rb else fmt(rb, lb)
if eb not in mp:
mp[eb] = lbl
sp[eb] = sp[lb] | sp[rb] | {lbl}
sv[eb] = (len(sp[lb] & sp[rb]), len(sp[lb] | sp[rb]))
lbl += 1
if comp(left, right) < 0:
left, right = right, left
return ((left, right), eb)
return expr()
def dfs(root, m):
if root[0] is None:
return "x"
left, right = root[0]
if m == 0:
return "({} {})".format(dfs(left, 0), dfs(right, 1))
return "({} {})".format(dfs(right, 0), dfs(left, 1))
def solve():
S = readline().strip()
if S == "0":
return False
res = parse(S)
write(dfs(res, 0))
write("\n")
return True
while solve():
...
```
|
output
| 1
| 96,017
| 3
| 192,035
|
Provide a correct Python 3 solution for this coding contest problem.
A dial lock is a kind of lock which has some dials with printed numbers. It has a special sequence of numbers, namely an unlocking sequence, to be opened.
You are working at a manufacturer of dial locks. Your job is to verify that every manufactured lock is unlocked by its unlocking sequence. In other words, you have to rotate many dials of many many locks.
Itβs a very hard and boring task. You want to reduce time to open the locks. Itβs a good idea to rotate multiple dials at one time. It is, however, a difficult problem to find steps to open a given lock with the fewest rotations. So you decided to write a program to find such steps for given initial and unlocking sequences.
Your companyβs dial locks are composed of vertically stacked k (1 β€ k β€ 10) cylindrical dials. Every dial has 10 numbers, from 0 to 9, along the side of the cylindrical shape from the left to the right in sequence. The neighbor on the right of 9 is 0.
A dial points one number at a certain position. If you rotate a dial to the left by i digits, the dial newly points the i-th right number. In contrast, if you rotate a dial to the right by i digits, it points the i-th left number. For example, if you rotate a dial pointing 8 to the left by 3 digits, the dial newly points 1.
You can rotate more than one adjacent dial at one time. For example, consider a lock with 5 dials. You can rotate just the 2nd dial. You can rotate the 3rd, 4th and 5th dials at the same time. But you cannot rotate the 1st and 3rd dials at one time without rotating the 2nd dial. When you rotate multiple dials, you have to rotate them to the same direction by the same digits.
Your program is to calculate the fewest number of rotations to unlock, for given initial and unlocking sequences. Rotating one or more adjacent dials to the same direction by the same digits is counted as one rotation.
Input
The input consists of multiple datasets. Each datset consists of two lines. The first line contains an integer k. The second lines contain two strings, separated by a space, which indicate the initial and unlocking sequences.
The last dataset is followed by a line containing one zero. This line is not a part of any dataset and should not be processed.
Output
For each dataset, print the minimum number of rotations in one line.
Example
Input
4
1357 4680
6
777777 003330
0
Output
1
2
|
instruction
| 0
| 96,034
| 3
| 192,068
|
"Correct Solution:
```
def solve():
def bfs(k):
start, goal = file_input.readline().split()
if start == goal:
return 0
start = map(int, start)
goal = map(int, goal)
diff = [(g - s) % 10 for g, s in zip(goal, start)]
q = [diff]
checked = {tuple(diff): True}
ans = 0
while q:
ans += 1
t_q = []
for d in q:
for i, r in enumerate(d):
if r != 0:
break
for j in range(i, k):
d[j] -= r
d[j] %= 10
key = tuple(d)
if key in checked:
continue
if sum(d) == 0:
return ans
checked[key] = True
t_q.append(d[:])
q = t_q
from sys import stdin
file_input = stdin
while True:
k = int(file_input.readline())
if k == 0:
break
print(bfs(k))
solve()
```
|
output
| 1
| 96,034
| 3
| 192,069
|
Provide a correct Python 3 solution for this coding contest problem.
A dial lock is a kind of lock which has some dials with printed numbers. It has a special sequence of numbers, namely an unlocking sequence, to be opened.
You are working at a manufacturer of dial locks. Your job is to verify that every manufactured lock is unlocked by its unlocking sequence. In other words, you have to rotate many dials of many many locks.
Itβs a very hard and boring task. You want to reduce time to open the locks. Itβs a good idea to rotate multiple dials at one time. It is, however, a difficult problem to find steps to open a given lock with the fewest rotations. So you decided to write a program to find such steps for given initial and unlocking sequences.
Your companyβs dial locks are composed of vertically stacked k (1 β€ k β€ 10) cylindrical dials. Every dial has 10 numbers, from 0 to 9, along the side of the cylindrical shape from the left to the right in sequence. The neighbor on the right of 9 is 0.
A dial points one number at a certain position. If you rotate a dial to the left by i digits, the dial newly points the i-th right number. In contrast, if you rotate a dial to the right by i digits, it points the i-th left number. For example, if you rotate a dial pointing 8 to the left by 3 digits, the dial newly points 1.
You can rotate more than one adjacent dial at one time. For example, consider a lock with 5 dials. You can rotate just the 2nd dial. You can rotate the 3rd, 4th and 5th dials at the same time. But you cannot rotate the 1st and 3rd dials at one time without rotating the 2nd dial. When you rotate multiple dials, you have to rotate them to the same direction by the same digits.
Your program is to calculate the fewest number of rotations to unlock, for given initial and unlocking sequences. Rotating one or more adjacent dials to the same direction by the same digits is counted as one rotation.
Input
The input consists of multiple datasets. Each datset consists of two lines. The first line contains an integer k. The second lines contain two strings, separated by a space, which indicate the initial and unlocking sequences.
The last dataset is followed by a line containing one zero. This line is not a part of any dataset and should not be processed.
Output
For each dataset, print the minimum number of rotations in one line.
Example
Input
4
1357 4680
6
777777 003330
0
Output
1
2
|
instruction
| 0
| 96,035
| 3
| 192,070
|
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f(n):
a,b = LS()
if a == b:
return 0
a = [int(c) for c in a]
b = [int(c) for c in b]
aa = [a]
ad = set()
ad.add(tuple(a))
r = 0
while True:
r += 1
na = []
for a in aa:
ti = 0
for i in range(r-1,n):
if a[i] != b[i]:
ti = i
break
sa = b[ti] - a[ti]
for j in range(ti+1, n+1):
t = [(a[i] + sa) % 10 if ti <= i < j else a[i] for i in range(n)]
k = tuple(t)
if k in ad:
continue
if t == b:
return r
ad.add(k)
na.append(t)
aa = na
while True:
n = I()
if n == 0:
break
rr.append(f(n))
return '\n'.join(map(str,rr))
print(main())
```
|
output
| 1
| 96,035
| 3
| 192,071
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A dial lock is a kind of lock which has some dials with printed numbers. It has a special sequence of numbers, namely an unlocking sequence, to be opened.
You are working at a manufacturer of dial locks. Your job is to verify that every manufactured lock is unlocked by its unlocking sequence. In other words, you have to rotate many dials of many many locks.
Itβs a very hard and boring task. You want to reduce time to open the locks. Itβs a good idea to rotate multiple dials at one time. It is, however, a difficult problem to find steps to open a given lock with the fewest rotations. So you decided to write a program to find such steps for given initial and unlocking sequences.
Your companyβs dial locks are composed of vertically stacked k (1 β€ k β€ 10) cylindrical dials. Every dial has 10 numbers, from 0 to 9, along the side of the cylindrical shape from the left to the right in sequence. The neighbor on the right of 9 is 0.
A dial points one number at a certain position. If you rotate a dial to the left by i digits, the dial newly points the i-th right number. In contrast, if you rotate a dial to the right by i digits, it points the i-th left number. For example, if you rotate a dial pointing 8 to the left by 3 digits, the dial newly points 1.
You can rotate more than one adjacent dial at one time. For example, consider a lock with 5 dials. You can rotate just the 2nd dial. You can rotate the 3rd, 4th and 5th dials at the same time. But you cannot rotate the 1st and 3rd dials at one time without rotating the 2nd dial. When you rotate multiple dials, you have to rotate them to the same direction by the same digits.
Your program is to calculate the fewest number of rotations to unlock, for given initial and unlocking sequences. Rotating one or more adjacent dials to the same direction by the same digits is counted as one rotation.
Input
The input consists of multiple datasets. Each datset consists of two lines. The first line contains an integer k. The second lines contain two strings, separated by a space, which indicate the initial and unlocking sequences.
The last dataset is followed by a line containing one zero. This line is not a part of any dataset and should not be processed.
Output
For each dataset, print the minimum number of rotations in one line.
Example
Input
4
1357 4680
6
777777 003330
0
Output
1
2
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f(n):
a,b = LS()
a = [int(c) for c in a]
b = [int(c) for c in b]
aa = [a]
ad = set()
ad.add(tuple(a))
r = 0
while True:
r += 1
na = []
for a in aa:
ti = 0
for i in range(r-1,n):
if a[i] != b[i]:
ti = i
break
sa = b[ti] - a[ti]
for j in range(ti+1, n+1):
t = [(a[i] + sa) % 10 if ti <= i < j else a[i] for i in range(n)]
k = tuple(t)
if k in ad:
continue
if t == b:
return r
ad.add(k)
na.append(t)
aa = na
while True:
n = I()
if n == 0:
break
rr.append(f(n))
return '\n'.join(map(str,rr))
print(main())
```
|
instruction
| 0
| 96,036
| 3
| 192,072
|
No
|
output
| 1
| 96,036
| 3
| 192,073
|
Provide a correct Python 3 solution for this coding contest problem.
The trafic on the Internet is increasing these days due to smartphones. The wireless carriers have to enhance their network infrastructure.
The network of a wireless carrier consists of a number of base stations and lines. Each line connects two base stations bi-directionally. The bandwidth of a line increases every year and is given by a polynomial f(x) of the year x.
Your task is, given the network structure, to write a program to calculate the maximal bandwidth between the 1-st and N-th base stations as a polynomial of x.
Input
The input consists of multiple datasets. Each dataset has the following format:
N M
u1 v1 p1
...
uM vM pM
The first line of each dataset contains two integers N (2 β€ N β€ 50) and M (0 β€ M β€ 500), which indicates the number of base stations and lines respectively. The following M lines describe the network structure. The i-th of them corresponds to the i-th network line and contains two integers ui and vi and a polynomial pi. ui and vi indicate the indices of base stations (1 β€ ui, vi β€ N); pi indicates the network bandwidth.
Each polynomial has the form of:
aLxL + aL-1xL-1 + ... + a2x2 + a1x + a0
where L (0 β€ L β€ 50) is the degree and ai's (0 β€ i β€ L, 0 β€ ai β€ 100) are the coefficients. In the input,
* each term aixi (for i β₯ 2) is represented as <ai>x^<i>
* the linear term (a1x) is represented as <a1>x;
* the constant (a0) is represented just by digits;
* these terms are given in the strictly decreasing order of the degrees and connected by a plus sign ("+");
* just like the standard notations, the <ai> is omitted if ai = 1 for non-constant terms;
* similarly, the entire term is omitted if ai = 0 for any terms; and
* the polynomial representations contain no space or characters other than digits, "x", "^", and "+".
For example, 2x2 + 3x + 5 is represented as 2x^2+3x+5; 2x3 + x is represented as 2x^3+x, not 2x^3+0x^2+1x+0 or the like. No polynomial is a constant zero, i.e. the one with all the coefficients being zero.
The end of input is indicated by a line with two zeros. This line is not part of any dataset.
Output
For each dataset, print the maximal bandwidth as a polynomial of x. The polynomial should be represented in the same way as the input format except that a constant zero is possible and should be represented by "0" (without quotes).
Example
Input
3 3
1 2 x+2
2 3 2x+1
3 1 x+1
2 0
3 2
1 2 x
2 3 2
4 3
1 2 x^3+2x^2+3x+4
2 3 x^2+2x+3
3 4 x+2
0 0
Output
2x+3
0
2
x+2
|
instruction
| 0
| 96,037
| 3
| 192,074
|
"Correct Solution:
```
import collections
class MyList(list):
def __init__(self, x=[]):
list.__init__(self, x)
def __iadd__(self, A):
ret = MyList()
for a, b in zip(self, A):
ret.append(a + b)
return ret
def __isub__(self, A):
ret = MyList()
for a, b in zip(self, A):
ret.append(a - b)
return ret
def __gt__(self, A):
for a, b in zip(self, A):
if a != b:
return a > b
return False
class MaxFlow:
"""Dinic Algorithm: find max-flow
complexity: O(EV^2)
used in GRL6A(AOJ)
"""
class Edge:
def __init__(self, to, cap, rev):
self.to, self.cap, self.rev = to, cap, rev
def __init__(self, V, D):
""" V: the number of vertexes
E: adjacency list
source: start point
sink: goal point
"""
self.V = V
self.E = [[] for _ in range(V)]
self.D = D
def zero(self):
return MyList([0] * self.D)
def add_edge(self, fr, to, cap):
self.E[fr].append(self.Edge(to, cap, len(self.E[to])))
self.E[to].append(self.Edge(fr, self.zero(), len(self.E[fr])-1))
def dinic(self, source, sink):
"""find max-flow"""
INF = MyList([10**9] * self.D)
maxflow = self.zero()
while True:
self.bfs(source)
if self.level[sink] < 0:
return maxflow
self.itr = MyList([0] * self.V)
while True:
flow = self.dfs(source, sink, INF)
if flow > self.zero():
maxflow += flow
else:
break
def dfs(self, vertex, sink, flow):
"""find augmenting path"""
if vertex == sink:
return flow
for i in range(self.itr[vertex], len(self.E[vertex])):
self.itr[vertex] = i
e = self.E[vertex][i]
if e.cap > self.zero() and self.level[vertex] < self.level[e.to]:
if flow > e.cap:
d = self.dfs(e.to, sink, e.cap)
else:
d = self.dfs(e.to, sink, flow)
if d > self.zero():
e.cap -= d
self.E[e.to][e.rev].cap += d
return d
return self.zero()
def bfs(self, start):
"""find shortest path from start"""
que = collections.deque()
self.level = [-1] * self.V
que.append(start)
self.level[start] = 0
while que:
fr = que.popleft()
for e in self.E[fr]:
if e.cap > self.zero() and self.level[e.to] < 0:
self.level[e.to] = self.level[fr] + 1
que.append(e.to)
def to_poly(a, l):
if l == 0:
return str(a)
elif l == 1:
return "{}x".format('' if a == 1 else a)
else:
return "{}x^{}".format('' if a == 1 else a, l)
while True:
N, M = map(int, input().split())
if N == M == 0:
break
mf = MaxFlow(N, 51)
for _ in range(M):
u, v, p = input().split()
u, v = int(u)-1, int(v)-1
poly = MyList([0] * 51)
for x in p.split('+'):
try:
num = int(x)
poly[-1] = num
except ValueError:
a, l = x.split('x')
if l:
poly[-int(l.strip("^"))-1] = int(a) if a else 1
else:
poly[-2] = int(a) if a else 1
mf.add_edge(u, v, poly)
mf.add_edge(v, u, poly)
maxflow = mf.dinic(0, N-1)
ans = '+'.join(to_poly(a, l) for a, l in zip(maxflow, reversed(range(51))) if a)
print(ans if ans else 0)
```
|
output
| 1
| 96,037
| 3
| 192,075
|
Provide a correct Python 3 solution for this coding contest problem.
The trafic on the Internet is increasing these days due to smartphones. The wireless carriers have to enhance their network infrastructure.
The network of a wireless carrier consists of a number of base stations and lines. Each line connects two base stations bi-directionally. The bandwidth of a line increases every year and is given by a polynomial f(x) of the year x.
Your task is, given the network structure, to write a program to calculate the maximal bandwidth between the 1-st and N-th base stations as a polynomial of x.
Input
The input consists of multiple datasets. Each dataset has the following format:
N M
u1 v1 p1
...
uM vM pM
The first line of each dataset contains two integers N (2 β€ N β€ 50) and M (0 β€ M β€ 500), which indicates the number of base stations and lines respectively. The following M lines describe the network structure. The i-th of them corresponds to the i-th network line and contains two integers ui and vi and a polynomial pi. ui and vi indicate the indices of base stations (1 β€ ui, vi β€ N); pi indicates the network bandwidth.
Each polynomial has the form of:
aLxL + aL-1xL-1 + ... + a2x2 + a1x + a0
where L (0 β€ L β€ 50) is the degree and ai's (0 β€ i β€ L, 0 β€ ai β€ 100) are the coefficients. In the input,
* each term aixi (for i β₯ 2) is represented as <ai>x^<i>
* the linear term (a1x) is represented as <a1>x;
* the constant (a0) is represented just by digits;
* these terms are given in the strictly decreasing order of the degrees and connected by a plus sign ("+");
* just like the standard notations, the <ai> is omitted if ai = 1 for non-constant terms;
* similarly, the entire term is omitted if ai = 0 for any terms; and
* the polynomial representations contain no space or characters other than digits, "x", "^", and "+".
For example, 2x2 + 3x + 5 is represented as 2x^2+3x+5; 2x3 + x is represented as 2x^3+x, not 2x^3+0x^2+1x+0 or the like. No polynomial is a constant zero, i.e. the one with all the coefficients being zero.
The end of input is indicated by a line with two zeros. This line is not part of any dataset.
Output
For each dataset, print the maximal bandwidth as a polynomial of x. The polynomial should be represented in the same way as the input format except that a constant zero is possible and should be represented by "0" (without quotes).
Example
Input
3 3
1 2 x+2
2 3 2x+1
3 1 x+1
2 0
3 2
1 2 x
2 3 2
4 3
1 2 x^3+2x^2+3x+4
2 3 x^2+2x+3
3 4 x+2
0 0
Output
2x+3
0
2
x+2
|
instruction
| 0
| 96,038
| 3
| 192,076
|
"Correct Solution:
```
import collections
class MyList(list):
def __init__(self, x=[]):
list.__init__(self, x)
def __iadd__(self, A):
return MyList([a + b for a, b in zip(self, A)])
def __isub__(self, A):
return MyList([a - b for a, b in zip(self, A)])
def __gt__(self, A):
for a, b in zip(self, A):
if a != b:
return a > b
return False
class MaxFlow:
"""Dinic Algorithm: find max-flow
complexity: O(EV^2)
used in GRL6A(AOJ)
"""
class Edge:
def __init__(self, to, cap, rev):
self.to, self.cap, self.rev = to, cap, rev
def __init__(self, V, D):
""" V: the number of vertexes
E: adjacency list
source: start point
sink: goal point
"""
self.V = V
self.E = [[] for _ in range(V)]
self.D = D
def zero(self):
return MyList([0] * self.D)
def add_edge(self, fr, to, cap):
self.E[fr].append(self.Edge(to, cap, len(self.E[to])))
self.E[to].append(self.Edge(fr, self.zero(), len(self.E[fr])-1))
def dinic(self, source, sink):
"""find max-flow"""
INF = MyList([10**9] * self.D)
maxflow = self.zero()
while True:
self.bfs(source)
if self.level[sink] < 0:
return maxflow
self.itr = MyList([0] * self.V)
while True:
flow = self.dfs(source, sink, INF)
if flow > self.zero():
maxflow += flow
else:
break
def dfs(self, vertex, sink, flow):
"""find augmenting path"""
if vertex == sink:
return flow
for i in range(self.itr[vertex], len(self.E[vertex])):
self.itr[vertex] = i
e = self.E[vertex][i]
if e.cap > self.zero() and self.level[vertex] < self.level[e.to]:
if flow > e.cap:
d = self.dfs(e.to, sink, e.cap)
else:
d = self.dfs(e.to, sink, flow)
if d > self.zero():
e.cap -= d
self.E[e.to][e.rev].cap += d
return d
return self.zero()
def bfs(self, start):
"""find shortest path from start"""
que = collections.deque()
self.level = [-1] * self.V
que.append(start)
self.level[start] = 0
while que:
fr = que.popleft()
for e in self.E[fr]:
if e.cap > self.zero() and self.level[e.to] < 0:
self.level[e.to] = self.level[fr] + 1
que.append(e.to)
def to_poly(a, l):
if l == 0:
return str(a)
elif l == 1:
return "{}x".format('' if a == 1 else a)
else:
return "{}x^{}".format('' if a == 1 else a, l)
while True:
N, M = map(int, input().split())
if N == M == 0:
break
mf = MaxFlow(N, 51)
for _ in range(M):
u, v, p = input().split()
u, v = int(u)-1, int(v)-1
poly = MyList([0] * 51)
for x in p.split('+'):
try:
num = int(x)
poly[-1] = num
except ValueError:
a, l = x.split('x')
if l:
poly[-int(l.strip("^"))-1] = int(a) if a else 1
else:
poly[-2] = int(a) if a else 1
mf.add_edge(u, v, poly)
mf.add_edge(v, u, poly)
maxflow = mf.dinic(0, N-1)
ans = '+'.join(to_poly(a, l) for a, l in zip(maxflow, reversed(range(51))) if a)
print(ans if ans else 0)
```
|
output
| 1
| 96,038
| 3
| 192,077
|
Provide a correct Python 3 solution for this coding contest problem.
The trafic on the Internet is increasing these days due to smartphones. The wireless carriers have to enhance their network infrastructure.
The network of a wireless carrier consists of a number of base stations and lines. Each line connects two base stations bi-directionally. The bandwidth of a line increases every year and is given by a polynomial f(x) of the year x.
Your task is, given the network structure, to write a program to calculate the maximal bandwidth between the 1-st and N-th base stations as a polynomial of x.
Input
The input consists of multiple datasets. Each dataset has the following format:
N M
u1 v1 p1
...
uM vM pM
The first line of each dataset contains two integers N (2 β€ N β€ 50) and M (0 β€ M β€ 500), which indicates the number of base stations and lines respectively. The following M lines describe the network structure. The i-th of them corresponds to the i-th network line and contains two integers ui and vi and a polynomial pi. ui and vi indicate the indices of base stations (1 β€ ui, vi β€ N); pi indicates the network bandwidth.
Each polynomial has the form of:
aLxL + aL-1xL-1 + ... + a2x2 + a1x + a0
where L (0 β€ L β€ 50) is the degree and ai's (0 β€ i β€ L, 0 β€ ai β€ 100) are the coefficients. In the input,
* each term aixi (for i β₯ 2) is represented as <ai>x^<i>
* the linear term (a1x) is represented as <a1>x;
* the constant (a0) is represented just by digits;
* these terms are given in the strictly decreasing order of the degrees and connected by a plus sign ("+");
* just like the standard notations, the <ai> is omitted if ai = 1 for non-constant terms;
* similarly, the entire term is omitted if ai = 0 for any terms; and
* the polynomial representations contain no space or characters other than digits, "x", "^", and "+".
For example, 2x2 + 3x + 5 is represented as 2x^2+3x+5; 2x3 + x is represented as 2x^3+x, not 2x^3+0x^2+1x+0 or the like. No polynomial is a constant zero, i.e. the one with all the coefficients being zero.
The end of input is indicated by a line with two zeros. This line is not part of any dataset.
Output
For each dataset, print the maximal bandwidth as a polynomial of x. The polynomial should be represented in the same way as the input format except that a constant zero is possible and should be represented by "0" (without quotes).
Example
Input
3 3
1 2 x+2
2 3 2x+1
3 1 x+1
2 0
3 2
1 2 x
2 3 2
4 3
1 2 x^3+2x^2+3x+4
2 3 x^2+2x+3
3 4 x+2
0 0
Output
2x+3
0
2
x+2
|
instruction
| 0
| 96,039
| 3
| 192,078
|
"Correct Solution:
```
import collections
def plus_list(A, B):
assert(len(A) == len(B))
return [a + b for a, b in zip(A, B)]
def minus_list(A, B):
assert(len(A) == len(B))
return [a - b for a, b in zip(A, B)]
def gt_list(A, B):
assert(len(A) == len(B))
for a, b in zip(A, B):
if a != b:
return a > b
return False
class MaxFlow:
"""Dinic Algorithm: find max-flow
complexity: O(EV^2)
used in GRL6A(AOJ)
"""
class Edge:
def __init__(self, to, cap, rev):
self.to, self.cap, self.rev = to, cap, rev
def __init__(self, V, D):
""" V: the number of vertexes
E: adjacency list
source: start point
sink: goal point
"""
self.V = V
self.E = [[] for _ in range(V)]
self.D = D
def add_edge(self, fr, to, cap):
self.E[fr].append(self.Edge(to, cap, len(self.E[to])))
self.E[to].append(self.Edge(fr, [0] * self.D, len(self.E[fr])-1))
def dinic(self, source, sink):
"""find max-flow"""
INF = [10**9] * self.D
maxflow = [0] * self.D
while True:
self.bfs(source)
if self.level[sink] < 0:
return maxflow
self.itr = [0] * self.V
while True:
flow = self.dfs(source, sink, INF)
if gt_list(flow, [0] * self.D):
maxflow = plus_list(maxflow, flow)
else:
break
def dfs(self, vertex, sink, flow):
"""find augmenting path"""
if vertex == sink:
return flow
for i in range(self.itr[vertex], len(self.E[vertex])):
self.itr[vertex] = i
e = self.E[vertex][i]
if gt_list(e.cap, [0] * self.D) and self.level[vertex] < self.level[e.to]:
if gt_list(flow, e.cap):
d = self.dfs(e.to, sink, e.cap)
else:
d = self.dfs(e.to, sink, flow)
if gt_list(d, [0] * self.D):
e.cap = minus_list(e.cap, d)
self.E[e.to][e.rev].cap = plus_list(self.E[e.to][e.rev].cap, d)
return d
return [0] * self.D
def bfs(self, start):
"""find shortest path from start"""
que = collections.deque()
self.level = [-1] * self.V
que.append(start)
self.level[start] = 0
while que:
fr = que.popleft()
for e in self.E[fr]:
if gt_list(e.cap, [0] * self.D) and self.level[e.to] < 0:
self.level[e.to] = self.level[fr] + 1
que.append(e.to)
def to_poly(a, l):
if l == 0:
return str(a)
elif l == 1:
return "{}x".format('' if a == 1 else a)
else:
return "{}x^{}".format('' if a == 1 else a, l)
while True:
N, M = map(int, input().split())
if N == M == 0:
break
mf = MaxFlow(N, 51)
for _ in range(M):
u, v, p = input().split()
u, v = int(u)-1, int(v)-1
poly = [0] * 51
for x in p.split('+'):
try:
num = int(x)
poly[-1] = num
except ValueError:
a, l = x.split('x')
if l:
poly[-int(l.strip("^"))-1] = int(a) if a else 1
else:
poly[-2] = int(a) if a else 1
mf.add_edge(u, v, poly)
mf.add_edge(v, u, poly)
maxflow = mf.dinic(0, N-1)
ans = '+'.join(to_poly(a, l) for a, l in zip(maxflow, reversed(range(51))) if a)
print(ans if ans else 0)
```
|
output
| 1
| 96,039
| 3
| 192,079
|
Provide a correct Python 3 solution for this coding contest problem.
The trafic on the Internet is increasing these days due to smartphones. The wireless carriers have to enhance their network infrastructure.
The network of a wireless carrier consists of a number of base stations and lines. Each line connects two base stations bi-directionally. The bandwidth of a line increases every year and is given by a polynomial f(x) of the year x.
Your task is, given the network structure, to write a program to calculate the maximal bandwidth between the 1-st and N-th base stations as a polynomial of x.
Input
The input consists of multiple datasets. Each dataset has the following format:
N M
u1 v1 p1
...
uM vM pM
The first line of each dataset contains two integers N (2 β€ N β€ 50) and M (0 β€ M β€ 500), which indicates the number of base stations and lines respectively. The following M lines describe the network structure. The i-th of them corresponds to the i-th network line and contains two integers ui and vi and a polynomial pi. ui and vi indicate the indices of base stations (1 β€ ui, vi β€ N); pi indicates the network bandwidth.
Each polynomial has the form of:
aLxL + aL-1xL-1 + ... + a2x2 + a1x + a0
where L (0 β€ L β€ 50) is the degree and ai's (0 β€ i β€ L, 0 β€ ai β€ 100) are the coefficients. In the input,
* each term aixi (for i β₯ 2) is represented as <ai>x^<i>
* the linear term (a1x) is represented as <a1>x;
* the constant (a0) is represented just by digits;
* these terms are given in the strictly decreasing order of the degrees and connected by a plus sign ("+");
* just like the standard notations, the <ai> is omitted if ai = 1 for non-constant terms;
* similarly, the entire term is omitted if ai = 0 for any terms; and
* the polynomial representations contain no space or characters other than digits, "x", "^", and "+".
For example, 2x2 + 3x + 5 is represented as 2x^2+3x+5; 2x3 + x is represented as 2x^3+x, not 2x^3+0x^2+1x+0 or the like. No polynomial is a constant zero, i.e. the one with all the coefficients being zero.
The end of input is indicated by a line with two zeros. This line is not part of any dataset.
Output
For each dataset, print the maximal bandwidth as a polynomial of x. The polynomial should be represented in the same way as the input format except that a constant zero is possible and should be represented by "0" (without quotes).
Example
Input
3 3
1 2 x+2
2 3 2x+1
3 1 x+1
2 0
3 2
1 2 x
2 3 2
4 3
1 2 x^3+2x^2+3x+4
2 3 x^2+2x+3
3 4 x+2
0 0
Output
2x+3
0
2
x+2
|
instruction
| 0
| 96,040
| 3
| 192,080
|
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
from string import digits
from collections import deque
class Dinic:
def __init__(self, N):
self.N = N
self.G = [[] for i in range(N)]
def add_edge(self, fr, to, cap):
forward = [to, cap, None]
forward[2] = backward = [fr, 0, forward]
self.G[fr].append(forward)
self.G[to].append(backward)
def add_multi_edge(self, v1, v2, cap1, cap2):
edge1 = [v2, cap1, None]
edge1[2] = edge2 = [v1, cap2, edge1]
self.G[v1].append(edge1)
self.G[v2].append(edge2)
def bfs(self, s, t):
self.level = level = [None]*self.N
deq = deque([s])
level[s] = 0
G = self.G
while deq:
v = deq.popleft()
lv = level[v] + 1
for w, cap, _ in G[v]:
if cap and level[w] is None:
level[w] = lv
deq.append(w)
return level[t] is not None
def dfs(self, v, t, f):
if v == t:
return f
level = self.level
for e in self.it[v]:
w, cap, rev = e
if cap and level[v] < level[w]:
d = self.dfs(w, t, min(f, cap))
if d:
e[1] -= d
rev[1] += d
return d
return 0
def flow(self, s, t):
flow = 0
INF = 10**9 + 7
G = self.G
while self.bfs(s, t):
*self.it, = map(iter, self.G)
f = INF
while f:
f = self.dfs(s, t, INF)
flow += f
return flow
def parse(S, L=50):
S = S + "$"
E = [0]*(L+1)
cur = 0
while 1:
if S[cur] in digits:
k = 0
while S[cur] in digits:
k = 10*k + int(S[cur])
cur += 1 # '0' ~ '9'
else:
k = 1
if S[cur] == 'x':
cur += 1 # 'x'
if S[cur] == '^':
cur += 1 # '^'
p = 0
while S[cur] in digits:
p = 10*p + int(S[cur])
cur += 1 # '0' ~ '9'
else:
p = 1
else:
p = 0
E[p] = k
if S[cur] != '+':
break
cur += 1 # '+'
return E
def solve():
N, M = map(int, readline().split())
if N == 0:
return False
L = 50
ds = [Dinic(N) for i in range(L+1)]
for i in range(M):
u, v, p = readline().split()
u = int(u)-1; v = int(v)-1
poly = parse(p, L)
for j in range(L+1):
if poly[j] > 0:
ds[j].add_multi_edge(u, v, poly[j], poly[j])
INF = 10**9
res = [0]*(L+1)
for j in range(L+1):
f = ds[j].flow(0, N-1)
res[j] = f
E = [[0]*N for i in range(N)]
for j in range(L-1, -1, -1):
d = ds[j]
used = [0]*N
used[N-1] = 1
que = deque([N-1])
G = ds[j+1].G
for v in range(N):
for w, cap, _ in G[v]:
if cap:
E[v][w] = 1
for v in range(N):
for w in range(N):
if E[v][w]:
d.add_edge(v, w, INF)
f = d.flow(0, N-1)
res[j] += f
ans = []
if res[0] > 0:
ans.append(str(res[0]))
if res[1] > 0:
ans.append(("%dx" % res[1]) if res[1] > 1 else "x")
for i in range(2, L+1):
if res[i] > 0:
ans.append(("%dx^%d" % (res[i], i)) if res[i] > 1 else ("x^%d" % i))
if not ans:
ans.append("0")
ans.reverse()
write("+".join(ans))
write("\n")
return True
while solve():
...
```
|
output
| 1
| 96,040
| 3
| 192,081
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bajtek is learning to skate on ice. He's a beginner, so his only mode of transportation is pushing off from a snow drift to the north, east, south or west and sliding until he lands in another snow drift. He has noticed that in this way it's impossible to get from some snow drifts to some other by any sequence of moves. He now wants to heap up some additional snow drifts, so that he can get from any snow drift to any other one. He asked you to find the minimal number of snow drifts that need to be created.
We assume that Bajtek can only heap up snow drifts at integer coordinates.
Input
The first line of input contains a single integer n (1 β€ n β€ 100) β the number of snow drifts. Each of the following n lines contains two integers xi and yi (1 β€ xi, yi β€ 1000) β the coordinates of the i-th snow drift.
Note that the north direction coinΡides with the direction of Oy axis, so the east direction coinΡides with the direction of the Ox axis. All snow drift's locations are distinct.
Output
Output the minimal number of snow drifts that need to be created in order for Bajtek to be able to reach any snow drift from any other one.
Examples
Input
2
2 1
1 2
Output
1
Input
2
2 1
4 1
Output
0
Submitted Solution:
```
def find(x):
if x == p[x]: return x
else:
p[x] = find(p[x])
return p[x]
def unite(a, b):
global count
a = find(a)
b = find(b)
if a != b:
p[a] = b;
count -= 1
n = int(input())
graph = [list(map(int, input().split())) for i in range(n)]
count = len({graph[i][0] for i in range(n)})
p = [i for i in range(1001)]
for (a, b) in graph:
for (x, y) in graph:
if b == y: unite(a, x)
print(count - 1)
```
|
instruction
| 0
| 96,410
| 3
| 192,820
|
Yes
|
output
| 1
| 96,410
| 3
| 192,821
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bajtek is learning to skate on ice. He's a beginner, so his only mode of transportation is pushing off from a snow drift to the north, east, south or west and sliding until he lands in another snow drift. He has noticed that in this way it's impossible to get from some snow drifts to some other by any sequence of moves. He now wants to heap up some additional snow drifts, so that he can get from any snow drift to any other one. He asked you to find the minimal number of snow drifts that need to be created.
We assume that Bajtek can only heap up snow drifts at integer coordinates.
Input
The first line of input contains a single integer n (1 β€ n β€ 100) β the number of snow drifts. Each of the following n lines contains two integers xi and yi (1 β€ xi, yi β€ 1000) β the coordinates of the i-th snow drift.
Note that the north direction coinΡides with the direction of Oy axis, so the east direction coinΡides with the direction of the Ox axis. All snow drift's locations are distinct.
Output
Output the minimal number of snow drifts that need to be created in order for Bajtek to be able to reach any snow drift from any other one.
Examples
Input
2
2 1
1 2
Output
1
Input
2
2 1
4 1
Output
0
Submitted Solution:
```
def main():
n = int(input())
nodes = []
connected = []
for _ in range(n):
nodes.append(list(map(int,input().split())))
for i in range(n-1):
for j in range(i+1,n):
if nodes[i][0] == nodes[j][0] or nodes[i][1] == nodes[j][1]:
set1 = -1
set2 = -1
for k in range(len(connected)):
if str(nodes[i]) in connected[k]:
set1 = k
if str(nodes[j]) in connected[k]:
set2 = k
if set1==set2 and set1>=0: continue
if set1 >= 0:
tmp = set1
set1 = connected[set1]
connected.remove(connected[tmp])
if set2 > tmp: set2 -= 1
else: set1 = {str(nodes[i])}
if set2 >= 0:
tmp = set2
set2 = connected[set2]
connected.remove(connected[tmp])
else: set2 = {str(nodes[j])}
connected.append(set1.union(set2))
else:
need_new_set_i = 1
need_new_set_j = 1
for k in range(len(connected)):
if str(nodes[i]) in connected[k]:
need_new_set_i = 0
if str(nodes[j]) in connected[k]:
need_new_set_j = 0
if need_new_set_i: connected.append({str(nodes[i])})
if need_new_set_j: connected.append({str(nodes[j])})
return len(connected) - 1 if len(connected) > 0 else 0
print(main())
```
|
instruction
| 0
| 96,411
| 3
| 192,822
|
Yes
|
output
| 1
| 96,411
| 3
| 192,823
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bajtek is learning to skate on ice. He's a beginner, so his only mode of transportation is pushing off from a snow drift to the north, east, south or west and sliding until he lands in another snow drift. He has noticed that in this way it's impossible to get from some snow drifts to some other by any sequence of moves. He now wants to heap up some additional snow drifts, so that he can get from any snow drift to any other one. He asked you to find the minimal number of snow drifts that need to be created.
We assume that Bajtek can only heap up snow drifts at integer coordinates.
Input
The first line of input contains a single integer n (1 β€ n β€ 100) β the number of snow drifts. Each of the following n lines contains two integers xi and yi (1 β€ xi, yi β€ 1000) β the coordinates of the i-th snow drift.
Note that the north direction coinΡides with the direction of Oy axis, so the east direction coinΡides with the direction of the Ox axis. All snow drift's locations are distinct.
Output
Output the minimal number of snow drifts that need to be created in order for Bajtek to be able to reach any snow drift from any other one.
Examples
Input
2
2 1
1 2
Output
1
Input
2
2 1
4 1
Output
0
Submitted Solution:
```
def arr_inp(n):
if n == 1:
return [int(x) for x in stdin.readline().split()]
elif n == 2:
return [float(x) for x in stdin.readline().split()]
else:
return [str(x) for x in stdin.readline().split()]
from sys import *
from collections import *
mem, mem2 = defaultdict(int), defaultdict(int)
for i in range(int(input())):
x, y = arr_inp(1)
mem[x] += 1
mem2[y] = 1
print(len(mem2.values()) - max(mem.values()))
```
|
instruction
| 0
| 96,412
| 3
| 192,824
|
No
|
output
| 1
| 96,412
| 3
| 192,825
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bajtek is learning to skate on ice. He's a beginner, so his only mode of transportation is pushing off from a snow drift to the north, east, south or west and sliding until he lands in another snow drift. He has noticed that in this way it's impossible to get from some snow drifts to some other by any sequence of moves. He now wants to heap up some additional snow drifts, so that he can get from any snow drift to any other one. He asked you to find the minimal number of snow drifts that need to be created.
We assume that Bajtek can only heap up snow drifts at integer coordinates.
Input
The first line of input contains a single integer n (1 β€ n β€ 100) β the number of snow drifts. Each of the following n lines contains two integers xi and yi (1 β€ xi, yi β€ 1000) β the coordinates of the i-th snow drift.
Note that the north direction coinΡides with the direction of Oy axis, so the east direction coinΡides with the direction of the Ox axis. All snow drift's locations are distinct.
Output
Output the minimal number of snow drifts that need to be created in order for Bajtek to be able to reach any snow drift from any other one.
Examples
Input
2
2 1
1 2
Output
1
Input
2
2 1
4 1
Output
0
Submitted Solution:
```
def main():
n = int(input())
nodes = []
connected = []
for _ in range(n):
nodes.append(list(map(int,input().split())))
for i in range(n-1):
for j in range(i+1,n):
if nodes[i][0] == nodes[j][0] or nodes[i][1] == nodes[j][1]:
set1 = -1
set2 = -1
for k in range(len(connected)):
if str(nodes[i]) in connected[k]:
set1 = k
if str(nodes[j]) in connected[k]:
set2 = k
if set1==set2 and set1>=0: continue
if set1 >= 0:
tmp = set1
set1 = connected[set1]
connected.remove(connected[tmp])
if set2 > tmp: set2 -= 1
else: set1 = {str(nodes[i])}
if set2 >= 0:
tmp = set2
set2 = connected[set2]
connected.remove(connected[tmp])
else: set2 = {str(nodes[j])}
connected.append(set1.union(set2))
else:
need_new_set_i = 1
need_new_set_j = 1
for k in range(len(connected)):
if str(nodes[i]) in connected[k]:
need_new_set_i = 0
if str(nodes[j]) in connected[k]:
need_new_set_j = 0
if need_new_set_i: connected.append({str(nodes[i])})
if need_new_set_j: connected.append({str(nodes[j])})
return len(connected) - 1
print(main())
```
|
instruction
| 0
| 96,414
| 3
| 192,828
|
No
|
output
| 1
| 96,414
| 3
| 192,829
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Martha β as a professional problemsetter β proposed a problem for a world-class contest. This is the problem statement:
Tomorrow is Nadia's birthday, and Bardia (her brother) is assigned to make the balloons ready!
There are n balloons (initially empty) that are tied to a straight line on certain positions x1, x2, ..., xn. Bardia inflates the balloons from left to right. As a result, i-th balloon gets bigger and bigger until its radius reaches the pressure endurance pi or it touches another previously-inflated balloon.
<image>
While Bardia was busy with the balloons, he wondered "What will be the sum of radius of balloons after all of the balloons are inflated?". Being a nerdy type of guy, he is now thinking about the problem instead of preparing his sister's birthday. Calculate the answer to Bardia's problem so that Nadia's birthday won't be balloon-less.
Artha β Martha's student β claimed his solution got accepted. Martha (being his teacher for a long time!) knew he couldn't have solved the problem for real and thus thinks there is something wrong with the testcases. Artha isn't anyhow logical, which means there is no way for Martha to explain the wrong point in his algorithm. So, the only way is to find a testcase to prove him wrong!
Artha's pseudo-code is shown below:
<image>
You should output a small testcase for the problem such that Artha's algorithm is incorrect. The algorithm's output is considered correct if it differs from the correct value by no more than 1.
Input
Please pay attention! No input will be given to your program for this problem. So you do not have to read from the input anything.
Output
You should output the generated small testcase (which Artha's solution doesn't get it right). It should be in the following format:
* First line must contain the only number n (1 β€ n β€ 500).
* The i-th of the next n lines should contain the description of the i-th balloon β two space-separated integers xi, pi (1 β€ pi β€ 106, 0 β€ x1 < x2 < ... < xn β€ 106).
Examples
Note
The testcase depicted in the figure above (just showing how output should be formatted):
4
0 9
6 3
12 7
17 1
|
instruction
| 0
| 96,416
| 3
| 192,832
|
Tags: constructive algorithms
Correct Solution:
```
n = 402
print (n)
print (0, 1000000)
for i in range(1, n-1):
print (i * 1000, n-i)
print (1000000, 1000000)
```
|
output
| 1
| 96,416
| 3
| 192,833
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Martha β as a professional problemsetter β proposed a problem for a world-class contest. This is the problem statement:
Tomorrow is Nadia's birthday, and Bardia (her brother) is assigned to make the balloons ready!
There are n balloons (initially empty) that are tied to a straight line on certain positions x1, x2, ..., xn. Bardia inflates the balloons from left to right. As a result, i-th balloon gets bigger and bigger until its radius reaches the pressure endurance pi or it touches another previously-inflated balloon.
<image>
While Bardia was busy with the balloons, he wondered "What will be the sum of radius of balloons after all of the balloons are inflated?". Being a nerdy type of guy, he is now thinking about the problem instead of preparing his sister's birthday. Calculate the answer to Bardia's problem so that Nadia's birthday won't be balloon-less.
Artha β Martha's student β claimed his solution got accepted. Martha (being his teacher for a long time!) knew he couldn't have solved the problem for real and thus thinks there is something wrong with the testcases. Artha isn't anyhow logical, which means there is no way for Martha to explain the wrong point in his algorithm. So, the only way is to find a testcase to prove him wrong!
Artha's pseudo-code is shown below:
<image>
You should output a small testcase for the problem such that Artha's algorithm is incorrect. The algorithm's output is considered correct if it differs from the correct value by no more than 1.
Input
Please pay attention! No input will be given to your program for this problem. So you do not have to read from the input anything.
Output
You should output the generated small testcase (which Artha's solution doesn't get it right). It should be in the following format:
* First line must contain the only number n (1 β€ n β€ 500).
* The i-th of the next n lines should contain the description of the i-th balloon β two space-separated integers xi, pi (1 β€ pi β€ 106, 0 β€ x1 < x2 < ... < xn β€ 106).
Examples
Note
The testcase depicted in the figure above (just showing how output should be formatted):
4
0 9
6 3
12 7
17 1
|
instruction
| 0
| 96,417
| 3
| 192,834
|
Tags: constructive algorithms
Correct Solution:
```
print(302)
print("0 1000000")
coord, rad = 17321*2, 300
for i in range(300):
print(coord, rad)
coord, rad = coord+600, rad-1
print("1000000 1000000")
```
|
output
| 1
| 96,417
| 3
| 192,835
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Martha β as a professional problemsetter β proposed a problem for a world-class contest. This is the problem statement:
Tomorrow is Nadia's birthday, and Bardia (her brother) is assigned to make the balloons ready!
There are n balloons (initially empty) that are tied to a straight line on certain positions x1, x2, ..., xn. Bardia inflates the balloons from left to right. As a result, i-th balloon gets bigger and bigger until its radius reaches the pressure endurance pi or it touches another previously-inflated balloon.
<image>
While Bardia was busy with the balloons, he wondered "What will be the sum of radius of balloons after all of the balloons are inflated?". Being a nerdy type of guy, he is now thinking about the problem instead of preparing his sister's birthday. Calculate the answer to Bardia's problem so that Nadia's birthday won't be balloon-less.
Artha β Martha's student β claimed his solution got accepted. Martha (being his teacher for a long time!) knew he couldn't have solved the problem for real and thus thinks there is something wrong with the testcases. Artha isn't anyhow logical, which means there is no way for Martha to explain the wrong point in his algorithm. So, the only way is to find a testcase to prove him wrong!
Artha's pseudo-code is shown below:
<image>
You should output a small testcase for the problem such that Artha's algorithm is incorrect. The algorithm's output is considered correct if it differs from the correct value by no more than 1.
Input
Please pay attention! No input will be given to your program for this problem. So you do not have to read from the input anything.
Output
You should output the generated small testcase (which Artha's solution doesn't get it right). It should be in the following format:
* First line must contain the only number n (1 β€ n β€ 500).
* The i-th of the next n lines should contain the description of the i-th balloon β two space-separated integers xi, pi (1 β€ pi β€ 106, 0 β€ x1 < x2 < ... < xn β€ 106).
Examples
Note
The testcase depicted in the figure above (just showing how output should be formatted):
4
0 9
6 3
12 7
17 1
Submitted Solution:
```
print(303)
print("0 1000000")
for i in range(1, 302):
print(i, i)
print("302 1000000")
```
|
instruction
| 0
| 96,418
| 3
| 192,836
|
No
|
output
| 1
| 96,418
| 3
| 192,837
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Martha β as a professional problemsetter β proposed a problem for a world-class contest. This is the problem statement:
Tomorrow is Nadia's birthday, and Bardia (her brother) is assigned to make the balloons ready!
There are n balloons (initially empty) that are tied to a straight line on certain positions x1, x2, ..., xn. Bardia inflates the balloons from left to right. As a result, i-th balloon gets bigger and bigger until its radius reaches the pressure endurance pi or it touches another previously-inflated balloon.
<image>
While Bardia was busy with the balloons, he wondered "What will be the sum of radius of balloons after all of the balloons are inflated?". Being a nerdy type of guy, he is now thinking about the problem instead of preparing his sister's birthday. Calculate the answer to Bardia's problem so that Nadia's birthday won't be balloon-less.
Artha β Martha's student β claimed his solution got accepted. Martha (being his teacher for a long time!) knew he couldn't have solved the problem for real and thus thinks there is something wrong with the testcases. Artha isn't anyhow logical, which means there is no way for Martha to explain the wrong point in his algorithm. So, the only way is to find a testcase to prove him wrong!
Artha's pseudo-code is shown below:
<image>
You should output a small testcase for the problem such that Artha's algorithm is incorrect. The algorithm's output is considered correct if it differs from the correct value by no more than 1.
Input
Please pay attention! No input will be given to your program for this problem. So you do not have to read from the input anything.
Output
You should output the generated small testcase (which Artha's solution doesn't get it right). It should be in the following format:
* First line must contain the only number n (1 β€ n β€ 500).
* The i-th of the next n lines should contain the description of the i-th balloon β two space-separated integers xi, pi (1 β€ pi β€ 106, 0 β€ x1 < x2 < ... < xn β€ 106).
Examples
Note
The testcase depicted in the figure above (just showing how output should be formatted):
4
0 9
6 3
12 7
17 1
Submitted Solution:
```
print(302)
print("0 1000000")
coord, rad = 2000, 300
for i in range(300):
print(coord, rad)
coord, rad = coord+600, rad-1
print("1000000 1000000")
```
|
instruction
| 0
| 96,419
| 3
| 192,838
|
No
|
output
| 1
| 96,419
| 3
| 192,839
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Martha β as a professional problemsetter β proposed a problem for a world-class contest. This is the problem statement:
Tomorrow is Nadia's birthday, and Bardia (her brother) is assigned to make the balloons ready!
There are n balloons (initially empty) that are tied to a straight line on certain positions x1, x2, ..., xn. Bardia inflates the balloons from left to right. As a result, i-th balloon gets bigger and bigger until its radius reaches the pressure endurance pi or it touches another previously-inflated balloon.
<image>
While Bardia was busy with the balloons, he wondered "What will be the sum of radius of balloons after all of the balloons are inflated?". Being a nerdy type of guy, he is now thinking about the problem instead of preparing his sister's birthday. Calculate the answer to Bardia's problem so that Nadia's birthday won't be balloon-less.
Artha β Martha's student β claimed his solution got accepted. Martha (being his teacher for a long time!) knew he couldn't have solved the problem for real and thus thinks there is something wrong with the testcases. Artha isn't anyhow logical, which means there is no way for Martha to explain the wrong point in his algorithm. So, the only way is to find a testcase to prove him wrong!
Artha's pseudo-code is shown below:
<image>
You should output a small testcase for the problem such that Artha's algorithm is incorrect. The algorithm's output is considered correct if it differs from the correct value by no more than 1.
Input
Please pay attention! No input will be given to your program for this problem. So you do not have to read from the input anything.
Output
You should output the generated small testcase (which Artha's solution doesn't get it right). It should be in the following format:
* First line must contain the only number n (1 β€ n β€ 500).
* The i-th of the next n lines should contain the description of the i-th balloon β two space-separated integers xi, pi (1 β€ pi β€ 106, 0 β€ x1 < x2 < ... < xn β€ 106).
Examples
Note
The testcase depicted in the figure above (just showing how output should be formatted):
4
0 9
6 3
12 7
17 1
Submitted Solution:
```
print(303)
print("0 1000000")
for i in range(1, 302):
print(i*(i+1)//2, i)
print("1000000 1000000")
```
|
instruction
| 0
| 96,420
| 3
| 192,840
|
No
|
output
| 1
| 96,420
| 3
| 192,841
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Martha β as a professional problemsetter β proposed a problem for a world-class contest. This is the problem statement:
Tomorrow is Nadia's birthday, and Bardia (her brother) is assigned to make the balloons ready!
There are n balloons (initially empty) that are tied to a straight line on certain positions x1, x2, ..., xn. Bardia inflates the balloons from left to right. As a result, i-th balloon gets bigger and bigger until its radius reaches the pressure endurance pi or it touches another previously-inflated balloon.
<image>
While Bardia was busy with the balloons, he wondered "What will be the sum of radius of balloons after all of the balloons are inflated?". Being a nerdy type of guy, he is now thinking about the problem instead of preparing his sister's birthday. Calculate the answer to Bardia's problem so that Nadia's birthday won't be balloon-less.
Artha β Martha's student β claimed his solution got accepted. Martha (being his teacher for a long time!) knew he couldn't have solved the problem for real and thus thinks there is something wrong with the testcases. Artha isn't anyhow logical, which means there is no way for Martha to explain the wrong point in his algorithm. So, the only way is to find a testcase to prove him wrong!
Artha's pseudo-code is shown below:
<image>
You should output a small testcase for the problem such that Artha's algorithm is incorrect. The algorithm's output is considered correct if it differs from the correct value by no more than 1.
Input
Please pay attention! No input will be given to your program for this problem. So you do not have to read from the input anything.
Output
You should output the generated small testcase (which Artha's solution doesn't get it right). It should be in the following format:
* First line must contain the only number n (1 β€ n β€ 500).
* The i-th of the next n lines should contain the description of the i-th balloon β two space-separated integers xi, pi (1 β€ pi β€ 106, 0 β€ x1 < x2 < ... < xn β€ 106).
Examples
Note
The testcase depicted in the figure above (just showing how output should be formatted):
4
0 9
6 3
12 7
17 1
Submitted Solution:
```
print(302)
print("0 1000000")
coord, rad = 17321, 300
for i in range(300):
print(coord, rad)
coord, rad = coord+600, rad-1
print("1000000 1000000")
```
|
instruction
| 0
| 96,421
| 3
| 192,842
|
No
|
output
| 1
| 96,421
| 3
| 192,843
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem.
Allen's future parking lot can be represented as a rectangle with 4 rows and n (n β€ 50) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having k (k β€ 2n) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.
<image> Illustration to the first example.
However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space.
Allen knows he will be a very busy man, and will only have time to move cars at most 20000 times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.
Input
The first line of the input contains two space-separated integers n and k (1 β€ n β€ 50, 1 β€ k β€ 2n), representing the number of columns and the number of cars, respectively.
The next four lines will contain n integers each between 0 and k inclusive, representing the initial state of the parking lot. The rows are numbered 1 to 4 from top to bottom and the columns are numbered 1 to n from left to right.
In the first and last line, an integer 1 β€ x β€ k represents a parking spot assigned to car x (you can only move this car to this place), while the integer 0 represents a empty space (you can't move any car to this place).
In the second and third line, an integer 1 β€ x β€ k represents initial position of car x, while the integer 0 represents an empty space (you can move any car to this place).
Each x between 1 and k appears exactly once in the second and third line, and exactly once in the first and fourth line.
Output
If there is a sequence of moves that brings all of the cars to their parking spaces, with at most 20000 car moves, then print m, the number of moves, on the first line. On the following m lines, print the moves (one move per line) in the format i r c, which corresponds to Allen moving car i to the neighboring space at row r and column c.
If it is not possible for Allen to move all the cars to the correct spaces with at most 20000 car moves, print a single line with the integer -1.
Examples
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Input
1 2
1
2
1
2
Output
-1
Input
1 2
1
1
2
2
Output
2
1 1 1
2 4 1
Note
In the first sample test case, all cars are in front of their spots except car 5, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most 20000 will be accepted.
In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.
Submitted Solution:
```
#!/usr/bin/python3
def parknext(N, P, sq, rem):
for i in range(N):
if P[0][i] == P[1][i] and P[0][i] > 0:
sq.append((P[0][i], 1, i + 1))
P[0][i] = P[1][i] = 0
rem[0] -= 1
if P[3][i] == P[2][i] and P[3][i] > 0:
sq.append((P[3][i], 4, i + 1))
P[3][i] = P[2][i] = 0
rem[0] -= 1
def rotnext(N, pos):
c, r = pos
assert r == 1 or r == 2
if r == 1 and c == N - 1:
return (N - 1, 2)
if r == 2 and c == 0:
return (0, 1)
if r == 1:
return (c + 1, r)
return (c - 1, r)
def rot(N, P, sq):
pos = None
for c in range(N):
for r in (1, 2):
if P[r][c] == 0:
pos = (c, r)
break
if pos is not None:
break
if pos is None:
return False
origpos = pos
prev = pos
cur = rotnext(N, pos)
while cur != origpos:
pc, pr = prev
cc, cr = cur
assert P[pr][pc] == 0
if P[cr][cc] > 0:
sq.append((P[cr][cc], pr + 1, pc + 1))
P[pr][pc] = P[cr][cc]
P[cr][cc] = 0
prev = cur
cur = rotnext(N, cur)
return True
def solve(N, K, P):
sq = []
rem = [K]
parknext(N, P, sq, rem)
while rem[0] > 0:
if not rot(N, P, sq):
return -1
parknext(N, P, sq, rem)
return sq
def main():
N, K = [int(e) for e in input().split(' ')]
P = []
for _ in range(4):
a = [int(e) for e in input().split(' ')]
assert len(a) == N
P.append(a)
ans = solve(N, K, P)
if ans == -1:
print("-1")
else:
for l in ans:
print(' '.join(map(str, l)))
if __name__ == '__main__':
main()
```
|
instruction
| 0
| 96,731
| 3
| 193,462
|
No
|
output
| 1
| 96,731
| 3
| 193,463
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.