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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The crowdedness of the discotheque would never stop our friends from having fun, but a bit more spaciousness won't hurt, will it?
The discotheque can be seen as an infinite xy-plane, in which there are a total of n dancers. Once someone starts moving around, they will move only inside their own movement range, which is a circular area Ci described by a center (xi, yi) and a radius ri. No two ranges' borders have more than one common point, that is for every pair (i, j) (1 ≤ i < j ≤ n) either ranges Ci and Cj are disjoint, or one of them is a subset of the other. Note that it's possible that two ranges' borders share a single common point, but no two dancers have exactly the same ranges.
Tsukihi, being one of them, defines the spaciousness to be the area covered by an odd number of movement ranges of dancers who are moving. An example is shown below, with shaded regions representing the spaciousness if everyone moves at the same time.
<image>
But no one keeps moving for the whole night after all, so the whole night's time is divided into two halves — before midnight and after midnight. Every dancer moves around in one half, while sitting down with friends in the other. The spaciousness of two halves are calculated separately and their sum should, of course, be as large as possible. The following figure shows an optimal solution to the example above.
<image>
By different plans of who dances in the first half and who does in the other, different sums of spaciousness over two halves are achieved. You are to find the largest achievable value of this sum.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 000) — the number of dancers.
The following n lines each describes a dancer: the i-th line among them contains three space-separated integers xi, yi and ri ( - 106 ≤ xi, yi ≤ 106, 1 ≤ ri ≤ 106), describing a circular movement range centered at (xi, yi) with radius ri.
Output
Output one decimal number — the largest achievable sum of spaciousness over two halves of the night.
The output is considered correct if it has a relative or absolute error of at most 10 - 9. Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
5
2 1 6
0 4 1
2 -1 3
1 -2 1
4 -1 1
Output
138.23007676
Input
8
0 0 1
0 0 2
0 0 3
0 0 4
0 0 5
0 0 6
0 0 7
0 0 8
Output
289.02652413
Note
The first sample corresponds to the illustrations in the legend.
Submitted Solution:
```
import math
z = math.pi
n = input()
a = input()
for i in range(int(n)-1):
a += '\n' + input()
a = a.split('\n')
for i in range(len(a)):
a[i] = a[i].split(' ')
a[i] = list(map(int,a[i]))
for i in range(len(a)):
for j in list(reversed(range(i+1,len(a)))): #sort the circles by their radius
if a[i][2] < a[j][2]:
a[i],a[j] = a[j],a[i]
def dis(x,y): #short for distance
return math.sqrt((x[0]-y[0])**2 + (x[1]-y[1])**2)
b = []
for i in range(len(a)):
b.append(a[i][2]**2)
for j in list(reversed(range(i))):
if dis(a[i],a[j]) < a[j][2]:
a[i].append(j)
break
c = []
for i in a:
if len(i) == 3:
c.append(1)
else:
c.append(c[i[3]]+1)
k = 0
for i in range(len(c)):
if c[i] == 1:
k += b[i]
elif c[i] % 2 == 0:
k += b[i]
else:
k -= b[i]
print(k*z)
``` | instruction | 0 | 83,897 | 3 | 167,794 |
Yes | output | 1 | 83,897 | 3 | 167,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The crowdedness of the discotheque would never stop our friends from having fun, but a bit more spaciousness won't hurt, will it?
The discotheque can be seen as an infinite xy-plane, in which there are a total of n dancers. Once someone starts moving around, they will move only inside their own movement range, which is a circular area Ci described by a center (xi, yi) and a radius ri. No two ranges' borders have more than one common point, that is for every pair (i, j) (1 ≤ i < j ≤ n) either ranges Ci and Cj are disjoint, or one of them is a subset of the other. Note that it's possible that two ranges' borders share a single common point, but no two dancers have exactly the same ranges.
Tsukihi, being one of them, defines the spaciousness to be the area covered by an odd number of movement ranges of dancers who are moving. An example is shown below, with shaded regions representing the spaciousness if everyone moves at the same time.
<image>
But no one keeps moving for the whole night after all, so the whole night's time is divided into two halves — before midnight and after midnight. Every dancer moves around in one half, while sitting down with friends in the other. The spaciousness of two halves are calculated separately and their sum should, of course, be as large as possible. The following figure shows an optimal solution to the example above.
<image>
By different plans of who dances in the first half and who does in the other, different sums of spaciousness over two halves are achieved. You are to find the largest achievable value of this sum.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 000) — the number of dancers.
The following n lines each describes a dancer: the i-th line among them contains three space-separated integers xi, yi and ri ( - 106 ≤ xi, yi ≤ 106, 1 ≤ ri ≤ 106), describing a circular movement range centered at (xi, yi) with radius ri.
Output
Output one decimal number — the largest achievable sum of spaciousness over two halves of the night.
The output is considered correct if it has a relative or absolute error of at most 10 - 9. Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
5
2 1 6
0 4 1
2 -1 3
1 -2 1
4 -1 1
Output
138.23007676
Input
8
0 0 1
0 0 2
0 0 3
0 0 4
0 0 5
0 0 6
0 0 7
0 0 8
Output
289.02652413
Note
The first sample corresponds to the illustrations in the legend.
Submitted Solution:
```
n = int(input())
d = [0] * n
p = [[] for x in d]
def f():
x, y, r = map(int, input().split())
return r * r, x, y
t = sorted(f() for y in d)
for i in range(n):
for j in range(i + 1, n):
if (t[j][2] - t[i][2]) ** 2 + (t[j][1] - t[i][1]) ** 2 < t[j][0]:
p[j].append(i)
d[i] = 1
break
g = lambda i: t[i][0] + sum(h(j, 1) for j in p[i])
h = lambda i, k: t[i][0] * k + sum(h(j, -k) for j in p[i])
print(3.1415926536 * sum(g(i) for i in range(n) if d[i]))
``` | instruction | 0 | 83,898 | 3 | 167,796 |
No | output | 1 | 83,898 | 3 | 167,797 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The crowdedness of the discotheque would never stop our friends from having fun, but a bit more spaciousness won't hurt, will it?
The discotheque can be seen as an infinite xy-plane, in which there are a total of n dancers. Once someone starts moving around, they will move only inside their own movement range, which is a circular area Ci described by a center (xi, yi) and a radius ri. No two ranges' borders have more than one common point, that is for every pair (i, j) (1 ≤ i < j ≤ n) either ranges Ci and Cj are disjoint, or one of them is a subset of the other. Note that it's possible that two ranges' borders share a single common point, but no two dancers have exactly the same ranges.
Tsukihi, being one of them, defines the spaciousness to be the area covered by an odd number of movement ranges of dancers who are moving. An example is shown below, with shaded regions representing the spaciousness if everyone moves at the same time.
<image>
But no one keeps moving for the whole night after all, so the whole night's time is divided into two halves — before midnight and after midnight. Every dancer moves around in one half, while sitting down with friends in the other. The spaciousness of two halves are calculated separately and their sum should, of course, be as large as possible. The following figure shows an optimal solution to the example above.
<image>
By different plans of who dances in the first half and who does in the other, different sums of spaciousness over two halves are achieved. You are to find the largest achievable value of this sum.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 000) — the number of dancers.
The following n lines each describes a dancer: the i-th line among them contains three space-separated integers xi, yi and ri ( - 106 ≤ xi, yi ≤ 106, 1 ≤ ri ≤ 106), describing a circular movement range centered at (xi, yi) with radius ri.
Output
Output one decimal number — the largest achievable sum of spaciousness over two halves of the night.
The output is considered correct if it has a relative or absolute error of at most 10 - 9. Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
5
2 1 6
0 4 1
2 -1 3
1 -2 1
4 -1 1
Output
138.23007676
Input
8
0 0 1
0 0 2
0 0 3
0 0 4
0 0 5
0 0 6
0 0 7
0 0 8
Output
289.02652413
Note
The first sample corresponds to the illustrations in the legend.
Submitted Solution:
```
import sys
from math import pi, sqrt
from decimal import *
from random import randint
input = sys.stdin.readline
N = int(input())
a = [tuple(map(int, input().split())) for _ in range(N)]
e = [[0] * N for _ in range(N)]
a.sort(key = lambda x: -x[2])
for i in range(N):
x, y, r = a[i]
for j in range(i + 1, N):
u, v, rr = a[j]
d = sqrt(Decimal((x - u) ** 2 + (y - v) ** 2))
if r - rr >= d:
e[i][j] = 1
e[j][i] = 1
res = Decimal(0)
pi = Decimal(pi)
c = 0
while c <= 10:
rres = Decimal(0)
midnight = set()
for i in range(N):
x = 0
y = 0
for j in range(i):
x ^= j in midnight
y ^= not (j in midnight)
if x == y == 0:
if randint(0, 1): midnight.add(i)
rres += Decimal(a[i][2] ** 2)
elif x == 0:
midnight.add(i)
rres += Decimal(a[i][2] ** 2)
elif y == 0: rres += Decimal(a[i][2] ** 2)
else:
if randint(0, 1): midnight.add(i)
rres -= Decimal(a[i][2] ** 2)
res = max(res, rres)
c += 1
print(res * pi)
``` | instruction | 0 | 83,899 | 3 | 167,798 |
No | output | 1 | 83,899 | 3 | 167,799 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The crowdedness of the discotheque would never stop our friends from having fun, but a bit more spaciousness won't hurt, will it?
The discotheque can be seen as an infinite xy-plane, in which there are a total of n dancers. Once someone starts moving around, they will move only inside their own movement range, which is a circular area Ci described by a center (xi, yi) and a radius ri. No two ranges' borders have more than one common point, that is for every pair (i, j) (1 ≤ i < j ≤ n) either ranges Ci and Cj are disjoint, or one of them is a subset of the other. Note that it's possible that two ranges' borders share a single common point, but no two dancers have exactly the same ranges.
Tsukihi, being one of them, defines the spaciousness to be the area covered by an odd number of movement ranges of dancers who are moving. An example is shown below, with shaded regions representing the spaciousness if everyone moves at the same time.
<image>
But no one keeps moving for the whole night after all, so the whole night's time is divided into two halves — before midnight and after midnight. Every dancer moves around in one half, while sitting down with friends in the other. The spaciousness of two halves are calculated separately and their sum should, of course, be as large as possible. The following figure shows an optimal solution to the example above.
<image>
By different plans of who dances in the first half and who does in the other, different sums of spaciousness over two halves are achieved. You are to find the largest achievable value of this sum.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 000) — the number of dancers.
The following n lines each describes a dancer: the i-th line among them contains three space-separated integers xi, yi and ri ( - 106 ≤ xi, yi ≤ 106, 1 ≤ ri ≤ 106), describing a circular movement range centered at (xi, yi) with radius ri.
Output
Output one decimal number — the largest achievable sum of spaciousness over two halves of the night.
The output is considered correct if it has a relative or absolute error of at most 10 - 9. Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
5
2 1 6
0 4 1
2 -1 3
1 -2 1
4 -1 1
Output
138.23007676
Input
8
0 0 1
0 0 2
0 0 3
0 0 4
0 0 5
0 0 6
0 0 7
0 0 8
Output
289.02652413
Note
The first sample corresponds to the illustrations in the legend.
Submitted Solution:
```
import sys
from math import pi, sqrt
from decimal import *
input = sys.stdin.readline
N = int(input())
a = [tuple(map(int, input().split())) for _ in range(N)]
e = [[0] * N for _ in range(N)]
a.sort(key = lambda x: -x[2])
for i in range(N):
x, y, r = a[i]
for j in range(i + 1, N):
u, v, rr = a[j]
d = sqrt(Decimal((x - u) ** 2 + (y - v) ** 2))
if r - rr >= d:
e[i][j] = 1
e[j][i] = 1
midnight = set()
res = Decimal(0)
pi = Decimal(pi)
for i in range(N):
x = 0
y = 0
for j in range(i):
x ^= j in midnight
y ^= not (j in midnight)
if x == 0:
midnight.add(i)
res += Decimal(a[i][2] ** 2)
elif y == 0: res += Decimal(a[i][2] ** 2)
else:
midnight.add(i)
res -= Decimal(a[i][2] ** 2)
print(res * pi)
``` | instruction | 0 | 83,900 | 3 | 167,800 |
No | output | 1 | 83,900 | 3 | 167,801 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The crowdedness of the discotheque would never stop our friends from having fun, but a bit more spaciousness won't hurt, will it?
The discotheque can be seen as an infinite xy-plane, in which there are a total of n dancers. Once someone starts moving around, they will move only inside their own movement range, which is a circular area Ci described by a center (xi, yi) and a radius ri. No two ranges' borders have more than one common point, that is for every pair (i, j) (1 ≤ i < j ≤ n) either ranges Ci and Cj are disjoint, or one of them is a subset of the other. Note that it's possible that two ranges' borders share a single common point, but no two dancers have exactly the same ranges.
Tsukihi, being one of them, defines the spaciousness to be the area covered by an odd number of movement ranges of dancers who are moving. An example is shown below, with shaded regions representing the spaciousness if everyone moves at the same time.
<image>
But no one keeps moving for the whole night after all, so the whole night's time is divided into two halves — before midnight and after midnight. Every dancer moves around in one half, while sitting down with friends in the other. The spaciousness of two halves are calculated separately and their sum should, of course, be as large as possible. The following figure shows an optimal solution to the example above.
<image>
By different plans of who dances in the first half and who does in the other, different sums of spaciousness over two halves are achieved. You are to find the largest achievable value of this sum.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 000) — the number of dancers.
The following n lines each describes a dancer: the i-th line among them contains three space-separated integers xi, yi and ri ( - 106 ≤ xi, yi ≤ 106, 1 ≤ ri ≤ 106), describing a circular movement range centered at (xi, yi) with radius ri.
Output
Output one decimal number — the largest achievable sum of spaciousness over two halves of the night.
The output is considered correct if it has a relative or absolute error of at most 10 - 9. Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
5
2 1 6
0 4 1
2 -1 3
1 -2 1
4 -1 1
Output
138.23007676
Input
8
0 0 1
0 0 2
0 0 3
0 0 4
0 0 5
0 0 6
0 0 7
0 0 8
Output
289.02652413
Note
The first sample corresponds to the illustrations in the legend.
Submitted Solution:
```
import sys
from math import pi, sqrt
from decimal import *
input = sys.stdin.readline
N = int(input())
a = [tuple(map(int, input().split())) for _ in range(N)]
e = [[0] * N for _ in range(N)]
a.sort(key = lambda x: -x[2])
for i in range(N):
x, y, r = a[i]
for j in range(i + 1, N):
u, v, rr = a[j]
d = sqrt((x - u) ** 2 + (y - v) ** 2)
if r - rr >= d:
e[i][j] = 1
e[j][i] = 1
midnight = set()
res = Decimal(0)
pi = Decimal(pi)
for i in range(N):
x = 0
y = 0
for j in range(i):
x ^= j in midnight
y ^= not (j in midnight)
if x == 0:
midnight.add(i)
res += Decimal(a[i][2] ** 2)
elif y == 0: res += Decimal(a[i][2] ** 2)
else:
midnight.add(i)
res -= Decimal(a[i][2] ** 2)
print(res * pi)
``` | instruction | 0 | 83,901 | 3 | 167,802 |
No | output | 1 | 83,901 | 3 | 167,803 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program you want to execute as a set of tasks organized in a dependency graph. The dependency graph is a directed acyclic graph: each task can depend on results of one or several other tasks, and there are no directed circular dependencies between tasks. A task can only be executed if all tasks it depends on have already completed.
Some of the tasks in the graph can only be executed on a coprocessor, and the rest can only be executed on the main processor. In one coprocessor call you can send it a set of tasks which can only be executed on it. For each task of the set, all tasks on which it depends must be either already completed or be included in the set. The main processor starts the program execution and gets the results of tasks executed on the coprocessor automatically.
Find the minimal number of coprocessor calls which are necessary to execute the given program.
Input
The first line contains two space-separated integers N (1 ≤ N ≤ 105) — the total number of tasks given, and M (0 ≤ M ≤ 105) — the total number of dependencies between tasks.
The next line contains N space-separated integers <image>. If Ei = 0, task i can only be executed on the main processor, otherwise it can only be executed on the coprocessor.
The next M lines describe the dependencies between tasks. Each line contains two space-separated integers T1 and T2 and means that task T1 depends on task T2 (T1 ≠ T2). Tasks are indexed from 0 to N - 1. All M pairs (T1, T2) are distinct. It is guaranteed that there are no circular dependencies between tasks.
Output
Output one line containing an integer — the minimal number of coprocessor calls necessary to execute the program.
Examples
Input
4 3
0 1 0 1
0 1
1 2
2 3
Output
2
Input
4 3
1 1 1 0
0 1
0 2
3 0
Output
1
Note
In the first test, tasks 1 and 3 can only be executed on the coprocessor. The dependency graph is linear, so the tasks must be executed in order 3 -> 2 -> 1 -> 0. You have to call coprocessor twice: first you call it for task 3, then you execute task 2 on the main processor, then you call it for for task 1, and finally you execute task 0 on the main processor.
In the second test, tasks 0, 1 and 2 can only be executed on the coprocessor. Tasks 1 and 2 have no dependencies, and task 0 depends on tasks 1 and 2, so all three tasks 0, 1 and 2 can be sent in one coprocessor call. After that task 3 is executed on the main processor.
Submitted Solution:
```
from collections import deque
import sys
input = sys.stdin.readline
def put():
return map(int, input().split())
def bfs():
main, co, ans = deque(), deque(), 0
for i in range(n):
if inedge[i]==0:
if l[i]==1: co.append(i)
else: main.append(i)
while main or co:
while main:
x = main.popleft()
for y in graph[x]:
if l[y]==1: co.append(y)
if co: ans+=1
while co:
x = co.popleft()
for y in graph[x]:
if l[y]==0: main.append(y)
return ans
n,m = put()
l = list(put())
graph = [[] for i in range(n)]
inedge= [0]*n
for _ in range(m):
x,y = put()
graph[y].append(x)
inedge[x]+=1
print(bfs())
``` | instruction | 0 | 83,912 | 3 | 167,824 |
No | output | 1 | 83,912 | 3 | 167,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program you want to execute as a set of tasks organized in a dependency graph. The dependency graph is a directed acyclic graph: each task can depend on results of one or several other tasks, and there are no directed circular dependencies between tasks. A task can only be executed if all tasks it depends on have already completed.
Some of the tasks in the graph can only be executed on a coprocessor, and the rest can only be executed on the main processor. In one coprocessor call you can send it a set of tasks which can only be executed on it. For each task of the set, all tasks on which it depends must be either already completed or be included in the set. The main processor starts the program execution and gets the results of tasks executed on the coprocessor automatically.
Find the minimal number of coprocessor calls which are necessary to execute the given program.
Input
The first line contains two space-separated integers N (1 ≤ N ≤ 105) — the total number of tasks given, and M (0 ≤ M ≤ 105) — the total number of dependencies between tasks.
The next line contains N space-separated integers <image>. If Ei = 0, task i can only be executed on the main processor, otherwise it can only be executed on the coprocessor.
The next M lines describe the dependencies between tasks. Each line contains two space-separated integers T1 and T2 and means that task T1 depends on task T2 (T1 ≠ T2). Tasks are indexed from 0 to N - 1. All M pairs (T1, T2) are distinct. It is guaranteed that there are no circular dependencies between tasks.
Output
Output one line containing an integer — the minimal number of coprocessor calls necessary to execute the program.
Examples
Input
4 3
0 1 0 1
0 1
1 2
2 3
Output
2
Input
4 3
1 1 1 0
0 1
0 2
3 0
Output
1
Note
In the first test, tasks 1 and 3 can only be executed on the coprocessor. The dependency graph is linear, so the tasks must be executed in order 3 -> 2 -> 1 -> 0. You have to call coprocessor twice: first you call it for task 3, then you execute task 2 on the main processor, then you call it for for task 1, and finally you execute task 0 on the main processor.
In the second test, tasks 0, 1 and 2 can only be executed on the coprocessor. Tasks 1 and 2 have no dependencies, and task 0 depends on tasks 1 and 2, so all three tasks 0, 1 and 2 can be sent in one coprocessor call. After that task 3 is executed on the main processor.
Submitted Solution:
```
import queue
from collections import namedtuple
thing = namedtuple('item', ['val', 'index'])
def topsort(adjList, inDeg,vals, N):
retval = 0
count =0
pq = queue.PriorityQueue()
for k in range(0,N):
if inDeg[k]==0:
pq.put(thing(vals[k], k))
while(pq.empty()!=True):
maybe = 0
count = count+1
cur = pq.get()
if pq.empty()==True and cur.val==1:
maybe = 1
flag = 0
for adj in adjList[cur.index]:
inDeg[adj]-=1
if inDeg[adj]==0:
flag = 1
pq.put(thing(vals[adj],adj))
if vals[adj] ==0:
retval +=maybe
if flag ==0:
retval +=maybe
if count == N:
return retval
else:
return 'error?', count
def main():
#if len(q)==1 and val = 1 add to count
N,M = map(int, input().split())
vals = list(map(int, input().split()))
adjList = [[] for _ in range(0,N)]
inDeg = [0 for _ in range(0,N)]
for i in range(0,M):
u,v = map(int, input().split())
adjList[u].append(v)
inDeg[v]+=1
print(topsort(adjList, inDeg,vals, N))
return 1
if __name__ == '__main__':
main()
``` | instruction | 0 | 83,913 | 3 | 167,826 |
No | output | 1 | 83,913 | 3 | 167,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program you want to execute as a set of tasks organized in a dependency graph. The dependency graph is a directed acyclic graph: each task can depend on results of one or several other tasks, and there are no directed circular dependencies between tasks. A task can only be executed if all tasks it depends on have already completed.
Some of the tasks in the graph can only be executed on a coprocessor, and the rest can only be executed on the main processor. In one coprocessor call you can send it a set of tasks which can only be executed on it. For each task of the set, all tasks on which it depends must be either already completed or be included in the set. The main processor starts the program execution and gets the results of tasks executed on the coprocessor automatically.
Find the minimal number of coprocessor calls which are necessary to execute the given program.
Input
The first line contains two space-separated integers N (1 ≤ N ≤ 105) — the total number of tasks given, and M (0 ≤ M ≤ 105) — the total number of dependencies between tasks.
The next line contains N space-separated integers <image>. If Ei = 0, task i can only be executed on the main processor, otherwise it can only be executed on the coprocessor.
The next M lines describe the dependencies between tasks. Each line contains two space-separated integers T1 and T2 and means that task T1 depends on task T2 (T1 ≠ T2). Tasks are indexed from 0 to N - 1. All M pairs (T1, T2) are distinct. It is guaranteed that there are no circular dependencies between tasks.
Output
Output one line containing an integer — the minimal number of coprocessor calls necessary to execute the program.
Examples
Input
4 3
0 1 0 1
0 1
1 2
2 3
Output
2
Input
4 3
1 1 1 0
0 1
0 2
3 0
Output
1
Note
In the first test, tasks 1 and 3 can only be executed on the coprocessor. The dependency graph is linear, so the tasks must be executed in order 3 -> 2 -> 1 -> 0. You have to call coprocessor twice: first you call it for task 3, then you execute task 2 on the main processor, then you call it for for task 1, and finally you execute task 0 on the main processor.
In the second test, tasks 0, 1 and 2 can only be executed on the coprocessor. Tasks 1 and 2 have no dependencies, and task 0 depends on tasks 1 and 2, so all three tasks 0, 1 and 2 can be sent in one coprocessor call. After that task 3 is executed on the main processor.
Submitted Solution:
```
import queue
from collections import namedtuple
thing = namedtuple('item', ['val', 'index'])
def topsort(adjList, inDeg,vals, N):
retval = 1
count =0
pq = queue.PriorityQueue()
for k in range(0,N):
if inDeg[k]==0:
pq.put(thing(vals[k], k))
while(pq.empty()!=True):
maybe = 0
count = count+1
cur = pq.get()
if pq.empty()==True and cur.val==1:
maybe = 1
for adj in adjList[cur.index]:
inDeg[adj]-=1
if inDeg[adj]==0:
pq.put(thing(vals[adj],adj))
if vals[adj] ==0:
retval +=maybe
if count == N:
return retval
else:
return 'error?', count
def main():
#if len(q)==1 and val = 1 add to count
N,M = map(int, input().split())
vals = list(map(int, input().split()))
adjList = [[] for _ in range(0,N)]
inDeg = [0 for _ in range(0,N)]
for i in range(0,M):
u,v = map(int, input().split())
adjList[u].append(v)
inDeg[v]+=1
print(topsort(adjList, inDeg,vals, N))
return 1
if __name__ == '__main__':
main()
``` | instruction | 0 | 83,914 | 3 | 167,828 |
No | output | 1 | 83,914 | 3 | 167,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a program you want to execute as a set of tasks organized in a dependency graph. The dependency graph is a directed acyclic graph: each task can depend on results of one or several other tasks, and there are no directed circular dependencies between tasks. A task can only be executed if all tasks it depends on have already completed.
Some of the tasks in the graph can only be executed on a coprocessor, and the rest can only be executed on the main processor. In one coprocessor call you can send it a set of tasks which can only be executed on it. For each task of the set, all tasks on which it depends must be either already completed or be included in the set. The main processor starts the program execution and gets the results of tasks executed on the coprocessor automatically.
Find the minimal number of coprocessor calls which are necessary to execute the given program.
Input
The first line contains two space-separated integers N (1 ≤ N ≤ 105) — the total number of tasks given, and M (0 ≤ M ≤ 105) — the total number of dependencies between tasks.
The next line contains N space-separated integers <image>. If Ei = 0, task i can only be executed on the main processor, otherwise it can only be executed on the coprocessor.
The next M lines describe the dependencies between tasks. Each line contains two space-separated integers T1 and T2 and means that task T1 depends on task T2 (T1 ≠ T2). Tasks are indexed from 0 to N - 1. All M pairs (T1, T2) are distinct. It is guaranteed that there are no circular dependencies between tasks.
Output
Output one line containing an integer — the minimal number of coprocessor calls necessary to execute the program.
Examples
Input
4 3
0 1 0 1
0 1
1 2
2 3
Output
2
Input
4 3
1 1 1 0
0 1
0 2
3 0
Output
1
Note
In the first test, tasks 1 and 3 can only be executed on the coprocessor. The dependency graph is linear, so the tasks must be executed in order 3 -> 2 -> 1 -> 0. You have to call coprocessor twice: first you call it for task 3, then you execute task 2 on the main processor, then you call it for for task 1, and finally you execute task 0 on the main processor.
In the second test, tasks 0, 1 and 2 can only be executed on the coprocessor. Tasks 1 and 2 have no dependencies, and task 0 depends on tasks 1 and 2, so all three tasks 0, 1 and 2 can be sent in one coprocessor call. After that task 3 is executed on the main processor.
Submitted Solution:
```
from collections import deque
import sys
input = sys.stdin.readline
def put():
return map(int, input().split())
def bfs():
main, co, ans = deque(), deque(), 0
for i in range(n):
if inedge[i]==0:
if l[i]==1: co.append(i)
else: main.append(i)
vis[i]=1
while main or co:
while main:
x = main.popleft()
for y in graph[x]:
if vis[y]==0:
if l[y]==1: co.append(y)
else: main.append(y)
vis[y]=1
if co: ans+=1
while co:
x = co.popleft()
for y in graph[x]:
if vis[y]==0:
if l[y]==1: co.append(y)
else: main.append(y)
vis[y]=1
return ans
n,m = put()
l = list(put())
graph = [[] for i in range(n)]
inedge, vis= [0]*n, [0]*n
for _ in range(m):
x,y = put()
graph[y].append(x)
inedge[x]+=1
print(bfs())
``` | instruction | 0 | 83,915 | 3 | 167,830 |
No | output | 1 | 83,915 | 3 | 167,831 |
Provide a correct Python 3 solution for this coding contest problem.
She catched the thrown coin that draws parabolic curve with her sparkling fingers. She is an ESPer. Yes, she is an electro-master who has the third strongest power among more than one million ESPers in the city. Being flicked by her thumb, the coin is accelerated by electromagnetic force and is shot as Fleming's right-hand rule. Even if she holds back the initial velocity of the coin exceeds three times of the speed of sound. The coin that is shot in such velocity is heated because of air friction and adiabatic compression. As a result coin melts and shines in orange. This is her special ability, called railgun. The strength of railgun can make a hole of two meters in diameter on a concrete wall.
She had defeated criminals such as post office robberies and bank robberies in the city with her ability. And today, she decided to destroy a laboratory that is suspected to making some inhumane experiments on human body. Only her railgun can shoot it.
The railgun with a coin cannot destroy the laboratory because of lack of power. Since she have found a powered-suit nearby, so she decided to use it as a projectile. However, in this case it is difficult to take sight properly because the suit is much bigger and heavier than coins. Therefore she only can shoot the suit with certain velocity vector from her current position. Depending on the position of the laboratory, her railgun may not hit it and become a firework.
Therefore she asked cooperation to the strongest ESPer in the city. He can change direction of a moving object as one of uncountable application of his ESP. Let's consider a 2-dimensional plane where the laboratory is on the origin (0, 0). She shoots a projectile from P = (px, py) with velocity vector V = (vx, vy). His ESP makes a virtual wall of radius R (= 1.0) centered on the origin. When projectile collides with the wall, it is reflected so that incident angle will be equal to reflection angle.
Range of railgun is limited to D, because air friction decreases velocity of projectile and heat may melts projectile completely. Under these conditions, please write a program that judges if the railgun hits the laboratory. Size of the laboratory and the suit is ignorablly small. After the railgun is shot, it is allowed to pass through P again.
Constraints
* Judge data never include dataset where the answer is (D - 1.0e-3) or bigger.
* 0.0001 ≤ |V| ≤ 0.9999
* 0.0001 ≤ |P| ≤ 0.9999
* D ≤ 50
Input
Input consists of several datasets.
The first line of each dataset contains a real number D.
Next line contains 4 real numbers, which means px, py, vx, vy, respectively.
Input terminates when D = 0.
Output
For each dataset, if the railgun hits, output the distance it moved until hits. Otherwise output 'impossible' (without quotes).
You can print any number of digits and answer with an error less than 1.0e-6 will be accepted.
Example
Input
10.0
0.5 0.0 -0.2 0.0
1.0
0.1 0.0 0.2 0.2
0
Output
0.50000000
impossible | instruction | 0 | 84,147 | 3 | 168,294 |
"Correct Solution:
```
from sys import stdin
def solve():
file_input = stdin
while True:
D = float(file_input.readline())
if D == 0:
break
px, py, vx, vy = map(float, file_input.readline().split())
if px * vy - py * vx == 0:
OP = (px ** 2 + py ** 2) ** 0.5
if px * vx + py * vy < 0:
if OP <= D:
print(OP)
else:
print('impossible')
else:
d = 2 - OP
if d <= D:
print(d)
else:
print('impossible')
else:
print('impossible')
solve()
``` | output | 1 | 84,147 | 3 | 168,295 |
Provide a correct Python 3 solution for this coding contest problem.
She catched the thrown coin that draws parabolic curve with her sparkling fingers. She is an ESPer. Yes, she is an electro-master who has the third strongest power among more than one million ESPers in the city. Being flicked by her thumb, the coin is accelerated by electromagnetic force and is shot as Fleming's right-hand rule. Even if she holds back the initial velocity of the coin exceeds three times of the speed of sound. The coin that is shot in such velocity is heated because of air friction and adiabatic compression. As a result coin melts and shines in orange. This is her special ability, called railgun. The strength of railgun can make a hole of two meters in diameter on a concrete wall.
She had defeated criminals such as post office robberies and bank robberies in the city with her ability. And today, she decided to destroy a laboratory that is suspected to making some inhumane experiments on human body. Only her railgun can shoot it.
The railgun with a coin cannot destroy the laboratory because of lack of power. Since she have found a powered-suit nearby, so she decided to use it as a projectile. However, in this case it is difficult to take sight properly because the suit is much bigger and heavier than coins. Therefore she only can shoot the suit with certain velocity vector from her current position. Depending on the position of the laboratory, her railgun may not hit it and become a firework.
Therefore she asked cooperation to the strongest ESPer in the city. He can change direction of a moving object as one of uncountable application of his ESP. Let's consider a 2-dimensional plane where the laboratory is on the origin (0, 0). She shoots a projectile from P = (px, py) with velocity vector V = (vx, vy). His ESP makes a virtual wall of radius R (= 1.0) centered on the origin. When projectile collides with the wall, it is reflected so that incident angle will be equal to reflection angle.
Range of railgun is limited to D, because air friction decreases velocity of projectile and heat may melts projectile completely. Under these conditions, please write a program that judges if the railgun hits the laboratory. Size of the laboratory and the suit is ignorablly small. After the railgun is shot, it is allowed to pass through P again.
Constraints
* Judge data never include dataset where the answer is (D - 1.0e-3) or bigger.
* 0.0001 ≤ |V| ≤ 0.9999
* 0.0001 ≤ |P| ≤ 0.9999
* D ≤ 50
Input
Input consists of several datasets.
The first line of each dataset contains a real number D.
Next line contains 4 real numbers, which means px, py, vx, vy, respectively.
Input terminates when D = 0.
Output
For each dataset, if the railgun hits, output the distance it moved until hits. Otherwise output 'impossible' (without quotes).
You can print any number of digits and answer with an error less than 1.0e-6 will be accepted.
Example
Input
10.0
0.5 0.0 -0.2 0.0
1.0
0.1 0.0 0.2 0.2
0
Output
0.50000000
impossible | instruction | 0 | 84,148 | 3 | 168,296 |
"Correct Solution:
```
# AOJ 1053: Accelerated Railgun
# Python3 2018.7.7 bal4u
EPS = 1e-7
while True:
d = float(input())
if d == 0: break
px, py, vx, vy = map(float, input().split())
ans = d+1
dp = (px*px + py*py)**0.5
dv = (vx*vx + vy*vy)**0.5
x = (px*vx + py*vy)/(dp*dv)
if abs(x+1) <= EPS: ans = dp
elif abs(1-x) <= EPS: ans = 2-dp
print(ans if abs(ans-d) <= EPS or ans <= d else "impossible")
``` | output | 1 | 84,148 | 3 | 168,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
She catched the thrown coin that draws parabolic curve with her sparkling fingers. She is an ESPer. Yes, she is an electro-master who has the third strongest power among more than one million ESPers in the city. Being flicked by her thumb, the coin is accelerated by electromagnetic force and is shot as Fleming's right-hand rule. Even if she holds back the initial velocity of the coin exceeds three times of the speed of sound. The coin that is shot in such velocity is heated because of air friction and adiabatic compression. As a result coin melts and shines in orange. This is her special ability, called railgun. The strength of railgun can make a hole of two meters in diameter on a concrete wall.
She had defeated criminals such as post office robberies and bank robberies in the city with her ability. And today, she decided to destroy a laboratory that is suspected to making some inhumane experiments on human body. Only her railgun can shoot it.
The railgun with a coin cannot destroy the laboratory because of lack of power. Since she have found a powered-suit nearby, so she decided to use it as a projectile. However, in this case it is difficult to take sight properly because the suit is much bigger and heavier than coins. Therefore she only can shoot the suit with certain velocity vector from her current position. Depending on the position of the laboratory, her railgun may not hit it and become a firework.
Therefore she asked cooperation to the strongest ESPer in the city. He can change direction of a moving object as one of uncountable application of his ESP. Let's consider a 2-dimensional plane where the laboratory is on the origin (0, 0). She shoots a projectile from P = (px, py) with velocity vector V = (vx, vy). His ESP makes a virtual wall of radius R (= 1.0) centered on the origin. When projectile collides with the wall, it is reflected so that incident angle will be equal to reflection angle.
Range of railgun is limited to D, because air friction decreases velocity of projectile and heat may melts projectile completely. Under these conditions, please write a program that judges if the railgun hits the laboratory. Size of the laboratory and the suit is ignorablly small. After the railgun is shot, it is allowed to pass through P again.
Constraints
* Judge data never include dataset where the answer is (D - 1.0e-3) or bigger.
* 0.0001 ≤ |V| ≤ 0.9999
* 0.0001 ≤ |P| ≤ 0.9999
* D ≤ 50
Input
Input consists of several datasets.
The first line of each dataset contains a real number D.
Next line contains 4 real numbers, which means px, py, vx, vy, respectively.
Input terminates when D = 0.
Output
For each dataset, if the railgun hits, output the distance it moved until hits. Otherwise output 'impossible' (without quotes).
You can print any number of digits and answer with an error less than 1.0e-6 will be accepted.
Example
Input
10.0
0.5 0.0 -0.2 0.0
1.0
0.1 0.0 0.2 0.2
0
Output
0.50000000
impossible
Submitted Solution:
```
from sys import stdin
def solve():
file_input = stdin
while True:
D = float(file_input.readline())
if D == 0:
break
px, py, vx, vy = map(float, file_input.readline().split())
if px * vy - py * vx == 0:
OP = (px ** 2 + py ** 2) ** 0.5
if px * vx + py * vy < 0:
if OP <= D:
print(OP)
else:
d = 2 - OP
if d <= D:
print(d)
else:
print('impossible')
else:
print('impossible')
solve()
``` | instruction | 0 | 84,149 | 3 | 168,298 |
No | output | 1 | 84,149 | 3 | 168,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
She catched the thrown coin that draws parabolic curve with her sparkling fingers. She is an ESPer. Yes, she is an electro-master who has the third strongest power among more than one million ESPers in the city. Being flicked by her thumb, the coin is accelerated by electromagnetic force and is shot as Fleming's right-hand rule. Even if she holds back the initial velocity of the coin exceeds three times of the speed of sound. The coin that is shot in such velocity is heated because of air friction and adiabatic compression. As a result coin melts and shines in orange. This is her special ability, called railgun. The strength of railgun can make a hole of two meters in diameter on a concrete wall.
She had defeated criminals such as post office robberies and bank robberies in the city with her ability. And today, she decided to destroy a laboratory that is suspected to making some inhumane experiments on human body. Only her railgun can shoot it.
The railgun with a coin cannot destroy the laboratory because of lack of power. Since she have found a powered-suit nearby, so she decided to use it as a projectile. However, in this case it is difficult to take sight properly because the suit is much bigger and heavier than coins. Therefore she only can shoot the suit with certain velocity vector from her current position. Depending on the position of the laboratory, her railgun may not hit it and become a firework.
Therefore she asked cooperation to the strongest ESPer in the city. He can change direction of a moving object as one of uncountable application of his ESP. Let's consider a 2-dimensional plane where the laboratory is on the origin (0, 0). She shoots a projectile from P = (px, py) with velocity vector V = (vx, vy). His ESP makes a virtual wall of radius R (= 1.0) centered on the origin. When projectile collides with the wall, it is reflected so that incident angle will be equal to reflection angle.
Range of railgun is limited to D, because air friction decreases velocity of projectile and heat may melts projectile completely. Under these conditions, please write a program that judges if the railgun hits the laboratory. Size of the laboratory and the suit is ignorablly small. After the railgun is shot, it is allowed to pass through P again.
Constraints
* Judge data never include dataset where the answer is (D - 1.0e-3) or bigger.
* 0.0001 ≤ |V| ≤ 0.9999
* 0.0001 ≤ |P| ≤ 0.9999
* D ≤ 50
Input
Input consists of several datasets.
The first line of each dataset contains a real number D.
Next line contains 4 real numbers, which means px, py, vx, vy, respectively.
Input terminates when D = 0.
Output
For each dataset, if the railgun hits, output the distance it moved until hits. Otherwise output 'impossible' (without quotes).
You can print any number of digits and answer with an error less than 1.0e-6 will be accepted.
Example
Input
10.0
0.5 0.0 -0.2 0.0
1.0
0.1 0.0 0.2 0.2
0
Output
0.50000000
impossible
Submitted Solution:
```
from sys import stdin
def solve():
file_input = stdin
while True:
D = float(file_input.readline())
if D == 0:
break
px, py, vx, vy = map(float, file_input.readline().split())
p_norm = (px ** 2 + py ** 2) ** 0.5
v_norm = (vx ** 2 + vy ** 2) ** 0.5
if px * vx + py * vy == (-1) * p_norm * v_norm:
if p_norm <= D:
print(p_norm)
else:
print('impossible')
else:
ratio = 1 / v_norm
wx = px + ratio * vx
wy = py + ratio * vy
d = (wx ** 2 + wy ** 2) ** 0.5
d += 1
if d <= D:
print(d)
else:
print('impossible')
solve()
``` | instruction | 0 | 84,150 | 3 | 168,300 |
No | output | 1 | 84,150 | 3 | 168,301 |
Provide a correct Python 3 solution for this coding contest problem.
A straight tunnel without branches is crowded with busy ants coming and going. Some ants walk left to right and others right to left. All ants walk at a constant speed of 1 cm/s. When two ants meet, they try to pass each other. However, some sections of the tunnel are narrow and two ants cannot pass each other. When two ants meet at a narrow section, they turn around and start walking in the opposite directions. When an ant reaches either end of the tunnel, it leaves the tunnel.
The tunnel has an integer length in centimeters. Every narrow section of the tunnel is integer centimeters distant from the both ends. Except for these sections, the tunnel is wide enough for ants to pass each other. All ants start walking at distinct narrow sections. No ants will newly enter the tunnel. Consequently, all the ants in the tunnel will eventually leave it. Your task is to write a program that tells which is the last ant to leave the tunnel and when it will.
Figure B.1 shows the movements of the ants during the first two seconds in a tunnel 6 centimeters long. Initially, three ants, numbered 1, 2, and 3, start walking at narrow sections, 1, 2, and 5 centimeters distant from the left end, respectively. After 0.5 seconds, the ants 1 and 2 meet at a wide section, and they pass each other. Two seconds after the start, the ants 1 and 3 meet at a narrow section, and they turn around.
Figure B.1 corresponds to the first dataset of the sample input.
<image>
Figure B.1. Movements of ants
Input
The input consists of one or more datasets. Each dataset is formatted as follows.
n l
d1 p1
d2 p2
...
dn pn
The first line of a dataset contains two integers separated by a space. n (1 ≤ n ≤ 20) represents the number of ants, and l (n + 1 ≤ l ≤ 100) represents the length of the tunnel in centimeters. The following n lines describe the initial states of ants. Each of the lines has two items, di and pi, separated by a space. Ants are given numbers 1 through n. The ant numbered i has the initial direction di and the initial position pi. The initial direction di (1 ≤ i ≤ n) is L (to the left) or R (to the right). The initial position pi (1 ≤ i ≤ n) is an integer specifying the distance from the left end of the tunnel in centimeters. Ants are listed in the left to right order, that is, 1 ≤ p1 < p2 < ... < pn ≤ l - 1.
The last dataset is followed by a line containing two zeros separated by a space.
Output
For each dataset, output how many seconds it will take before all the ants leave the tunnel, and which of the ants will be the last. The last ant is identified by its number. If two ants will leave at the same time, output the number indicating the ant that will leave through the left end of the tunnel.
Example
Input
3 6
R 1
L 2
L 5
1 10
R 1
2 10
R 5
L 7
2 10
R 3
L 8
2 99
R 1
L 98
4 10
L 1
R 2
L 8
R 9
6 10
R 2
R 3
L 4
R 6
L 7
L 8
0 0
Output
5 1
9 1
7 1
8 2
98 2
8 2
8 3 | instruction | 0 | 84,156 | 3 | 168,312 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
LR = "LR".index
def solve(A, L):
K = len(A)
if K == 0:
return -1, -1, -1
T = []
v = -1; last = None
left = 0
for i in range(K):
di, pi, ki = A[i]
for j in range(i+1, K):
dj, pj, kj = A[j]
if di > dj:
T.append(((pj - pi)//2, i, j))
if di == 0:
if v <= pi:
v = pi
last = i
left = 1
else:
if v < L - pi:
v = L - pi
last = i
left = 0
T.sort()
for _, i, j in T:
A[i], A[j] = A[j], A[i]
return v, A[last][2], left
ans = []
while 1:
N, L = map(int, readline().split())
if N == 0:
break
A = []; B = []
for i in range(N):
d, p = readline().split(); d = LR(d); p = int(p)
if p % 2:
A.append((d, p, i+1))
else:
B.append((d, p, i+1))
v0, i0, l0 = solve(A, L)
v1, i1, l1 = solve(B, L)
if v0 > v1:
ans.append("%d %d\n" % (v0, i0))
elif v0 < v1:
ans.append("%d %d\n" % (v1, i1))
else:
if l0:
ans.append("%d %d\n" % (v0, i0))
else:
ans.append("%d %d\n" % (v1, i1))
sys.stdout.writelines(ans)
``` | output | 1 | 84,156 | 3 | 168,313 |
Provide a correct Python 3 solution for this coding contest problem.
A straight tunnel without branches is crowded with busy ants coming and going. Some ants walk left to right and others right to left. All ants walk at a constant speed of 1 cm/s. When two ants meet, they try to pass each other. However, some sections of the tunnel are narrow and two ants cannot pass each other. When two ants meet at a narrow section, they turn around and start walking in the opposite directions. When an ant reaches either end of the tunnel, it leaves the tunnel.
The tunnel has an integer length in centimeters. Every narrow section of the tunnel is integer centimeters distant from the both ends. Except for these sections, the tunnel is wide enough for ants to pass each other. All ants start walking at distinct narrow sections. No ants will newly enter the tunnel. Consequently, all the ants in the tunnel will eventually leave it. Your task is to write a program that tells which is the last ant to leave the tunnel and when it will.
Figure B.1 shows the movements of the ants during the first two seconds in a tunnel 6 centimeters long. Initially, three ants, numbered 1, 2, and 3, start walking at narrow sections, 1, 2, and 5 centimeters distant from the left end, respectively. After 0.5 seconds, the ants 1 and 2 meet at a wide section, and they pass each other. Two seconds after the start, the ants 1 and 3 meet at a narrow section, and they turn around.
Figure B.1 corresponds to the first dataset of the sample input.
<image>
Figure B.1. Movements of ants
Input
The input consists of one or more datasets. Each dataset is formatted as follows.
n l
d1 p1
d2 p2
...
dn pn
The first line of a dataset contains two integers separated by a space. n (1 ≤ n ≤ 20) represents the number of ants, and l (n + 1 ≤ l ≤ 100) represents the length of the tunnel in centimeters. The following n lines describe the initial states of ants. Each of the lines has two items, di and pi, separated by a space. Ants are given numbers 1 through n. The ant numbered i has the initial direction di and the initial position pi. The initial direction di (1 ≤ i ≤ n) is L (to the left) or R (to the right). The initial position pi (1 ≤ i ≤ n) is an integer specifying the distance from the left end of the tunnel in centimeters. Ants are listed in the left to right order, that is, 1 ≤ p1 < p2 < ... < pn ≤ l - 1.
The last dataset is followed by a line containing two zeros separated by a space.
Output
For each dataset, output how many seconds it will take before all the ants leave the tunnel, and which of the ants will be the last. The last ant is identified by its number. If two ants will leave at the same time, output the number indicating the ant that will leave through the left end of the tunnel.
Example
Input
3 6
R 1
L 2
L 5
1 10
R 1
2 10
R 5
L 7
2 10
R 3
L 8
2 99
R 1
L 98
4 10
L 1
R 2
L 8
R 9
6 10
R 2
R 3
L 4
R 6
L 7
L 8
0 0
Output
5 1
9 1
7 1
8 2
98 2
8 2
8 3 | instruction | 0 | 84,157 | 3 | 168,314 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
while True:
n,l = LI()
if n == 0:
break
a = []
b = []
for _ in range(n):
d,p = LS()
if int(p) % 2 == 0:
a.append((d,int(p),_+1))
else:
b.append((d,int(p),_+1))
lc = 0
rm = 0
rf = False
for d,p,i in a:
if d == 'L':
lc += 1
m = int(p)
if d == 'R':
m = l - m
if rm < m or (rm == m and d == 'L'):
rm = m
rf = d == 'R'
ri = lc
if rf:
ri = lc + 1
ari = -1
if a:
ari = a[ri-1][2]
lc = 0
rf = False
af = True
for d,p,i in b:
if d == 'L':
lc += 1
m = int(p)
if d == 'R':
m = l - m
if rm < m or (rm == m and d == 'L'):
rm = m
rf = d == 'R'
af = False
ri = lc
if rf:
ri = lc + 1
bri = -1
if b:
bri = b[ri-1][2]
if af:
rr.append('{} {}'.format(rm, ari))
else:
rr.append('{} {}'.format(rm, bri))
return '\n'.join(map(str, rr))
print(main())
``` | output | 1 | 84,157 | 3 | 168,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two. | instruction | 0 | 84,460 | 3 | 168,920 |
Tags: brute force, data structures, dp
Correct Solution:
```
from copy import deepcopy
MOD = int(10**9 + 7)
for _ in range(int(input())):
n, k = map(int, input().split())
if k == 1:
print(1)
continue
elif n == 1:
print(2)
continue
ans = n+1
dire = -1
arrows = [1] * (n-1)
k -= 1
while k > 1:
new_arrows = [0] * (n-1)
if dire == -1:
new_arrows[n-2] = arrows[n-2]
for i in range(n-3, -1, -1):
new_arrows[i] = new_arrows[i+1] + arrows[i]
else:
new_arrows[0] = arrows[0]
for i in range(1, n-1):
new_arrows[i] = new_arrows[i-1] + arrows[i]
ans += sum(new_arrows)
ans %= MOD
dire *= -1
arrows = [x % MOD for x in new_arrows]
k -= 1
# print(new_arrows)
# print(ans)
print(ans)
``` | output | 1 | 84,460 | 3 | 168,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two. | instruction | 0 | 84,461 | 3 | 168,922 |
Tags: brute force, data structures, dp
Correct Solution:
```
for _ in range(int(input())):
n,k=map(int,input().split())
MOD=1000000007
dp=[[0 for x in range(1010)] for y in range(1010)]
for l in range(k+1):
for m in range(n+1):
if l==1:
dp[l][m]=1
elif m==0:
dp[l][m]=1
else:
dp[l][m]=(dp[l][m-1]+dp[l-1][n-m])%MOD
print(dp[k][n])
``` | output | 1 | 84,461 | 3 | 168,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two. | instruction | 0 | 84,462 | 3 | 168,924 |
Tags: brute force, data structures, dp
Correct Solution:
```
t = int(input())
#mat = [[0 for _ in range(1001)] for _ in range(1001)]
#
#for i in range(1, 1001):
# mat[i][0] = 1
#
#pref_ls = [0 for _ in range(1001)]
#
#for i in range(1, 1001):
# new_pref_ls = [1]
# for j in range(1, 1001):
# mat[i][j] = (1 + pref_ls[j-1]) % (10**9+7)
# new_pref_ls.append(new_pref_ls[-1]+mat[i][j])
## break
# pref_ls = new_pref_ls
for test in range(1, t + 1):
n,k = list(map(int, input().split()))
if k == 1:
print(1)
elif n == 1:
print(2)
else:
res = 2
ls = [1 for _ in range(n-1)]
for i in range(k-1):
new_ls = []
curr_sum = 0
for j in range(n-1):
res = (res + ls[j]) % (10**9+7)
curr_sum += ls[j] % (10**9+7)
new_ls.append(curr_sum)
ls = new_ls[::-1]
print(res)
``` | output | 1 | 84,462 | 3 | 168,925 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two. | instruction | 0 | 84,463 | 3 | 168,926 |
Tags: brute force, data structures, dp
Correct Solution:
```
#!/usr/bin/env python3
# created : 2021
from sys import stdin
MOD = int(1e9+7)
def solve(tc):
n, k = map(int, stdin.readline().split())
if n == 1:
if k == 1:
print(1)
else:
print(2)
return
mem = [0 for i in range(k+1)]
planes = [1 for i in range(n)]
mem[1] = 1
for i in range(2, k+1):
mem[i] = mem[i-1]
for j in range(n):
mem[i] += planes[j]
mem[i] %= MOD
if i & 1:
cum = planes[0]
planes[0] = 0
for j in range(1, n):
tmp = planes[j]
planes[j] = cum
cum += tmp
cum %= MOD
else:
cum = planes[n-1]
planes[n-1] = 0
for j in range(n-2, -1, -1):
tmp = planes[j]
planes[j] = cum
cum += tmp
cum %= MOD
print(mem[k])
tcs = 1
tcs = int(stdin.readline().strip())
tc = 1
while tc <= tcs:
solve(tc)
tc += 1
``` | output | 1 | 84,463 | 3 | 168,927 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two. | instruction | 0 | 84,464 | 3 | 168,928 |
Tags: brute force, data structures, dp
Correct Solution:
```
# SHRi GANESHA author: Kunal Verma #
import os
import sys
from bisect import bisect_right
from collections import Counter, deque, defaultdict
from io import BytesIO, IOBase
from math import gcd, inf, sqrt, ceil, radians, cos, sin
def lcm(a, b):
return (a * b) // gcd(a, b)
'''
mod = 10 ** 9 + 7
fac = [1]
for i in range(1, 2 * 10 ** 5 + 1):
fac.append((fac[-1] * i) % mod)
fac_in = [pow(fac[-1], mod - 2, mod)]
for i in range(2 * 10 ** 5, 0, -1):
fac_in.append((fac_in[-1] * i) % mod)
fac_in.reverse()
def comb(a, b):
if a < b:
return 0
return (fac[a] * fac_in[b] * fac_in[a - b]) % mod
'''
#MAXN = 10000004
# spf = [0 for i in range(MAXN)]
# adj = [[] for i in range(MAXN)]
def sieve():
global spf, adj, MAXN
spf[1] = 1
for i in range(2, MAXN):
spf[i] = i
for i in range(2, MAXN):
if i * i > MAXN:
break
if (spf[i] == i):
for j in range(i * i, MAXN, i):
if (spf[j] == j):
spf[j] = i
def getdistinctFactorization(n):
global adj, spf, MAXN
for i in range(1, n + 1):
index = 1
x = i
if (x != 1):
adj[i].append(spf[x])
x = x // spf[x]
while (x != 1):
if (adj[i][index - 1] != spf[x]):
adj[i].append(spf[x])
index += 1
x = x // spf[x]
def printDivisors(n):
i = 2
z = [1, n]
while i <= sqrt(n):
if (n % i == 0):
if (n / i == i):
z.append(i)
else:
z.append(i)
z.append(n // i)
i = i + 1
return z
def create(n, x, f):
pq = len(bin(n)[2:])
if f == 0:
tt = min
else:
tt = max
dp = [[inf] * n for _ in range(pq)]
dp[0] = x
for i in range(1, pq):
for j in range(n - (1 << i) + 1):
dp[i][j] = tt(dp[i - 1][j], dp[i - 1][j + (1 << (i - 1))])
return dp
def enquiry(l, r, dp, f):
if l > r:
return inf if not f else -inf
if f == 1:
tt = max
else:
tt = min
pq1 = len(bin(r - l + 1)[2:]) - 1
return tt(dp[pq1][l], dp[pq1][r - (1 << pq1) + 1])
def SieveOfEratosthenes(n):
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n + 1, p):
prime[i] = False
p += 1
x = []
for i in range(2, n + 1):
if prime[i]:
x.append(i)
return x
def dfs(i,vis,adj):
c=[]
st=[]
st.append(i)
while (st):
xx=st.pop()
if not vis[xx]:
vis[xx]=1
c.append(xx)
for i in adj[xx]:
st.append(i)
return vis,c
def main():
for _ in range(int(input())):
n,k=map(int,input().split())
mod=10**9+7
y=[1]*n
x=[0]*n
s=0
p=1
for i in range(k-1):
if p:
for j in range(len(y)):
s=(s+y[j])%mod
an=y[n-1]%mod
for j in range(n-2,-1,-1):
x[j]=an
an=(an+y[j])%mod
y=[0]*n
p^=1
else:
for j in range(len(x)):
s=(s+x[j])%mod
an = x[0]%mod
for j in range(1,n):
y[j] = an
an = (an+x[j])%mod
x=[0]*n
p^=1
print(s+1)
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
``` | output | 1 | 84,464 | 3 | 168,929 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two. | instruction | 0 | 84,465 | 3 | 168,930 |
Tags: brute force, data structures, dp
Correct Solution:
```
from __future__ import division, print_function
import math
import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input().strip()
return(list(s[:len(s)]))
def invr():
return(map(int,input().split()))
mx=10**9+7
dp=[[0 for i in range(1005)]for j in range(1005)]
for i in range(1005):
dp[1][i]=1
for i in range(1005):
dp[i][0]=1
for _ in range(inp()):
n,k=invr()
for i in range(2,k+2):
for j in range(1,n+2):
dp[i][j]=(dp[i-1][n-j]+dp[i][j-1])%mx
print(dp[k][n])
``` | output | 1 | 84,465 | 3 | 168,931 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two. | instruction | 0 | 84,466 | 3 | 168,932 |
Tags: brute force, data structures, dp
Correct Solution:
```
mod=10**9+7
cas=int(input())
while cas:
cas-=1;
n,k=map(int,input().split())
dp=[1 for i in range(n)];
ans=1
for i in range(k-1):
tmp=0
for j in range(n):
ans=(ans+dp[j])%mod
if(i%2==0):
for j in range(n-1,-1,-1):
## print(tmp)
tt=dp[j]
dp[j]=tmp
tmp=(tmp+tt)%mod
else:
for j in range(n):
tt=dp[j]
dp[j]=tmp
tmp=(tmp+tt)%mod
## print(dp[0])
print(ans)
``` | output | 1 | 84,466 | 3 | 168,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two. | instruction | 0 | 84,467 | 3 | 168,934 |
Tags: brute force, data structures, dp
Correct Solution:
```
import sys
input = sys.stdin.readline
mod=10**9+7
t=int(input())
for tests in range(t):
n,k=map(int,input().split())
if k==1:
print(1)
continue
if n==1:
print(2)
continue
ANS=1
DP=[1]*n
for i in range(k-1):
NDP=[0]*n
if i%2==0:
S=0
for j in range(n):
S+=DP[j]
S%=mod
if j!=n-1:
NDP[j+1]=S
ANS+=S
else:
S=0
for j in range(n-1,-1,-1):
S+=DP[j]
S%=mod
if j!=0:
NDP[j-1]=S
ANS+=S
DP=NDP
print(ANS%mod)
``` | output | 1 | 84,467 | 3 | 168,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two.
Submitted Solution:
```
for u in range(int(input())):
n, k = map(int, input().split())
x = [1]*(n)
ans = 1
mod = 10**9 + 7
if(k == 1):
print(1)
elif(n == 1):
print(2)
else:
k -= 2
ans += n
x = [1]*(n-1)
while(k > 0):
s = 0
if(k%2 == 0):
x[0] = x[0]%mod
s += (x[0])%mod
for i in range(1, n-1):
x[i] = (x[i] + x[i-1])%mod
s += (x[i])%mod
else:
x[n-2] = x[n-2]%mod
s += (x[n-2])%mod
for i in range(n-3, -1, -1):
x[i] = (x[i] + x[i+1])%mod
s += (x[i])%mod
ans += s%mod
k -= 1
print(ans%mod)
``` | instruction | 0 | 84,468 | 3 | 168,936 |
Yes | output | 1 | 84,468 | 3 | 168,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two.
Submitted Solution:
```
MOD = 10**9 + 7
t = int(input())
for test in range(t):
n, k = [int(i) for i in input().split()]
if k==1:
print(1)
elif k==2:
print(n+1)
elif n==1:
print(2)
else:
ans = n+1
v = [1 for i in range(n-1)]
for my_iter in range(k-2):
v_new = [0 for i in range(n-1)]
v_new[-1] = v[0]
for it in range(1,n-1):
v_new[-it-1] = (v_new[-it]+ v[it]) % MOD
#print(v_new)
ans+= sum(v_new) % MOD
v = v_new
print(ans % MOD)
``` | instruction | 0 | 84,469 | 3 | 168,938 |
Yes | output | 1 | 84,469 | 3 | 168,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two.
Submitted Solution:
```
for _ in range(int(input())):
n,k=(map(int,input().split()))
dp=[]
for i in range(0,1013):
dp.append([0]*1013)
ans=1
for i in range(1,k+1):
for j in range(0,n+1):
if(j==0 or i==1):
dp[i][j]=1
else:
dp[i][j] = (dp[i - 1][n - j] + dp[i][j - 1]) % (1000000007)
print(dp[k][n])
``` | instruction | 0 | 84,470 | 3 | 168,940 |
Yes | output | 1 | 84,470 | 3 | 168,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two.
Submitted Solution:
```
import sys
input=sys.stdin.readline
def I():return input().strip()
def II():return int(input().strip())
def LI():return [*map(int,input().strip().split())]
import string,math,time,functools,random,fractions
from heapq import heappush,heappop,heapify
from bisect import bisect_left,bisect_right
from collections import deque,defaultdict,Counter,OrderedDict
from itertools import permutations,combinations,groupby
MOD=10**9+7
for _ in range(II()):
n,k=LI()
if k==1:
print(1)
continue
if n==1:
print(2)
continue
n-=1
arr=[0]*(k-1)
ans=n+2
for i in range(k-1):
if i==0:
arr[i]=[1]*n
continue
arr[i]=[0]*n
for i in range(1,k-1):
if i%2==0:
s=0
for j in range(n):
s=(s+arr[i-1][j])%MOD
arr[i][j]=s
ans=(ans+s)%MOD
else:
s=0
for j in range(n-1,-1,-1):
s=(s+arr[i-1][j])%MOD
arr[i][j]=s
ans=(ans+s)%MOD
print(ans%MOD)
``` | instruction | 0 | 84,471 | 3 | 168,942 |
Yes | output | 1 | 84,471 | 3 | 168,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two.
Submitted Solution:
```
import sys
input=sys.stdin.readline
mod=10**9+7
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
dp_right=[1 for i in range(n+2)]
dp_left=[0 for i in range(n+2)]
dp_right[0]=0
ans=1
while(k>2):
for i in range(n,0,-1):
dp_left[i]+=(dp_left[i+1]+dp_right[i+1])%mod
ans+=dp_right[i]%mod
dp_right[i]=0
k-=1
if(k<=1):
break
for i in range(1,n+1):
dp_right[i]+=(dp_right[i-1]+dp_left[i-1])%mod
ans+=dp_left[i]%mod
dp_left[i]=0
k-=1
print(ans%mod)
``` | instruction | 0 | 84,472 | 3 | 168,944 |
No | output | 1 | 84,472 | 3 | 168,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two.
Submitted Solution:
```
# Author: Javier Bórquez
import os
import sys
sys.setrecursionlimit(1000 * 100)
class Memoize:
def __init__(self, f):
self.f = f
self.memo = {}
def __call__(self, *args):
if not args in self.memo:
self.memo[args] = self.f(*args)
return self.memo[args]
def main():
fastReadInt = sys.stdin.buffer.readline
def fastReadStr(): return sys.stdin.buffer.readline().decode('utf-8').strip()
def fastWrite(ans): return sys.stdout.buffer.write(str(str(ans) + "\n").encode('utf-8'))
def fastWriteList(ans): return sys.stdout.buffer.write(str(" ".join(map(str, ans)) + "\n").encode('utf-8'))
DEBUG = 'DEBUG' in os.environ
def debug(*args):
if DEBUG:
print(">", *args)
@Memoize
def recursive(wall, totalWall, power):
# debug(wall, power)
# debug(">power", power, ">wall", wall)
# this is the end
if wall == totalWall:
return 1
# no more power
if power == 1:
return 1
res = 0
for ii in range(0, min(totalWall - wall, power)):
res += recursive(max(totalWall - ii, ii), totalWall, power - 1)
return res + 1
def solution(wallsPower):
walls = wallsPower[0]
power = wallsPower[1]
res = recursive(0, walls, min(power, walls + 1))
debug(walls, power, "=", res)
return res % (10 ** 9 + 8)
# N lines, then N int
for t in range(int(fastReadInt())):
fastWrite(solution(list(map(int, fastReadInt().split()))))
# # N lines, then N string
# for t in range(int(fastReadInt())):
# solution(fastReadStr())
# # N lines, then N lunes of String separated by space
# for t in range(int(fastReadInt())):
# solution(fastReadStr().split())
main()
``` | instruction | 0 | 84,473 | 3 | 168,946 |
No | output | 1 | 84,473 | 3 | 168,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two.
Submitted Solution:
```
def fog():
s = list(map(int, input().split()))
n = s[0]
k = s[1]
lst = []
sm = 0
for i in range(n-1):
lst.append(1)
if k == 1:
print(1)
elif n == 1:
print(2)
elif k == 2:
print(n+1)
elif n == 2:
print(k+1)
else:
for i in range(k-2):
lst1 = [sum(lst)]
for i in range(n-2):
lst1.append((lst1[i] - (lst[-i-1])) % (10**9+7))
sm += sum(lst1) % (10**9+7)
sm = sm % (10**9+7)
lst = lst1
print(sm+1)
t = int(input())
while t > 0:
t -= 1
fog()
``` | instruction | 0 | 84,474 | 3 | 168,948 |
No | output | 1 | 84,474 | 3 | 168,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two.
Submitted Solution:
```
mod=10**9 + 7
def add(a,b):return ((a%mod) + (b%mod))%mod
def answer(n,k):
dp=[[0 for i in range(n)] for j in range(k)]
for i in range(n):dp[0][i]=1
ans=1
for i in range(k):
for j in range(1,n):
dp[i][j]=add(dp[i-1][-j],dp[i][j-1])
ans=add(ans,dp[i][-1])
return ans
for T in range(int(input())):
n,k=map(int,input().split())
print(answer(n,k))
``` | instruction | 0 | 84,475 | 3 | 168,950 |
No | output | 1 | 84,475 | 3 | 168,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem has nothing to do with Little Chris. It is about hill climbers instead (and Chris definitely isn't one).
There are n hills arranged on a line, each in the form of a vertical line segment with one endpoint on the ground. The hills are numbered with numbers from 1 to n from left to right. The i-th hill stands at position xi with its top at height yi. For every two hills a and b, if the top of hill a can be seen from the top of hill b, their tops are connected by a rope. Formally, the tops of two hills are connected if the segment connecting their top points does not intersect or touch any of the other hill segments. Using these ropes, the hill climbers can move from hill to hill.
There are m teams of climbers, each composed of exactly two members. The first and the second climbers of the i-th team are located at the top of the ai-th and bi-th hills, respectively. They want to meet together at the top of some hill. Now, each of two climbers move according to the following process:
1. if a climber is at the top of the hill where the other climber is already located or will come eventually, the former climber stays at this hill;
2. otherwise, the climber picks a hill to the right of his current hill that is reachable by a rope and is the rightmost possible, climbs this hill and continues the process (the climber can also climb a hill whose top is lower than the top of his current hill).
<image>
For each team of climbers, determine the number of the meeting hill for this pair!
Input
The first line of input contains a single integer n (1 ≤ n ≤ 105), the number of hills. The next n lines describe the hills. The i-th of them contains two space-separated integers xi, yi (1 ≤ xi ≤ 107; 1 ≤ yi ≤ 1011), the position and the height of the i-th hill. The hills are given in the ascending order of xi, i.e., xi < xj for i < j.
The next line of input contains a single integer m (1 ≤ m ≤ 105), the number of teams. The next m lines describe the teams. The i-th of them contains two space-separated integers ai, bi (1 ≤ ai, bi ≤ n), the numbers of the hills where the climbers of the i-th team are located. It is possible that ai = bi.
Output
In a single line output m space-separated integers, where the i-th integer is the number of the meeting hill for the members of the i-th team.
Examples
Input
6
1 4
2 1
3 2
4 3
6 4
7 4
3
3 1
5 6
2 3
Output
5 6 3
Submitted Solution:
```
def traverse(hills, start):
if len(hills[start:]) <= 2: return hills[start:]
path = [hills[start], hills[start+1]]
for i in range(start + 2, len(hills)):
while len(path) >=2 and hills[i][1] > path[-1][1] < path[-2][1]:
path.pop()
path.append(hills[i])
return path
def lca(pathA, pathB):
N = min(len(pathA), len(pathB))
for i in range(1, N+1):
if pathA[-i] != pathB[-i]:
l = i - 1
break
else:
l = N
return l - 1
def CF406D():
# Hills
N = int(input())
hills = [tuple(map(int, input().split())) for _ in range(N)]
# teams
M = int(input())
teams = [tuple(map(int, input().split())) for _ in range(M)]
paths = {} # (id, stack)
lcas = []
for a, b in teams:
if a > b:
a, b = b, a
paths[a] = paths.get(a, traverse(hills, a-1))
paths[b] = paths.get(b, traverse(hills, b-1))
pathA = paths[a]
pathB = paths[b]
# print(a, pathA)
# print(b, pathB)
# print()
lcas.append(N - lca(pathA, pathB))
return lcas
if __name__ == '__main__':
res = CF406D()
for i in res:
print(i, end = ' ')
print()
``` | instruction | 0 | 84,551 | 3 | 169,102 |
No | output | 1 | 84,551 | 3 | 169,103 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem has nothing to do with Little Chris. It is about hill climbers instead (and Chris definitely isn't one).
There are n hills arranged on a line, each in the form of a vertical line segment with one endpoint on the ground. The hills are numbered with numbers from 1 to n from left to right. The i-th hill stands at position xi with its top at height yi. For every two hills a and b, if the top of hill a can be seen from the top of hill b, their tops are connected by a rope. Formally, the tops of two hills are connected if the segment connecting their top points does not intersect or touch any of the other hill segments. Using these ropes, the hill climbers can move from hill to hill.
There are m teams of climbers, each composed of exactly two members. The first and the second climbers of the i-th team are located at the top of the ai-th and bi-th hills, respectively. They want to meet together at the top of some hill. Now, each of two climbers move according to the following process:
1. if a climber is at the top of the hill where the other climber is already located or will come eventually, the former climber stays at this hill;
2. otherwise, the climber picks a hill to the right of his current hill that is reachable by a rope and is the rightmost possible, climbs this hill and continues the process (the climber can also climb a hill whose top is lower than the top of his current hill).
<image>
For each team of climbers, determine the number of the meeting hill for this pair!
Input
The first line of input contains a single integer n (1 ≤ n ≤ 105), the number of hills. The next n lines describe the hills. The i-th of them contains two space-separated integers xi, yi (1 ≤ xi ≤ 107; 1 ≤ yi ≤ 1011), the position and the height of the i-th hill. The hills are given in the ascending order of xi, i.e., xi < xj for i < j.
The next line of input contains a single integer m (1 ≤ m ≤ 105), the number of teams. The next m lines describe the teams. The i-th of them contains two space-separated integers ai, bi (1 ≤ ai, bi ≤ n), the numbers of the hills where the climbers of the i-th team are located. It is possible that ai = bi.
Output
In a single line output m space-separated integers, where the i-th integer is the number of the meeting hill for the members of the i-th team.
Examples
Input
6
1 4
2 1
3 2
4 3
6 4
7 4
3
3 1
5 6
2 3
Output
5 6 3
Submitted Solution:
```
def cross(x0, y0, x1, y1):
return x0*y1 - y0*x1
def main():
n = int(input())
x, y = [ 0 for _ in range(n+1) ], [ 0 for _ in range(n+1) ]
for i in range(1,n+1):
x[i], y[i] = list(map(int, input().split()))
m = int(input())
results = []
for i in range(m):
a, b = list(map(int, input().split()))
if b < a:
tmp = a
a = b
b = tmp
a_best, b_best = a, b
while a < b:
ref = a + 1
if ref == n:
a = ref
break
for j in range(ref+1,n):
ax = cross(x[ref]-x[a],y[ref]-y[a],x[j]-x[a],y[j]-y[a])
if ax > 0:
ref = j
a = ref
while b < a:
ref = b+1
if ref == n:
b = ref
break
for j in range(ref+1,n):
bx = cross(x[ref]-x[b],y[ref]-y[b],x[j]-x[b],y[j]-y[b])
if bx > 0:
ref = j
b = ref
results.append(b)
for i in range(len(results)):
print(results[i])
if __name__ == '__main__':
main()
``` | instruction | 0 | 84,552 | 3 | 169,104 |
No | output | 1 | 84,552 | 3 | 169,105 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem has nothing to do with Little Chris. It is about hill climbers instead (and Chris definitely isn't one).
There are n hills arranged on a line, each in the form of a vertical line segment with one endpoint on the ground. The hills are numbered with numbers from 1 to n from left to right. The i-th hill stands at position xi with its top at height yi. For every two hills a and b, if the top of hill a can be seen from the top of hill b, their tops are connected by a rope. Formally, the tops of two hills are connected if the segment connecting their top points does not intersect or touch any of the other hill segments. Using these ropes, the hill climbers can move from hill to hill.
There are m teams of climbers, each composed of exactly two members. The first and the second climbers of the i-th team are located at the top of the ai-th and bi-th hills, respectively. They want to meet together at the top of some hill. Now, each of two climbers move according to the following process:
1. if a climber is at the top of the hill where the other climber is already located or will come eventually, the former climber stays at this hill;
2. otherwise, the climber picks a hill to the right of his current hill that is reachable by a rope and is the rightmost possible, climbs this hill and continues the process (the climber can also climb a hill whose top is lower than the top of his current hill).
<image>
For each team of climbers, determine the number of the meeting hill for this pair!
Input
The first line of input contains a single integer n (1 ≤ n ≤ 105), the number of hills. The next n lines describe the hills. The i-th of them contains two space-separated integers xi, yi (1 ≤ xi ≤ 107; 1 ≤ yi ≤ 1011), the position and the height of the i-th hill. The hills are given in the ascending order of xi, i.e., xi < xj for i < j.
The next line of input contains a single integer m (1 ≤ m ≤ 105), the number of teams. The next m lines describe the teams. The i-th of them contains two space-separated integers ai, bi (1 ≤ ai, bi ≤ n), the numbers of the hills where the climbers of the i-th team are located. It is possible that ai = bi.
Output
In a single line output m space-separated integers, where the i-th integer is the number of the meeting hill for the members of the i-th team.
Examples
Input
6
1 4
2 1
3 2
4 3
6 4
7 4
3
3 1
5 6
2 3
Output
5 6 3
Submitted Solution:
```
def traverse(hills, start):
if len(hills[start:]) <= 2: return hills[start:]
path = [hills[start], hills[start+1]]
for i in range(start + 2, len(hills)):
while len(path) >=2 and hills[i][1] > path[-1][1] < path[-2][1]:
path.pop()
path.append(hills[i])
return path
def lca(pathA, pathB):
N = min(len(pathA), len(pathB))
l = pathA[len(pathA)-N]
for i in range(1, N+1):
if pathA[-i] == pathB[-i]:
l = pathA[-i]
else:
break
return l
def CF406D():
# Hills
N = int(input())
hills = [tuple(map(int, input().split())) for _ in range(N)]
indices = dict(zip(hills, list(range(1, N+1))))
# teams
M = int(input())
teams = [tuple(map(int, input().split())) for _ in range(M)]
paths = {} # (id, stack)
lcas = []
for a, b in teams:
if a > b:
a, b = b, a
paths[a] = paths.get(a, traverse(hills, a-1))
paths[b] = paths.get(b, traverse(hills, b-1))
pathA = paths[a]
pathB = paths[b]
l = lca(pathA, pathB)
# print(l)
l = indices[l]
# print(a, pathA)
# print(b, pathB)
# print()
lcas.append(l)
return lcas
if __name__ == '__main__':
res = CF406D()
for i in res:
print(i, end = ' ')
print()
``` | instruction | 0 | 84,553 | 3 | 169,106 |
No | output | 1 | 84,553 | 3 | 169,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem has nothing to do with Little Chris. It is about hill climbers instead (and Chris definitely isn't one).
There are n hills arranged on a line, each in the form of a vertical line segment with one endpoint on the ground. The hills are numbered with numbers from 1 to n from left to right. The i-th hill stands at position xi with its top at height yi. For every two hills a and b, if the top of hill a can be seen from the top of hill b, their tops are connected by a rope. Formally, the tops of two hills are connected if the segment connecting their top points does not intersect or touch any of the other hill segments. Using these ropes, the hill climbers can move from hill to hill.
There are m teams of climbers, each composed of exactly two members. The first and the second climbers of the i-th team are located at the top of the ai-th and bi-th hills, respectively. They want to meet together at the top of some hill. Now, each of two climbers move according to the following process:
1. if a climber is at the top of the hill where the other climber is already located or will come eventually, the former climber stays at this hill;
2. otherwise, the climber picks a hill to the right of his current hill that is reachable by a rope and is the rightmost possible, climbs this hill and continues the process (the climber can also climb a hill whose top is lower than the top of his current hill).
<image>
For each team of climbers, determine the number of the meeting hill for this pair!
Input
The first line of input contains a single integer n (1 ≤ n ≤ 105), the number of hills. The next n lines describe the hills. The i-th of them contains two space-separated integers xi, yi (1 ≤ xi ≤ 107; 1 ≤ yi ≤ 1011), the position and the height of the i-th hill. The hills are given in the ascending order of xi, i.e., xi < xj for i < j.
The next line of input contains a single integer m (1 ≤ m ≤ 105), the number of teams. The next m lines describe the teams. The i-th of them contains two space-separated integers ai, bi (1 ≤ ai, bi ≤ n), the numbers of the hills where the climbers of the i-th team are located. It is possible that ai = bi.
Output
In a single line output m space-separated integers, where the i-th integer is the number of the meeting hill for the members of the i-th team.
Examples
Input
6
1 4
2 1
3 2
4 3
6 4
7 4
3
3 1
5 6
2 3
Output
5 6 3
Submitted Solution:
```
ans = []
INF = 10000000000000000000000000000000000
n = int(input())
x, y = [0 for i in range(n)], [0 for i in range(n)]
for i in range(n):
x[i], y[i] = list(map(int, input().split()))
m = int(input())
def sm(x1, y1, x2, y2):
if x1 == x2:
return (1 if y2 > y1 else -1) * INF
else:
return (y2 - y1) / (x2 - x1)
for i in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
while a != b:
a, b = sorted([a, b])
#print('+++', a, b)
mx = a + 1
for k in range(a + 2, n):
s1 = sm(x[a], y[a], x[mx], y[mx])
s2 = sm(x[a], y[a], x[k], y[k])
#print('** ', s1, s2)
if s1 >= s2:
break
else:
mx = k
a = mx
#print('---', a, b)
ans.append(a + 1)
for i in range(m - 1):
print(ans[i], end=' ')
print(ans[m - 1], end='')
"""
6
1 4
2 1
3 2
4 3
6 4
7 4
3
3 1
5 6
2 3
4 5
"""
``` | instruction | 0 | 84,554 | 3 | 169,108 |
No | output | 1 | 84,554 | 3 | 169,109 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Optimizing the amount of data transmitted via a network is an important and interesting part of developing any network application.
<image>
In one secret game developed deep in the ZeptoLab company, the game universe consists of n levels, located in a circle. You can get from level i to levels i - 1 and i + 1, also you can get from level 1 to level n and vice versa. The map of the i-th level description size is ai bytes.
In order to reduce the transmitted traffic, the game gets levels as follows. All the levels on the server are divided into m groups and each time a player finds himself on one of the levels of a certain group for the first time, the server sends all levels of the group to the game client as a single packet. Thus, when a player travels inside the levels of a single group, the application doesn't need any new information. Due to the technical limitations the packet can contain an arbitrary number of levels but their total size mustn't exceed b bytes, where b is some positive integer constant.
Usual situation is that players finish levels one by one, that's why a decision was made to split n levels into m groups so that each group was a continuous segment containing multiple neighboring levels (also, the group can have two adjacent levels, n and 1). Specifically, if the descriptions of all levels have the total weight of at most b bytes, then they can all be united into one group to be sent in a single packet.
Determine, what minimum number of groups do you need to make in order to organize the levels of the game observing the conditions above?
As developing a game is a long process and technology never stagnates, it is yet impossible to predict exactly what value will take constant value b limiting the packet size when the game is out. That's why the developers ask you to find the answer for multiple values of b.
Input
The first line contains two integers n, q (2 ≤ n ≤ 106, 1 ≤ q ≤ 50) — the number of levels in the game universe and the number of distinct values of b that you need to process.
The second line contains n integers ai (1 ≤ ai ≤ 109) — the sizes of the levels in bytes.
The next q lines contain integers bj (<image>), determining the values of constant b, for which you need to determine the answer.
Output
For each value of kj from the input print on a single line integer mj (1 ≤ mj ≤ n), determining the minimum number of groups to divide game levels into for transmission via network observing the given conditions.
Examples
Input
6 3
2 4 2 1 3 2
7
4
6
Output
2
4
3
Note
In the test from the statement you can do in the following manner.
* at b = 7 you can divide into two segments: 2|421|32 (note that one of the segments contains the fifth, sixth and first levels);
* at b = 4 you can divide into four segments: 2|4|21|3|2;
* at b = 6 you can divide into three segments: 24|21|32|.
Submitted Solution:
```
import sys
n, q = [int(n) for n in sys.stdin.readline().split()]
a = [int(n) for n in sys.stdin.readline().split()]
b = []
for _ in range(q):
b.append(int(sys.stdin.readline()))
# n, q = [int(n) for n in "6 3".split()]
# # a = [int(n) for n in "2 4 2 1 3 2".split()]
# a = [int(n) for n in "2 4 2 1 3 2".split()]
# b = [7, 4, 6]
maxi = a.index(max(a))
archive = a[maxi:] + a[:maxi]
lena = min([len(a), 13])
for curb in b:
a = archive
curgroups = -1
for _ in range(lena):
groups = 1
sum = 0
for cura in a:
sum += cura
if sum > curb:
sum = cura
groups += 1
if curgroups == -1 or groups < curgroups:
curgroups = groups
a.insert(0, a.pop())
print(curgroups)
``` | instruction | 0 | 84,575 | 3 | 169,150 |
No | output | 1 | 84,575 | 3 | 169,151 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Optimizing the amount of data transmitted via a network is an important and interesting part of developing any network application.
<image>
In one secret game developed deep in the ZeptoLab company, the game universe consists of n levels, located in a circle. You can get from level i to levels i - 1 and i + 1, also you can get from level 1 to level n and vice versa. The map of the i-th level description size is ai bytes.
In order to reduce the transmitted traffic, the game gets levels as follows. All the levels on the server are divided into m groups and each time a player finds himself on one of the levels of a certain group for the first time, the server sends all levels of the group to the game client as a single packet. Thus, when a player travels inside the levels of a single group, the application doesn't need any new information. Due to the technical limitations the packet can contain an arbitrary number of levels but their total size mustn't exceed b bytes, where b is some positive integer constant.
Usual situation is that players finish levels one by one, that's why a decision was made to split n levels into m groups so that each group was a continuous segment containing multiple neighboring levels (also, the group can have two adjacent levels, n and 1). Specifically, if the descriptions of all levels have the total weight of at most b bytes, then they can all be united into one group to be sent in a single packet.
Determine, what minimum number of groups do you need to make in order to organize the levels of the game observing the conditions above?
As developing a game is a long process and technology never stagnates, it is yet impossible to predict exactly what value will take constant value b limiting the packet size when the game is out. That's why the developers ask you to find the answer for multiple values of b.
Input
The first line contains two integers n, q (2 ≤ n ≤ 106, 1 ≤ q ≤ 50) — the number of levels in the game universe and the number of distinct values of b that you need to process.
The second line contains n integers ai (1 ≤ ai ≤ 109) — the sizes of the levels in bytes.
The next q lines contain integers bj (<image>), determining the values of constant b, for which you need to determine the answer.
Output
For each value of kj from the input print on a single line integer mj (1 ≤ mj ≤ n), determining the minimum number of groups to divide game levels into for transmission via network observing the given conditions.
Examples
Input
6 3
2 4 2 1 3 2
7
4
6
Output
2
4
3
Note
In the test from the statement you can do in the following manner.
* at b = 7 you can divide into two segments: 2|421|32 (note that one of the segments contains the fifth, sixth and first levels);
* at b = 4 you can divide into four segments: 2|4|21|3|2;
* at b = 6 you can divide into three segments: 24|21|32|.
Submitted Solution:
```
import sys
n, q = [int(n) for n in sys.stdin.readline().split()]
a = [int(n) for n in sys.stdin.readline().split()]
b = []
for _ in range(q):
b.append(int(sys.stdin.readline()))
# n, q = [int(n) for n in "6 3".split()]
# # a = [int(n) for n in "2 4 2 1 3 2".split()]
# a = [int(n) for n in "2 4 2 1 3 2".split()]
# b = [7, 4, 6]
maxi = a.index(max(a))
archive = a[maxi:] + a[:maxi]
for curb in b:
a = archive
curgroups = -1
for _ in range(2):
groups = 1
sum = 0
for cura in a:
sum += cura
if sum > curb:
sum = cura
groups += 1
if curgroups == -1 or groups < curgroups:
curgroups = groups
a.append(a.pop(0))
print(curgroups)
``` | instruction | 0 | 84,576 | 3 | 169,152 |
No | output | 1 | 84,576 | 3 | 169,153 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Optimizing the amount of data transmitted via a network is an important and interesting part of developing any network application.
<image>
In one secret game developed deep in the ZeptoLab company, the game universe consists of n levels, located in a circle. You can get from level i to levels i - 1 and i + 1, also you can get from level 1 to level n and vice versa. The map of the i-th level description size is ai bytes.
In order to reduce the transmitted traffic, the game gets levels as follows. All the levels on the server are divided into m groups and each time a player finds himself on one of the levels of a certain group for the first time, the server sends all levels of the group to the game client as a single packet. Thus, when a player travels inside the levels of a single group, the application doesn't need any new information. Due to the technical limitations the packet can contain an arbitrary number of levels but their total size mustn't exceed b bytes, where b is some positive integer constant.
Usual situation is that players finish levels one by one, that's why a decision was made to split n levels into m groups so that each group was a continuous segment containing multiple neighboring levels (also, the group can have two adjacent levels, n and 1). Specifically, if the descriptions of all levels have the total weight of at most b bytes, then they can all be united into one group to be sent in a single packet.
Determine, what minimum number of groups do you need to make in order to organize the levels of the game observing the conditions above?
As developing a game is a long process and technology never stagnates, it is yet impossible to predict exactly what value will take constant value b limiting the packet size when the game is out. That's why the developers ask you to find the answer for multiple values of b.
Input
The first line contains two integers n, q (2 ≤ n ≤ 106, 1 ≤ q ≤ 50) — the number of levels in the game universe and the number of distinct values of b that you need to process.
The second line contains n integers ai (1 ≤ ai ≤ 109) — the sizes of the levels in bytes.
The next q lines contain integers bj (<image>), determining the values of constant b, for which you need to determine the answer.
Output
For each value of kj from the input print on a single line integer mj (1 ≤ mj ≤ n), determining the minimum number of groups to divide game levels into for transmission via network observing the given conditions.
Examples
Input
6 3
2 4 2 1 3 2
7
4
6
Output
2
4
3
Note
In the test from the statement you can do in the following manner.
* at b = 7 you can divide into two segments: 2|421|32 (note that one of the segments contains the fifth, sixth and first levels);
* at b = 4 you can divide into four segments: 2|4|21|3|2;
* at b = 6 you can divide into three segments: 24|21|32|.
Submitted Solution:
```
def numlev(l, b):
c = l.copy()
def sumup(l, x):
tot = l[0]
ans = [0]
for i in range(1, len(l)):
if tot + l[i] <= x:
tot += l[i]
ans.append(i)
else:
break
cou = 0
for i in ans:
del(l[i-cou])
cou += 1
sol = 0
while(len(c) > 0):
sol += 1
sumup(c, b)
return sol
(n, q) = map(int, input().split())
a = list(map(int, input().split()))
barr = []
for i in range(q):
x = int(input())
barr.append(x)
for b in barr:
print(numlev(a, b))
``` | instruction | 0 | 84,577 | 3 | 169,154 |
No | output | 1 | 84,577 | 3 | 169,155 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Optimizing the amount of data transmitted via a network is an important and interesting part of developing any network application.
<image>
In one secret game developed deep in the ZeptoLab company, the game universe consists of n levels, located in a circle. You can get from level i to levels i - 1 and i + 1, also you can get from level 1 to level n and vice versa. The map of the i-th level description size is ai bytes.
In order to reduce the transmitted traffic, the game gets levels as follows. All the levels on the server are divided into m groups and each time a player finds himself on one of the levels of a certain group for the first time, the server sends all levels of the group to the game client as a single packet. Thus, when a player travels inside the levels of a single group, the application doesn't need any new information. Due to the technical limitations the packet can contain an arbitrary number of levels but their total size mustn't exceed b bytes, where b is some positive integer constant.
Usual situation is that players finish levels one by one, that's why a decision was made to split n levels into m groups so that each group was a continuous segment containing multiple neighboring levels (also, the group can have two adjacent levels, n and 1). Specifically, if the descriptions of all levels have the total weight of at most b bytes, then they can all be united into one group to be sent in a single packet.
Determine, what minimum number of groups do you need to make in order to organize the levels of the game observing the conditions above?
As developing a game is a long process and technology never stagnates, it is yet impossible to predict exactly what value will take constant value b limiting the packet size when the game is out. That's why the developers ask you to find the answer for multiple values of b.
Input
The first line contains two integers n, q (2 ≤ n ≤ 106, 1 ≤ q ≤ 50) — the number of levels in the game universe and the number of distinct values of b that you need to process.
The second line contains n integers ai (1 ≤ ai ≤ 109) — the sizes of the levels in bytes.
The next q lines contain integers bj (<image>), determining the values of constant b, for which you need to determine the answer.
Output
For each value of kj from the input print on a single line integer mj (1 ≤ mj ≤ n), determining the minimum number of groups to divide game levels into for transmission via network observing the given conditions.
Examples
Input
6 3
2 4 2 1 3 2
7
4
6
Output
2
4
3
Note
In the test from the statement you can do in the following manner.
* at b = 7 you can divide into two segments: 2|421|32 (note that one of the segments contains the fifth, sixth and first levels);
* at b = 4 you can divide into four segments: 2|4|21|3|2;
* at b = 6 you can divide into three segments: 24|21|32|.
Submitted Solution:
```
import sys
n, q = [int(n) for n in sys.stdin.readline().split()]
a = [int(n) for n in sys.stdin.readline().split()]
b = []
for _ in range(q):
b.append(int(sys.stdin.readline()))
# n, q = [int(n) for n in "6 3".split()]
# # a = [int(n) for n in "2 4 2 1 3 2".split()]
# a = [int(n) for n in "2 4 2 1 3 2".split()]
# b = [7, 4, 6]
maxi = a.index(max(a))
archive = a[maxi:] + a[:maxi]
lena = min([len(a), 12])
for curb in b:
a = archive
curgroups = -1
for _ in range(lena):
groups = 1
sum = 0
for cura in a:
sum += cura
if sum > curb:
sum = cura
groups += 1
if curgroups == -1 or groups < curgroups:
curgroups = groups
a.insert(0, a.pop())
a.insert(0, a.pop())
print(curgroups)
``` | instruction | 0 | 84,578 | 3 | 169,156 |
No | output | 1 | 84,578 | 3 | 169,157 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everyone knows that long ago on the territory of present-day Berland there lived Bindian tribes. Their capital was surrounded by n hills, forming a circle. On each hill there was a watchman, who watched the neighbourhood day and night.
In case of any danger the watchman could make a fire on the hill. One watchman could see the signal of another watchman, if on the circle arc connecting the two hills there was no hill higher than any of the two. As for any two hills there are two different circle arcs connecting them, the signal was seen if the above mentioned condition was satisfied on at least one of the arcs. For example, for any two neighbouring watchmen it is true that the signal of one will be seen by the other.
An important characteristics of this watch system was the amount of pairs of watchmen able to see each other's signals. You are to find this amount by the given heights of the hills.
Input
The first line of the input data contains an integer number n (3 ≤ n ≤ 106), n — the amount of hills around the capital. The second line contains n numbers — heights of the hills in clockwise order. All height numbers are integer and lie between 1 and 109.
Output
Print the required amount of pairs.
Examples
Input
5
1 2 4 5 3
Output
7 | instruction | 0 | 84,614 | 3 | 169,228 |
Tags: data structures
Correct Solution:
```
#!/usr/bin/env python
def main():
n = int(input())
hill = tuple(map(int, input().split()))
pairs = 0
highest, at = max((h, k) for k, h in enumerate(hill))
last = highest
count = 0
previous = list()
push = previous.append
pop = previous.pop
for at in range(at - 1, at - n, -1):
current = hill[at]
while current > last:
pairs += count
last, count = pop()
if current == last:
count += 1
pairs += count
else:
pairs += 1
push((last, count))
last = current
count = 1
push((last, count))
end = len(previous)
pairs += sum(previous[k][1]
for k in range((1 if previous[0][1] else 2), end))
print(pairs)
if __name__ == '__main__':
main()
``` | output | 1 | 84,614 | 3 | 169,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everyone knows that long ago on the territory of present-day Berland there lived Bindian tribes. Their capital was surrounded by n hills, forming a circle. On each hill there was a watchman, who watched the neighbourhood day and night.
In case of any danger the watchman could make a fire on the hill. One watchman could see the signal of another watchman, if on the circle arc connecting the two hills there was no hill higher than any of the two. As for any two hills there are two different circle arcs connecting them, the signal was seen if the above mentioned condition was satisfied on at least one of the arcs. For example, for any two neighbouring watchmen it is true that the signal of one will be seen by the other.
An important characteristics of this watch system was the amount of pairs of watchmen able to see each other's signals. You are to find this amount by the given heights of the hills.
Input
The first line of the input data contains an integer number n (3 ≤ n ≤ 106), n — the amount of hills around the capital. The second line contains n numbers — heights of the hills in clockwise order. All height numbers are integer and lie between 1 and 109.
Output
Print the required amount of pairs.
Examples
Input
5
1 2 4 5 3
Output
7
Submitted Solution:
```
n = int(input())
hs = list(map(int, input().split()))
maxi = hs.index(max(hs))
# linearise
hs = hs[maxi:] + hs[:maxi]
hs.append(hs[0])
rs = [n]*(n+1)
ls = [0]*(n+1)
ss = [0]*(n+1)
for i in range(n-1, -1, -1):
rs[i] = i+1
while rs[i] < n and hs[i] > hs[rs[i]]:
rs[i] = rs[rs[i]]
if rs[i] < n and hs[i] == hs[rs[i]]:
ss[i] = ss[rs[i]] + 1
rs[i] = rs[rs[i]]
ans = ss[0]
for i in range(1, n+1):
ls[i] = i-1
while ls[i] > 0 and hs[i] >= hs[ls[i]]:
ls[i] = ls[ls[i]]
if hs[i] < hs[ls[i]]:
#print(i, ls[i])
ans += 1
if hs[i] < hs[rs[i]] and (ls[i] != 0 or rs[i] != n):
#print(i, rs[i])
ans += 1
ans += ss[i]
#print(ls)
#print(rs)
#print(ss)
print(ans)
``` | instruction | 0 | 84,619 | 3 | 169,238 |
Yes | output | 1 | 84,619 | 3 | 169,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everyone knows that long ago on the territory of present-day Berland there lived Bindian tribes. Their capital was surrounded by n hills, forming a circle. On each hill there was a watchman, who watched the neighbourhood day and night.
In case of any danger the watchman could make a fire on the hill. One watchman could see the signal of another watchman, if on the circle arc connecting the two hills there was no hill higher than any of the two. As for any two hills there are two different circle arcs connecting them, the signal was seen if the above mentioned condition was satisfied on at least one of the arcs. For example, for any two neighbouring watchmen it is true that the signal of one will be seen by the other.
An important characteristics of this watch system was the amount of pairs of watchmen able to see each other's signals. You are to find this amount by the given heights of the hills.
Input
The first line of the input data contains an integer number n (3 ≤ n ≤ 106), n — the amount of hills around the capital. The second line contains n numbers — heights of the hills in clockwise order. All height numbers are integer and lie between 1 and 109.
Output
Print the required amount of pairs.
Examples
Input
5
1 2 4 5 3
Output
7
Submitted Solution:
```
"""
Codeforces
5E - Bindian Signalizing
http://codeforces.com/contest/5/problem/E
Héctor González Belver
../07/2018
"""
import sys
import itertools
def rotation(iterable, n, start):
for i in range(n):
yield iterable[(i+start)%n]
def main():
n = int(sys.stdin.readline().strip())
hills = list(map(int,sys.stdin.readline().strip().split()))
max_height, pos_max_height = max((h, i) for i, h in enumerate(hills))
reference_height = max_height
reference_cost = 0
pairs = 0
reference_hills = []
for current_height in itertools.islice(rotation(hills, n, pos_max_height+1), n-1):
while current_height > reference_height:
pairs += reference_cost
reference_height, reference_cost = reference_hills.pop()
if current_height == reference_height:
reference_cost += 1
pairs += reference_cost
else:
pairs += 1
reference_hills.append((reference_height, reference_cost))
reference_height = current_height
reference_cost = 1
reference_hills.append((reference_height, reference_cost))
start = 1 if reference_hills[0][1] else 2
pairs += sum(reference_hills[i][1] for i in range(start, len(reference_hills)))
sys.stdout.write(str(pairs) + '\n')
if __name__ == '__main__':
main()
``` | instruction | 0 | 84,620 | 3 | 169,240 |
Yes | output | 1 | 84,620 | 3 | 169,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everyone knows that long ago on the territory of present-day Berland there lived Bindian tribes. Their capital was surrounded by n hills, forming a circle. On each hill there was a watchman, who watched the neighbourhood day and night.
In case of any danger the watchman could make a fire on the hill. One watchman could see the signal of another watchman, if on the circle arc connecting the two hills there was no hill higher than any of the two. As for any two hills there are two different circle arcs connecting them, the signal was seen if the above mentioned condition was satisfied on at least one of the arcs. For example, for any two neighbouring watchmen it is true that the signal of one will be seen by the other.
An important characteristics of this watch system was the amount of pairs of watchmen able to see each other's signals. You are to find this amount by the given heights of the hills.
Input
The first line of the input data contains an integer number n (3 ≤ n ≤ 106), n — the amount of hills around the capital. The second line contains n numbers — heights of the hills in clockwise order. All height numbers are integer and lie between 1 and 109.
Output
Print the required amount of pairs.
Examples
Input
5
1 2 4 5 3
Output
7
Submitted Solution:
```
n = int(input())
hills = list(map(int, input().strip().split()))
max_height, pos_max_height = max((h, i) for i, h in enumerate(hills))
rotation_hill=(hills[pos_max_height:]+hills[:pos_max_height])[1:]
reference_height = max_height
reference_cost = 0
pairs = 0
reference_hills = []
for current_height in rotation_hill:
while current_height > reference_height:
pairs += reference_cost
reference_height, reference_cost = reference_hills.pop()
if current_height == reference_height:
reference_cost += 1
pairs += reference_cost
else:
pairs += 1
reference_hills.append((reference_height, reference_cost))
reference_height = current_height
reference_cost = 1
reference_hills.append((reference_height, reference_cost))
start = 1 if reference_hills[0][1] else 2
pairs += sum(reference_hills[i][1] for i in range(start, len(reference_hills)))
print(pairs)
``` | instruction | 0 | 84,621 | 3 | 169,242 |
Yes | output | 1 | 84,621 | 3 | 169,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everyone knows that long ago on the territory of present-day Berland there lived Bindian tribes. Their capital was surrounded by n hills, forming a circle. On each hill there was a watchman, who watched the neighbourhood day and night.
In case of any danger the watchman could make a fire on the hill. One watchman could see the signal of another watchman, if on the circle arc connecting the two hills there was no hill higher than any of the two. As for any two hills there are two different circle arcs connecting them, the signal was seen if the above mentioned condition was satisfied on at least one of the arcs. For example, for any two neighbouring watchmen it is true that the signal of one will be seen by the other.
An important characteristics of this watch system was the amount of pairs of watchmen able to see each other's signals. You are to find this amount by the given heights of the hills.
Input
The first line of the input data contains an integer number n (3 ≤ n ≤ 106), n — the amount of hills around the capital. The second line contains n numbers — heights of the hills in clockwise order. All height numbers are integer and lie between 1 and 109.
Output
Print the required amount of pairs.
Examples
Input
5
1 2 4 5 3
Output
7
Submitted Solution:
```
from sys import stdin, stdout
def rotate(a):
mx = -1
mxp = -1;
for i in range(len(a)):
if a[i] > mx:
mx = a[i]
mxp = i
n = len(a)
h = [0]*n
#print(mxp)
for i in range(mxp, mxp + n):
h[i-mxp] = a[i%n]
h.append(h[0])
return h
def gettotalpairs(n, a):
h = rotate(a)
l = [0]*len(h)
r = [0]*len(h)
c = [0]*len(h)
l[0] = n
for i in range(1, n):
l[i] = i-1
while h[i] > h[l[i]]:
l[i] = l[l[i]]
if h[i] == h[l[i]]:
c[i] = c[l[i]]+1
l[i] = l[l[i]]
r[n] = n
for i in range(n-1, -1, -1):
r[i] = i + 1
while h[i] > h[r[i]]:
r[i] = r[r[i]]
if h[i] == h[r[i]]:
r[i] = r[r[i]]
res = 0
for i in range(n):
if h[i] < h[0]:
if l[i] == 0 and r[i] == n:
res += 1;
else:
res += 2
res += c[i];
return int(res)
if __name__ == '__main__':
n = int(stdin.readline())
a = list(map(int, stdin.readline().split()))
res = gettotalpairs(n, a)
stdout.write(str(res))
``` | instruction | 0 | 84,622 | 3 | 169,244 |
Yes | output | 1 | 84,622 | 3 | 169,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everyone knows that long ago on the territory of present-day Berland there lived Bindian tribes. Their capital was surrounded by n hills, forming a circle. On each hill there was a watchman, who watched the neighbourhood day and night.
In case of any danger the watchman could make a fire on the hill. One watchman could see the signal of another watchman, if on the circle arc connecting the two hills there was no hill higher than any of the two. As for any two hills there are two different circle arcs connecting them, the signal was seen if the above mentioned condition was satisfied on at least one of the arcs. For example, for any two neighbouring watchmen it is true that the signal of one will be seen by the other.
An important characteristics of this watch system was the amount of pairs of watchmen able to see each other's signals. You are to find this amount by the given heights of the hills.
Input
The first line of the input data contains an integer number n (3 ≤ n ≤ 106), n — the amount of hills around the capital. The second line contains n numbers — heights of the hills in clockwise order. All height numbers are integer and lie between 1 and 109.
Output
Print the required amount of pairs.
Examples
Input
5
1 2 4 5 3
Output
7
Submitted Solution:
```
t,n=int(input()),tuple(map(int,input().split()))
if t<2:print(0)
mx=ans=0
c=1
for i in range(1,len(n)):
if n[i]>n[mx]:
ans+=i
mx=i
c=1
elif n[i]<n[mx]:
ans+=i-mx+c-1
else:
ans+=i-mx+c-1 if c>1 else i
mx=i
c+=1
print(ans)
``` | instruction | 0 | 84,623 | 3 | 169,246 |
No | output | 1 | 84,623 | 3 | 169,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everyone knows that long ago on the territory of present-day Berland there lived Bindian tribes. Their capital was surrounded by n hills, forming a circle. On each hill there was a watchman, who watched the neighbourhood day and night.
In case of any danger the watchman could make a fire on the hill. One watchman could see the signal of another watchman, if on the circle arc connecting the two hills there was no hill higher than any of the two. As for any two hills there are two different circle arcs connecting them, the signal was seen if the above mentioned condition was satisfied on at least one of the arcs. For example, for any two neighbouring watchmen it is true that the signal of one will be seen by the other.
An important characteristics of this watch system was the amount of pairs of watchmen able to see each other's signals. You are to find this amount by the given heights of the hills.
Input
The first line of the input data contains an integer number n (3 ≤ n ≤ 106), n — the amount of hills around the capital. The second line contains n numbers — heights of the hills in clockwise order. All height numbers are integer and lie between 1 and 109.
Output
Print the required amount of pairs.
Examples
Input
5
1 2 4 5 3
Output
7
Submitted Solution:
```
n = int(input())
test = dict()
arr = list(map(int, input().split())) * 2
answ = n
for i in range(n):
loc_max = 0
for j in range(i + 2, i + n - 1):
if j >= n and i in test and j % n in test[i]:
break
loc_max = max(loc_max, arr[j - 1])
if loc_max <= min(arr[i], arr[j]):
answ += 1
if i < n and j < n:
test[j] = dict()
test[j][i] = True
print(answ)
``` | instruction | 0 | 84,624 | 3 | 169,248 |
No | output | 1 | 84,624 | 3 | 169,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everyone knows that long ago on the territory of present-day Berland there lived Bindian tribes. Their capital was surrounded by n hills, forming a circle. On each hill there was a watchman, who watched the neighbourhood day and night.
In case of any danger the watchman could make a fire on the hill. One watchman could see the signal of another watchman, if on the circle arc connecting the two hills there was no hill higher than any of the two. As for any two hills there are two different circle arcs connecting them, the signal was seen if the above mentioned condition was satisfied on at least one of the arcs. For example, for any two neighbouring watchmen it is true that the signal of one will be seen by the other.
An important characteristics of this watch system was the amount of pairs of watchmen able to see each other's signals. You are to find this amount by the given heights of the hills.
Input
The first line of the input data contains an integer number n (3 ≤ n ≤ 106), n — the amount of hills around the capital. The second line contains n numbers — heights of the hills in clockwise order. All height numbers are integer and lie between 1 and 109.
Output
Print the required amount of pairs.
Examples
Input
5
1 2 4 5 3
Output
7
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split()))
left_max = [0 for i in range(0, n)]
right_max = [0 for i in range(0, n)]
for i in range(1, n):
left_max[i] = max(left_max[i - 1], arr[i - 1])
for i in range(n - 2, -1, -1):
right_max[i] = max(right_max[i + 1], arr[i + 1])
right_idx = [n for i in range(0, n)]
for i in range(0, n):
for j in range(i + 1, n):
if arr[j] > arr[i]:
right_idx[i] = j
break
cnt = 0
for i in range(0, n):
for j in range(i + 1, n):
a, b = arr[i], arr[j]
if a >= left_max[i] and a >= right_max[j] and b >= left_max[i] and b >= right_max[j]:
cnt += 1
elif right_idx[i] >= j:
cnt += 1
print(cnt)
``` | instruction | 0 | 84,625 | 3 | 169,250 |
No | output | 1 | 84,625 | 3 | 169,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everyone knows that long ago on the territory of present-day Berland there lived Bindian tribes. Their capital was surrounded by n hills, forming a circle. On each hill there was a watchman, who watched the neighbourhood day and night.
In case of any danger the watchman could make a fire on the hill. One watchman could see the signal of another watchman, if on the circle arc connecting the two hills there was no hill higher than any of the two. As for any two hills there are two different circle arcs connecting them, the signal was seen if the above mentioned condition was satisfied on at least one of the arcs. For example, for any two neighbouring watchmen it is true that the signal of one will be seen by the other.
An important characteristics of this watch system was the amount of pairs of watchmen able to see each other's signals. You are to find this amount by the given heights of the hills.
Input
The first line of the input data contains an integer number n (3 ≤ n ≤ 106), n — the amount of hills around the capital. The second line contains n numbers — heights of the hills in clockwise order. All height numbers are integer and lie between 1 and 109.
Output
Print the required amount of pairs.
Examples
Input
5
1 2 4 5 3
Output
7
Submitted Solution:
```
n = int(input())
test = [[False for _ in range(n)] for _ in range(n)]
arr = list(map(int, input().split())) * 2
answ = n
for i in range(n):
loc_max = 0
for j in range(i + 2, i + n - 1):
if test[i % n][j % n]:
break
loc_max = max(loc_max, arr[j - 1])
if loc_max <= min(arr[i], arr[j]):
answ += 1
test[i % n][j % n] = True
test[j % n][i % n] = True
print(answ)
``` | instruction | 0 | 84,626 | 3 | 169,252 |
No | output | 1 | 84,626 | 3 | 169,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Developer Petr thinks that he invented a perpetual motion machine. Namely, he has a lot of elements, which work in the following way.
Each element has one controller that can be set to any non-negative real value. If a controller is set on some value x, then the controller consumes x2 energy units per second. At the same time, any two elements connected by a wire produce y·z energy units per second, where y and z are the values set on their controllers.
Petr has only a limited number of wires, so he has already built some scheme of elements and wires, and is now interested if it's possible to set the controllers in such a way that the system produces at least as much power as it consumes, and at least one controller is set on the value different from 0. Help him check this, and if it's possible, find the required integer values that should be set.
It is guaranteed that if there exist controllers' settings satisfying the above conditions, then there exist required integer values not greater than 106.
Input
There are several (at least one) test cases in the input. The first line contains single integer — the number of test cases.
There is an empty line before each test case. The first line of test case contains two integers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 105) — the number of elements in the scheme and the number of wires.
After that, m lines follow, each of them contains two integers a and b (1 ≤ a, b ≤ n) — two elements connected by a wire. No element is connected with itself, no two elements are connected by more than one wire.
It is guaranteed that the sum of n and the sum of m over all test cases do not exceed 105.
For hacks you can only use tests with one test case.
Output
Print answer for each test case.
For each test case print "YES" if it's possible to set the controllers in such a way that the consumed power is not greater than the power produced, and the required values on the next line. The settings should be integers from 0 to 106, inclusive, and at least one value should be different from 0. If there are multiple answers, print any of them.
If it's not possible to set the controllers in the required way, print one line "NO".
Example
Input
4
4 4
1 2
2 3
3 4
4 2
3 2
2 3
3 1
4 6
1 2
3 4
4 2
1 4
1 3
3 2
10 9
2 1
3 2
5 2
6 2
2 7
2 8
2 9
2 10
4 2
Output
YES
1 2 2 1
NO
YES
1 1 1 1
YES
1 5 1 1 1 1 1 1 1 1
Note
In the first example it's possible to set the controllers in the required way, for example, in the following way: set 1 on the first element, set 2 on the second and on the third, set 1 on the fourth. The consumed power is then equal to 12 + 22 + 22 + 12 = 10 energy units per second, the produced power is equal to 1·2 + 2·2 + 2·1 + 2·1 = 10 energy units per second. Thus the answer is "YES".
In the second test case it's not possible to set the controllers in the required way. For example, if we set all controllers to 0.5, then the consumed powers equals 0.75 energy units per second, while produced power equals 0.5 energy units per second.
Submitted Solution:
```
n,r,p=int(input()),0,0
for i in map(int,input().split()):
if (i>p and r>0) or (i==p and r==2):exit(print("NO"))
elif i>p and r==0:p=i;continue
elif i==p:r=1
else:r=2
p=i
print("YES")
``` | instruction | 0 | 84,710 | 3 | 169,420 |
No | output | 1 | 84,710 | 3 | 169,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Developer Petr thinks that he invented a perpetual motion machine. Namely, he has a lot of elements, which work in the following way.
Each element has one controller that can be set to any non-negative real value. If a controller is set on some value x, then the controller consumes x2 energy units per second. At the same time, any two elements connected by a wire produce y·z energy units per second, where y and z are the values set on their controllers.
Petr has only a limited number of wires, so he has already built some scheme of elements and wires, and is now interested if it's possible to set the controllers in such a way that the system produces at least as much power as it consumes, and at least one controller is set on the value different from 0. Help him check this, and if it's possible, find the required integer values that should be set.
It is guaranteed that if there exist controllers' settings satisfying the above conditions, then there exist required integer values not greater than 106.
Input
There are several (at least one) test cases in the input. The first line contains single integer — the number of test cases.
There is an empty line before each test case. The first line of test case contains two integers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 105) — the number of elements in the scheme and the number of wires.
After that, m lines follow, each of them contains two integers a and b (1 ≤ a, b ≤ n) — two elements connected by a wire. No element is connected with itself, no two elements are connected by more than one wire.
It is guaranteed that the sum of n and the sum of m over all test cases do not exceed 105.
For hacks you can only use tests with one test case.
Output
Print answer for each test case.
For each test case print "YES" if it's possible to set the controllers in such a way that the consumed power is not greater than the power produced, and the required values on the next line. The settings should be integers from 0 to 106, inclusive, and at least one value should be different from 0. If there are multiple answers, print any of them.
If it's not possible to set the controllers in the required way, print one line "NO".
Example
Input
4
4 4
1 2
2 3
3 4
4 2
3 2
2 3
3 1
4 6
1 2
3 4
4 2
1 4
1 3
3 2
10 9
2 1
3 2
5 2
6 2
2 7
2 8
2 9
2 10
4 2
Output
YES
1 2 2 1
NO
YES
1 1 1 1
YES
1 5 1 1 1 1 1 1 1 1
Note
In the first example it's possible to set the controllers in the required way, for example, in the following way: set 1 on the first element, set 2 on the second and on the third, set 1 on the fourth. The consumed power is then equal to 12 + 22 + 22 + 12 = 10 energy units per second, the produced power is equal to 1·2 + 2·2 + 2·1 + 2·1 = 10 energy units per second. Thus the answer is "YES".
In the second test case it's not possible to set the controllers in the required way. For example, if we set all controllers to 0.5, then the consumed powers equals 0.75 energy units per second, while produced power equals 0.5 energy units per second.
Submitted Solution:
```
test_cases = int(input())
#print("Test cases:", test_cases)
def value(controllers, connections):
consume = 0
for controller in controllers:
consume += controller ** 2
produce = 0
for connection in connections:
produce += controllers[connection[0] - 1] * controllers[connection[1] - 1]
return consume <= produce
def recurse(elements):
#controller_values = [[0], [1], [2], [3]]
basic_values = [[0], [1], [2]]
if elements == 1:
return basic_values
else:
lst = []
for c_value in recurse(elements - 1):
for basic in basic_values:
lst.append(c_value + basic)
return lst
for i in range(test_cases):
#print("---------Test case", i + 1, "--------")
input()
elements, wires = [int(x) for x in input().split()]
#print("Elements:", elements)
#print("Wires:", wires)
#print("Type of wire:", type(wires))
connections = []
for j in range(wires):
a, b = [int(x) for x in input().split()]
connections.append((a, b))
#print("Connections become", connections)
#print("Connections are:")
#for connection in connections:
#print(connection[0], "with", connection[1])
all_controllers = recurse(elements)[1:]
breaked = False
for controllers in all_controllers:
if value(controllers, connections):
print("YES")
for controller in controllers:
print(controller,end=' ')
print()
breaked = True
break
if not breaked:
print("NO")
#print("=========================")
#print(recurse(5))
``` | instruction | 0 | 84,711 | 3 | 169,422 |
No | output | 1 | 84,711 | 3 | 169,423 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.