message stringlengths 2 65.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 0 108k | cluster float64 14 14 | __index_level_0__ int64 0 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull.
Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p?
More formally, if we denote the handle of the i-th person as hi, then the following condition must hold: <image>.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of people.
The next n lines each contains two strings. The i-th line contains strings fi and si (1 ≤ |fi|, |si| ≤ 50) — the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct.
The next line contains n distinct integers: p1, p2, ..., pn (1 ≤ pi ≤ n).
Output
If it is possible, output "YES", otherwise output "NO".
Examples
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
1 2 3
Output
NO
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
3 1 2
Output
YES
Input
2
galileo galilei
nicolaus copernicus
2 1
Output
YES
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
2 4 9 6 5 7 1 3 8 10
Output
YES
Note
In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last.
In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright. | instruction | 0 | 28,619 | 14 | 57,238 |
Tags: greedy
Correct Solution:
```
n = int(input())
l = [input().split() for i in range(n)]
p = [int(x)-1 for x in input().split()]
cur = ""
poss = True
for i in range(n):
per = l[p[i]]
if per[0] > cur:
if per[1] > cur:
cur = min(per[0],per[1])
else:
cur = per[0]
else:
if per[1] > cur:
cur = per[1]
else:
poss = False
break
print("YES" if poss else "NO")
``` | output | 1 | 28,619 | 14 | 57,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull.
Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p?
More formally, if we denote the handle of the i-th person as hi, then the following condition must hold: <image>.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of people.
The next n lines each contains two strings. The i-th line contains strings fi and si (1 ≤ |fi|, |si| ≤ 50) — the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct.
The next line contains n distinct integers: p1, p2, ..., pn (1 ≤ pi ≤ n).
Output
If it is possible, output "YES", otherwise output "NO".
Examples
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
1 2 3
Output
NO
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
3 1 2
Output
YES
Input
2
galileo galilei
nicolaus copernicus
2 1
Output
YES
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
2 4 9 6 5 7 1 3 8 10
Output
YES
Note
In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last.
In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright.
Submitted Solution:
```
def solve(n, names, p):
first_idx = p[0] - 1
last_handle = min(names[first_idx][0], names[first_idx][1])
for i in range(1, n):
curr_idx = p[i] - 1
curr_handle = min(names[curr_idx][0], names[curr_idx][1])
if curr_handle < last_handle:
curr_handle = max(names[curr_idx][0], names[curr_idx][1])
if curr_handle < last_handle:
return "NO"
last_handle = curr_handle
return "YES"
if __name__ == "__main__":
n = int(input())
names = list()
for _ in range(0, n):
name = input().split(" ")
names.append(name)
p = list(map(int, input().split(" ")))
print(solve(n, names, p))
``` | instruction | 0 | 28,620 | 14 | 57,240 |
Yes | output | 1 | 28,620 | 14 | 57,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull.
Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p?
More formally, if we denote the handle of the i-th person as hi, then the following condition must hold: <image>.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of people.
The next n lines each contains two strings. The i-th line contains strings fi and si (1 ≤ |fi|, |si| ≤ 50) — the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct.
The next line contains n distinct integers: p1, p2, ..., pn (1 ≤ pi ≤ n).
Output
If it is possible, output "YES", otherwise output "NO".
Examples
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
1 2 3
Output
NO
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
3 1 2
Output
YES
Input
2
galileo galilei
nicolaus copernicus
2 1
Output
YES
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
2 4 9 6 5 7 1 3 8 10
Output
YES
Note
In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last.
In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright.
Submitted Solution:
```
from functools import reduce
from operator import *
from math import *
from sys import *
from string import *
setrecursionlimit(10**7)
RI=lambda: list(map(int,input().split()))
RS=lambda: input().rstrip().split()
#################################################
n=RI()[0]
inp=[0]*n
flag=1
for i in range(n):
inp[i]=RS()
p=RI()
minS=min(inp[p[0]-1])
for i in range(1,n):
if inp[p[i]-1][0]>minS and inp[p[i]-1][1]>minS:
minS=min(inp[p[i]-1])
elif inp[p[i]-1][0]>minS:
minS=inp[p[i]-1][0]
elif inp[p[i]-1][1]>minS:
minS=inp[p[i]-1][1]
else:
flag=0
print(["NO","YES"][flag])
``` | instruction | 0 | 28,621 | 14 | 57,242 |
Yes | output | 1 | 28,621 | 14 | 57,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull.
Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p?
More formally, if we denote the handle of the i-th person as hi, then the following condition must hold: <image>.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of people.
The next n lines each contains two strings. The i-th line contains strings fi and si (1 ≤ |fi|, |si| ≤ 50) — the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct.
The next line contains n distinct integers: p1, p2, ..., pn (1 ≤ pi ≤ n).
Output
If it is possible, output "YES", otherwise output "NO".
Examples
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
1 2 3
Output
NO
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
3 1 2
Output
YES
Input
2
galileo galilei
nicolaus copernicus
2 1
Output
YES
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
2 4 9 6 5 7 1 3 8 10
Output
YES
Note
In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last.
In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright.
Submitted Solution:
```
def doJ(a , b):
return [a,b]
n = int(input())
where = []
for i in range(n):
where.append([])
a = []
for i in range(n):
cur = list(map(str, input().split()))
fi = doJ(cur[0], i)
se = doJ(cur[1], i)
a.append(fi)
a.append(se)
a.sort(key=lambda x: x[0])
h = list(map(int, input().split()))
cur = 0
for i in a:
where[i[1]].append(cur)
cur += 1
pre = -1
fl = True
for i in range(n):
h[i] -= 1
if where[h[i]][0] > pre:
pre = where[h[i]][0]
elif where[h[i]][1] > pre:
pre = where[h[i]][1]
else:
fl = False
if fl is False:
print("NO")
else :
print("YES")
``` | instruction | 0 | 28,622 | 14 | 57,244 |
Yes | output | 1 | 28,622 | 14 | 57,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull.
Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p?
More formally, if we denote the handle of the i-th person as hi, then the following condition must hold: <image>.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of people.
The next n lines each contains two strings. The i-th line contains strings fi and si (1 ≤ |fi|, |si| ≤ 50) — the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct.
The next line contains n distinct integers: p1, p2, ..., pn (1 ≤ pi ≤ n).
Output
If it is possible, output "YES", otherwise output "NO".
Examples
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
1 2 3
Output
NO
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
3 1 2
Output
YES
Input
2
galileo galilei
nicolaus copernicus
2 1
Output
YES
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
2 4 9 6 5 7 1 3 8 10
Output
YES
Note
In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last.
In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright.
Submitted Solution:
```
import sys
input = lambda:sys.stdin.readline()
MOD = 1000000007
ii = lambda: int(input())
si = lambda: input()
dgl = lambda: list(map(int, input()))
f = lambda: list(map(int, input().split()))
il = lambda: list(map(int, input().split()))
ls = lambda: list(input())
lstr = lambda: list(input().split())
n = ii()
l = []
arr = []
for _ in range(n):
x = lstr()
l.append(x)
arr.extend(x)
lind = il()
arr.sort()
ind = 0
for i in arr:
if ind < n and i in l[lind[ind]-1]:
ind += 1
print('YNEOS'[ind != n::2])
``` | instruction | 0 | 28,623 | 14 | 57,246 |
Yes | output | 1 | 28,623 | 14 | 57,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull.
Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p?
More formally, if we denote the handle of the i-th person as hi, then the following condition must hold: <image>.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of people.
The next n lines each contains two strings. The i-th line contains strings fi and si (1 ≤ |fi|, |si| ≤ 50) — the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct.
The next line contains n distinct integers: p1, p2, ..., pn (1 ≤ pi ≤ n).
Output
If it is possible, output "YES", otherwise output "NO".
Examples
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
1 2 3
Output
NO
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
3 1 2
Output
YES
Input
2
galileo galilei
nicolaus copernicus
2 1
Output
YES
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
2 4 9 6 5 7 1 3 8 10
Output
YES
Note
In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last.
In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright.
Submitted Solution:
```
n=int(input())
l=[]
f=0
s3=""
for i in range(n):
s1,s2=map(str,input().strip().split(' '))
l.append([s1,s2])
lst = list(map(int,input().strip().split(' ')))
for j in range(n):
if j==0:
s3=min(l[lst[j]-1][0],l[lst[j]-1][1])
else:
s4=l[lst[j]-1][0]
s5=l[lst[j]-1][0]
if s4>s5:
s4,s5=s5,s4
if s3>s4 and s3>s5:
f=1
print('NO')
break
else:
if s3<s4:
s3=s4
else:
s3=s5
if f==0:
print('YES')
``` | instruction | 0 | 28,624 | 14 | 57,248 |
No | output | 1 | 28,624 | 14 | 57,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull.
Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p?
More formally, if we denote the handle of the i-th person as hi, then the following condition must hold: <image>.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of people.
The next n lines each contains two strings. The i-th line contains strings fi and si (1 ≤ |fi|, |si| ≤ 50) — the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct.
The next line contains n distinct integers: p1, p2, ..., pn (1 ≤ pi ≤ n).
Output
If it is possible, output "YES", otherwise output "NO".
Examples
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
1 2 3
Output
NO
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
3 1 2
Output
YES
Input
2
galileo galilei
nicolaus copernicus
2 1
Output
YES
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
2 4 9 6 5 7 1 3 8 10
Output
YES
Note
In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last.
In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright.
Submitted Solution:
```
n=int(input())
l=[None]*n
i=0
while i<n:
l[i]=input().split()
i+=1
z=[int(px) for px in input().split()]
x=1
y=True
a=min(l[z[0]-1])
while x<n-1:
u=l[z[x]-1][0]
v=l[z[x]-1][1]
if(u<a and v<a):
y=False
break
elif(u>a and v>a):
a=min(u,v)
else:
a=max(u,v)
x+=1
if(y):
print("YES")
else:
print("NO")
``` | instruction | 0 | 28,625 | 14 | 57,250 |
No | output | 1 | 28,625 | 14 | 57,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull.
Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p?
More formally, if we denote the handle of the i-th person as hi, then the following condition must hold: <image>.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of people.
The next n lines each contains two strings. The i-th line contains strings fi and si (1 ≤ |fi|, |si| ≤ 50) — the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct.
The next line contains n distinct integers: p1, p2, ..., pn (1 ≤ pi ≤ n).
Output
If it is possible, output "YES", otherwise output "NO".
Examples
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
1 2 3
Output
NO
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
3 1 2
Output
YES
Input
2
galileo galilei
nicolaus copernicus
2 1
Output
YES
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
2 4 9 6 5 7 1 3 8 10
Output
YES
Note
In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last.
In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright.
Submitted Solution:
```
from itertools import product
def main():
n = int(input())
a = [[i, j] for _ in range(n) for i, j in (input().split(),)]
pi = map(int, input().split())
res = (True, True)
prev = a[next(pi)-1]
l = lambda i, j: prev[i] <= a[p-1][j]
for p in pi:
res = tuple(any(l(i, j) for i in (0, 1) if res[i]) for j in (0, 1))
if not any(res):
print('NO')
return
print('YES')
if __name__ == '__main__':
main()
``` | instruction | 0 | 28,626 | 14 | 57,252 |
No | output | 1 | 28,626 | 14 | 57,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull.
Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p?
More formally, if we denote the handle of the i-th person as hi, then the following condition must hold: <image>.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of people.
The next n lines each contains two strings. The i-th line contains strings fi and si (1 ≤ |fi|, |si| ≤ 50) — the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct.
The next line contains n distinct integers: p1, p2, ..., pn (1 ≤ pi ≤ n).
Output
If it is possible, output "YES", otherwise output "NO".
Examples
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
1 2 3
Output
NO
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
3 1 2
Output
YES
Input
2
galileo galilei
nicolaus copernicus
2 1
Output
YES
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
2 4 9 6 5 7 1 3 8 10
Output
YES
Note
In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last.
In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright.
Submitted Solution:
```
import sys
import queue
#file = open("in.txt", "r")
#sys.stdin = file
line = sys.stdin.readline()
n = int(line)
first = ["" for x in range(n)]
second = ["" for x in range(n)]
for i in range(0, n):
line = sys.stdin.readline().split()
first[i] = line[0]
second[i] = line[1]
permutation = [int(x) for x in sys.stdin.readline().split()]
last = min(first[0], second[0])
can = True
for i in range(1, n):
p = permutation[i]-1
if last < min(first[p], second[p]):
last = min(first[p], second[p])
elif last < max(first[p], second[p]):
last = max(first[p], second[p])
else:
can = False
if can:
print("YES")
else:
print("NO")
``` | instruction | 0 | 28,627 | 14 | 57,254 |
No | output | 1 | 28,627 | 14 | 57,255 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After celebrating the midcourse the students of one of the faculties of the Berland State University decided to conduct a vote for the best photo. They published the photos in the social network and agreed on the rules to choose a winner: the photo which gets most likes wins. If multiple photoes get most likes, the winner is the photo that gets this number first.
Help guys determine the winner photo by the records of likes.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the total likes to the published photoes.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 1 000 000), where ai is the identifier of the photo which got the i-th like.
Output
Print the identifier of the photo which won the elections.
Examples
Input
5
1 3 2 2 1
Output
2
Input
9
100 200 300 200 100 300 300 100 200
Output
300
Note
In the first test sample the photo with id 1 got two likes (first and fifth), photo with id 2 got two likes (third and fourth), and photo with id 3 got one like (second).
Thus, the winner is the photo with identifier 2, as it got:
* more likes than the photo with id 3;
* as many likes as the photo with id 1, but the photo with the identifier 2 got its second like earlier. | instruction | 0 | 28,676 | 14 | 57,352 |
Tags: *special, constructive algorithms, implementation
Correct Solution:
```
numbers = int(input())
line = input()
dic = {}
parts = line.split(" ")
maxi=parts[0]
for x in parts:
if x in dic.keys():
dic[x]+=1
else:
dic[x]=1
if dic[x]>dic[maxi]:
maxi = x
print(maxi)
``` | output | 1 | 28,676 | 14 | 57,353 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After celebrating the midcourse the students of one of the faculties of the Berland State University decided to conduct a vote for the best photo. They published the photos in the social network and agreed on the rules to choose a winner: the photo which gets most likes wins. If multiple photoes get most likes, the winner is the photo that gets this number first.
Help guys determine the winner photo by the records of likes.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the total likes to the published photoes.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 1 000 000), where ai is the identifier of the photo which got the i-th like.
Output
Print the identifier of the photo which won the elections.
Examples
Input
5
1 3 2 2 1
Output
2
Input
9
100 200 300 200 100 300 300 100 200
Output
300
Note
In the first test sample the photo with id 1 got two likes (first and fifth), photo with id 2 got two likes (third and fourth), and photo with id 3 got one like (second).
Thus, the winner is the photo with identifier 2, as it got:
* more likes than the photo with id 3;
* as many likes as the photo with id 1, but the photo with the identifier 2 got its second like earlier. | instruction | 0 | 28,677 | 14 | 57,354 |
Tags: *special, constructive algorithms, implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = [[], []]
maxl = -1
for i in range(len(a)):
photo = a[i]
if b[0].count(photo) == 0:
b[0].append(photo)
b[1].append(0)
nom = b[0].index(photo)
nom = b[0].index(photo)
b[1][nom] += 1
maxmom = max(b[1])
if maxl < maxmom:
maxl = maxmom
mesto = b[1].index(maxmom)
ans = b[0][mesto]
print(ans)
``` | output | 1 | 28,677 | 14 | 57,355 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After celebrating the midcourse the students of one of the faculties of the Berland State University decided to conduct a vote for the best photo. They published the photos in the social network and agreed on the rules to choose a winner: the photo which gets most likes wins. If multiple photoes get most likes, the winner is the photo that gets this number first.
Help guys determine the winner photo by the records of likes.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the total likes to the published photoes.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 1 000 000), where ai is the identifier of the photo which got the i-th like.
Output
Print the identifier of the photo which won the elections.
Examples
Input
5
1 3 2 2 1
Output
2
Input
9
100 200 300 200 100 300 300 100 200
Output
300
Note
In the first test sample the photo with id 1 got two likes (first and fifth), photo with id 2 got two likes (third and fourth), and photo with id 3 got one like (second).
Thus, the winner is the photo with identifier 2, as it got:
* more likes than the photo with id 3;
* as many likes as the photo with id 1, but the photo with the identifier 2 got its second like earlier. | instruction | 0 | 28,678 | 14 | 57,356 |
Tags: *special, constructive algorithms, implementation
Correct Solution:
```
n = int(input())
likes = list(map(int, input().split(' ')))
max_likes = 0
max_likes_pid = -1
lc = {}
for pid in likes:
lc[pid] = lc.get(pid, 0) + 1
if lc[pid] > max_likes:
max_likes = lc[pid]
max_likes_pid = pid
print(max_likes_pid)
``` | output | 1 | 28,678 | 14 | 57,357 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After celebrating the midcourse the students of one of the faculties of the Berland State University decided to conduct a vote for the best photo. They published the photos in the social network and agreed on the rules to choose a winner: the photo which gets most likes wins. If multiple photoes get most likes, the winner is the photo that gets this number first.
Help guys determine the winner photo by the records of likes.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the total likes to the published photoes.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 1 000 000), where ai is the identifier of the photo which got the i-th like.
Output
Print the identifier of the photo which won the elections.
Examples
Input
5
1 3 2 2 1
Output
2
Input
9
100 200 300 200 100 300 300 100 200
Output
300
Note
In the first test sample the photo with id 1 got two likes (first and fifth), photo with id 2 got two likes (third and fourth), and photo with id 3 got one like (second).
Thus, the winner is the photo with identifier 2, as it got:
* more likes than the photo with id 3;
* as many likes as the photo with id 1, but the photo with the identifier 2 got its second like earlier. | instruction | 0 | 28,679 | 14 | 57,358 |
Tags: *special, constructive algorithms, implementation
Correct Solution:
```
n = int(input())
a = [0]*1000001
m = 0
l = list(map(int, input().split()))
for i in range(n):
a[l[i]] += 1
if a[l[i]] > m:
m = a[l[i]]
j = l[i]
print(j)
``` | output | 1 | 28,679 | 14 | 57,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After celebrating the midcourse the students of one of the faculties of the Berland State University decided to conduct a vote for the best photo. They published the photos in the social network and agreed on the rules to choose a winner: the photo which gets most likes wins. If multiple photoes get most likes, the winner is the photo that gets this number first.
Help guys determine the winner photo by the records of likes.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the total likes to the published photoes.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 1 000 000), where ai is the identifier of the photo which got the i-th like.
Output
Print the identifier of the photo which won the elections.
Examples
Input
5
1 3 2 2 1
Output
2
Input
9
100 200 300 200 100 300 300 100 200
Output
300
Note
In the first test sample the photo with id 1 got two likes (first and fifth), photo with id 2 got two likes (third and fourth), and photo with id 3 got one like (second).
Thus, the winner is the photo with identifier 2, as it got:
* more likes than the photo with id 3;
* as many likes as the photo with id 1, but the photo with the identifier 2 got its second like earlier. | instruction | 0 | 28,680 | 14 | 57,360 |
Tags: *special, constructive algorithms, implementation
Correct Solution:
```
n = int(input())
like = list(map(int , input().split()))
id = 0
A = [0] * 1000005
for i in range(n) :
A[like[i]] += 1
if A[like[i]] > A[id] :
id = like[i]
print(id)
``` | output | 1 | 28,680 | 14 | 57,361 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After celebrating the midcourse the students of one of the faculties of the Berland State University decided to conduct a vote for the best photo. They published the photos in the social network and agreed on the rules to choose a winner: the photo which gets most likes wins. If multiple photoes get most likes, the winner is the photo that gets this number first.
Help guys determine the winner photo by the records of likes.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the total likes to the published photoes.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 1 000 000), where ai is the identifier of the photo which got the i-th like.
Output
Print the identifier of the photo which won the elections.
Examples
Input
5
1 3 2 2 1
Output
2
Input
9
100 200 300 200 100 300 300 100 200
Output
300
Note
In the first test sample the photo with id 1 got two likes (first and fifth), photo with id 2 got two likes (third and fourth), and photo with id 3 got one like (second).
Thus, the winner is the photo with identifier 2, as it got:
* more likes than the photo with id 3;
* as many likes as the photo with id 1, but the photo with the identifier 2 got its second like earlier. | instruction | 0 | 28,681 | 14 | 57,362 |
Tags: *special, constructive algorithms, implementation
Correct Solution:
```
likes_num = int(input())
likes = dict() #{photo_id: [total_likes, last_like_time]}
time = 0
for i in input().split():
if i in likes:
likes[i][0] += 1
likes[i][1] = time
else:
likes[i] = [1, time]
time += 1
max_likes = 0
for key, value in likes.items():
if value[0]>max_likes:
max_likes = value[0]
res = key
elif value[0]==max_likes and likes[res][1]>value[1]:
res = key
print(res)
``` | output | 1 | 28,681 | 14 | 57,363 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After celebrating the midcourse the students of one of the faculties of the Berland State University decided to conduct a vote for the best photo. They published the photos in the social network and agreed on the rules to choose a winner: the photo which gets most likes wins. If multiple photoes get most likes, the winner is the photo that gets this number first.
Help guys determine the winner photo by the records of likes.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the total likes to the published photoes.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 1 000 000), where ai is the identifier of the photo which got the i-th like.
Output
Print the identifier of the photo which won the elections.
Examples
Input
5
1 3 2 2 1
Output
2
Input
9
100 200 300 200 100 300 300 100 200
Output
300
Note
In the first test sample the photo with id 1 got two likes (first and fifth), photo with id 2 got two likes (third and fourth), and photo with id 3 got one like (second).
Thus, the winner is the photo with identifier 2, as it got:
* more likes than the photo with id 3;
* as many likes as the photo with id 1, but the photo with the identifier 2 got its second like earlier. | instruction | 0 | 28,682 | 14 | 57,364 |
Tags: *special, constructive algorithms, implementation
Correct Solution:
```
# n, k = map(int, input().split())
n = int(input())
v = [int(i) for i in input().split()]
mapa = {}
ma = 0
res = -1
for i in v:
if i not in mapa:
mapa[i] = 0
mapa[i] += 1
if mapa[i] > ma:
ma = mapa[i]
res = i
print(res)
``` | output | 1 | 28,682 | 14 | 57,365 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After celebrating the midcourse the students of one of the faculties of the Berland State University decided to conduct a vote for the best photo. They published the photos in the social network and agreed on the rules to choose a winner: the photo which gets most likes wins. If multiple photoes get most likes, the winner is the photo that gets this number first.
Help guys determine the winner photo by the records of likes.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the total likes to the published photoes.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 1 000 000), where ai is the identifier of the photo which got the i-th like.
Output
Print the identifier of the photo which won the elections.
Examples
Input
5
1 3 2 2 1
Output
2
Input
9
100 200 300 200 100 300 300 100 200
Output
300
Note
In the first test sample the photo with id 1 got two likes (first and fifth), photo with id 2 got two likes (third and fourth), and photo with id 3 got one like (second).
Thus, the winner is the photo with identifier 2, as it got:
* more likes than the photo with id 3;
* as many likes as the photo with id 1, but the photo with the identifier 2 got its second like earlier. | instruction | 0 | 28,683 | 14 | 57,366 |
Tags: *special, constructive algorithms, implementation
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
b = [0 for i in range(1000001)]
m = 0
f = 0
for i in range(n):
k = a[i]
b[k] += 1
if b[k] > m:
m = b[k]
f = k
print(f)
``` | output | 1 | 28,683 | 14 | 57,367 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike and !Mike are old childhood rivals, they are opposite in everything they do, except programming. Today they have a problem they cannot solve on their own, but together (with you) — who knows?
Every one of them has an integer sequences a and b of length n. Being given a query of the form of pair of integers (l, r), Mike can instantly tell the value of <image> while !Mike can instantly tell the value of <image>.
Now suppose a robot (you!) asks them all possible different queries of pairs of integers (l, r) (1 ≤ l ≤ r ≤ n) (so he will make exactly n(n + 1) / 2 queries) and counts how many times their answers coincide, thus for how many pairs <image> is satisfied.
How many occasions will the robot count?
Input
The first line contains only integer n (1 ≤ n ≤ 200 000).
The second line contains n integer numbers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the sequence a.
The third line contains n integer numbers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109) — the sequence b.
Output
Print the only integer number — the number of occasions the robot will count, thus for how many pairs <image> is satisfied.
Examples
Input
6
1 2 3 2 1 4
6 7 1 2 3 2
Output
2
Input
3
3 3 3
1 1 1
Output
0
Note
The occasions in the first sample case are:
1.l = 4,r = 4 since max{2} = min{2}.
2.l = 4,r = 5 since max{2, 1} = min{2, 3}.
There are no occasions in the second sample case since Mike will answer 3 to any query pair, but !Mike will always answer 1. | instruction | 0 | 28,708 | 14 | 57,416 |
Tags: binary search, data structures
Correct Solution:
```
from bisect import bisect
HISENTINEL = 10**9 + 1
LOSENTINEL = -HISENTINEL
def main():
length = int(input())
a = [int(fld) for fld in input().strip().split()]
b = [int(fld) for fld in input().strip().split()]
print(countmaxminsubseq(a, b))
def countmaxminsubseq(a, b):
leq, lgt = getleftbounds(a, b, 0)
req, rgt = getleftbounds(reversed(a), reversed(b), 1)
req = reverseindex(req)
rgt = reverseindex(rgt)
count = 0
for i, (leq1, lgt1, req1, rgt1) in enumerate(zip(leq, lgt, req, rgt)):
count += (leq1 - lgt1)*(rgt1 - i) + (i - leq1)*(rgt1 - req1)
return count
def getleftbounds(a, b, bias):
astack = [(HISENTINEL, -1)]
bstack = [(LOSENTINEL, -1)]
leqarr, lgtarr = [], []
for i, (aelt, belt) in enumerate(zip(a, b)):
while astack[-1][0] < aelt + bias:
astack.pop()
lgt = astack[-1][1]
while bstack[-1][0] > belt:
bstack.pop()
if belt < aelt:
leq = lgt = i
elif belt == aelt:
leq = i
istack = bisect(bstack, (aelt, -2)) - 1
lgt = max(lgt, bstack[istack][1])
else:
istack = bisect(bstack, (aelt, i)) - 1
val, pos = bstack[istack]
if val < aelt:
lgt = leq = max(lgt, pos)
else:
leq = pos
istack = bisect(bstack, (aelt, -2)) - 1
val, pos = bstack[istack]
lgt = max(lgt, pos)
leq = max(leq, lgt)
leqarr.append(leq)
lgtarr.append(lgt)
astack.append((aelt, i))
bstack.append((belt, i))
return leqarr, lgtarr
def reverseindex(rind):
pivot = len(rind) - 1
return [pivot - i for i in reversed(rind)]
main()
``` | output | 1 | 28,708 | 14 | 57,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Whereas humans nowadays read fewer and fewer books on paper, book readership among marmots has surged. Heidi has expanded the library and is now serving longer request sequences.
Input
Same as the easy version, but the limits have changed: 1 ≤ n, k ≤ 400 000.
Output
Same as the easy version.
Examples
Input
4 100
1 2 2 1
Output
2
Input
4 1
1 2 2 1
Output
3
Input
4 2
1 2 3 1
Output
3 | instruction | 0 | 28,765 | 14 | 57,530 |
Tags: data structures, greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
from collections import deque, defaultdict
from heapq import heappush, heappop
n, k = map(int, input().split())
A = list(map(int, input().split()))
dic = defaultdict(deque)
for i, a in enumerate(A):
dic[a].append(i)
hp = []
# for d in dic:
# heappush(hp, (-dic[d][0], d))
S = set()
ans = 0
for i, a in enumerate(A):
dic[a].popleft()
if a not in S:
if len(S) < k:
S.add(a)
ans += 1
else:
idx = heappop(hp)[1]
S.discard(idx)
S.add(a)
ans += 1
if dic[a]: heappush(hp, (-dic[a][0], a))
else: heappush(hp, (float("-inf"), a))
print(ans)
``` | output | 1 | 28,765 | 14 | 57,531 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Whereas humans nowadays read fewer and fewer books on paper, book readership among marmots has surged. Heidi has expanded the library and is now serving longer request sequences.
Input
Same as the easy version, but the limits have changed: 1 ≤ n, k ≤ 400 000.
Output
Same as the easy version.
Examples
Input
4 100
1 2 2 1
Output
2
Input
4 1
1 2 2 1
Output
3
Input
4 2
1 2 3 1
Output
3 | instruction | 0 | 28,766 | 14 | 57,532 |
Tags: data structures, greedy
Correct Solution:
```
import sys
import heapq
from collections import namedtuple
Record = namedtuple('Record', ['index', 'book_id'])
l1 = sys.stdin.readline()
l2 = sys.stdin.readline()
n, k = map(int, l1.split(' '))
books = list(map(int, l2.split(' ')))
cost = 0
cache = set()
prev = dict() # book_id -> index
next = [n+1] * n # index of next with the same value
inactive_ids = set() # set of inactive object id()s
book_to_record = dict()
def serve_book(book_id, i):
cache.add(book_id)
record = Record(-next[i], book_id)
heapq.heappush(h, record)
book_to_record[book_id] = record
h = []
for i, book_id in enumerate(books):
if book_id in prev:
next[prev[book_id]] = i
prev[book_id] = i
for i, book_id in enumerate(books):
# print("book_id=%s, h=%s, inactive=%s" %(book_id, h, inactive_ids))
if book_id in cache:
previous_record = book_to_record[book_id]
inactive_ids.add(id(previous_record))
serve_book(book_id, i)
# print('--> Serve book from library ', book_id)
continue
if len(cache) < k:
cost += 1
serve_book(book_id, i)
# print('--> Buy book', book_id)
continue
while True:
item = heapq.heappop(h)
if id(item) in inactive_ids:
# print("--> Ignore record", item)
inactive_ids.remove(id(item))
continue
cache.remove(item.book_id)
serve_book(book_id, i)
cost += 1
# print('--> Throw away book', item.book_id)
# print('--> Add book to libary', book_id)
break
# print("To evict %s" % to_evict)
print(cost)
``` | output | 1 | 28,766 | 14 | 57,533 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Whereas humans nowadays read fewer and fewer books on paper, book readership among marmots has surged. Heidi has expanded the library and is now serving longer request sequences.
Input
Same as the easy version, but the limits have changed: 1 ≤ n, k ≤ 400 000.
Output
Same as the easy version.
Examples
Input
4 100
1 2 2 1
Output
2
Input
4 1
1 2 2 1
Output
3
Input
4 2
1 2 3 1
Output
3 | instruction | 0 | 28,767 | 14 | 57,534 |
Tags: data structures, greedy
Correct Solution:
```
# https://codeforces.com/problemset/problem/802/B
import heapq
n, k = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pos = {}
Q = []
cnt = 0
for i, x in enumerate(a):
if x not in pos:
pos[x] = []
pos[x].append(i)
for i, x in enumerate(a):
if x not in d:
cnt += 1
if len(d) == k:
pos_, x_ = heapq.heappop(Q)
del d[x_]
d[x] = 1
pos[x].pop(0)
if len(pos[x]) > 0:
heapq.heappush(Q, (-pos[x][0], x))
else:
heapq.heappush(Q, (-float('inf'), x))
print(cnt)
``` | output | 1 | 28,767 | 14 | 57,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Whereas humans nowadays read fewer and fewer books on paper, book readership among marmots has surged. Heidi has expanded the library and is now serving longer request sequences.
Input
Same as the easy version, but the limits have changed: 1 ≤ n, k ≤ 400 000.
Output
Same as the easy version.
Examples
Input
4 100
1 2 2 1
Output
2
Input
4 1
1 2 2 1
Output
3
Input
4 2
1 2 3 1
Output
3
Submitted Solution:
```
def book_frequency_histogram(books: list):
book_frequency = {}
for book in books:
if book in book_frequency:
book_frequency[book] += 1
else:
book_frequency[book] = 1
return book_frequency
def is_used_again_later(book_frequency: dict, book: int):
return book_frequency[book] > 1
def remove_max_distance_book():
for last_library_book in reversed(books):
if last_library_book in library:
library.remove(last_library_book)
break
def add_book_if_used_again(library: set, book: int, book_frequency: dict):
if is_used_again_later(book_frequency, book):
library.add(book)
if __name__ == '__main__':
n_books, capacity = map(int, input().strip().split())
books = list(map(int, input().strip().split()))
library = set()
book_frequency = book_frequency_histogram(books)
cost = 0
for book in books:
if len(library) < capacity:
if book not in library:
add_book_if_used_again(library, book, book_frequency)
cost += 1
else:
if book not in library:
remove_max_distance_book()
add_book_if_used_again(library, book, book_frequency)
cost += 1
book_frequency[book] -= 1
print(cost)
``` | instruction | 0 | 28,771 | 14 | 57,542 |
No | output | 1 | 28,771 | 14 | 57,543 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Why I have to finish so many assignments???
Jamie is getting very busy with his school life. He starts to forget the assignments that he has to do. He decided to write the things down on a to-do list. He assigns a value priority for each of his assignment (lower value means more important) so he can decide which he needs to spend more time on.
After a few days, Jamie finds out the list is too large that he can't even manage the list by himself! As you are a good friend of Jamie, help him write a program to support the following operations on the to-do list:
* set ai xi — Add assignment ai to the to-do list if it is not present, and set its priority to xi. If assignment ai is already in the to-do list, its priority is changed to xi.
* remove ai — Remove assignment ai from the to-do list if it is present in it.
* query ai — Output the number of assignments that are more important (have a smaller priority value) than assignment ai, so Jamie can decide a better schedule. Output - 1 if ai is not in the to-do list.
* undo di — Undo all changes that have been made in the previous di days (not including the day of this operation)
At day 0, the to-do list is empty. In each of the following q days, Jamie will do exactly one out of the four operations. If the operation is a query, you should output the result of the query before proceeding to the next day, or poor Jamie cannot make appropriate decisions.
Input
The first line consists of a single integer q (1 ≤ q ≤ 105) — the number of operations.
The following q lines consists of the description of the operations. The i-th line consists of the operation that Jamie has done in the i-th day. The query has the following format:
The first word in the line indicates the type of operation. It must be one of the following four: set, remove, query, undo.
* If it is a set operation, a string ai and an integer xi follows (1 ≤ xi ≤ 109). ai is the assignment that need to be set to priority xi.
* If it is a remove operation, a string ai follows. ai is the assignment that need to be removed.
* If it is a query operation, a string ai follows. ai is the assignment that needs to be queried.
* If it is a undo operation, an integer di follows (0 ≤ di < i). di is the number of days that changes needed to be undone.
All assignment names ai only consists of lowercase English letters and have a length 1 ≤ |ai| ≤ 15.
It is guaranteed that the last operation is a query operation.
Output
For each query operation, output a single integer — the number of assignments that have a priority lower than assignment ai, or - 1 if ai is not in the to-do list.
Interaction
If the operation is a query, you should output the result of the query and flush the output stream before proceeding to the next operation. Otherwise, you may get the verdict Idleness Limit Exceed.
For flushing the output stream, please refer to the documentation of your chosen programming language. The flush functions of some common programming languages are listed below:
* C: fflush(stdout);
* C++: cout « flush;
* Java: System.out.flush();
Examples
Input
8
set chemlabreport 1
set physicsexercise 2
set chinesemockexam 3
query physicsexercise
query chinesemockexam
remove physicsexercise
query physicsexercise
query chinesemockexam
Output
1
2
-1
1
Input
8
set physicsexercise 2
set chinesemockexam 3
set physicsexercise 1
query physicsexercise
query chinesemockexam
undo 4
query physicsexercise
query chinesemockexam
Output
0
1
0
-1
Input
5
query economicsessay
remove economicsessay
query economicsessay
undo 2
query economicsessay
Output
-1
-1
-1
Input
5
set economicsessay 1
remove economicsessay
undo 1
undo 1
query economicsessay
Output
-1
Submitted Solution:
```
#import random, math
outputdebug = False
def debug(msg):
if outputdebug:
print (msg)
class Node():
def __init__(self, key,data,copy = 1):
self.key = key
self.data = data
self.left_count = 1
self.copy =1
self.left = None
self.right = None
class AVLTree():
def __init__(self, *args):
self.node = None
self.height = -1
self.balance = 0;
if len(args) == 1:
for i in args[0]:
self.add(i)
def add(self, key,data = None):
tree = self.node
newnode = Node(key,data)
if tree == None:
self.node = newnode
self.node.left = AVLTree()
self.node.right = AVLTree()
debug("Inserted key [" + str(key) + "]")
elif key < tree.key:
tree.left_count +=1
self.node.left.add(key,data)
elif key > tree.key:
self.node.right.add(key,data)
else:
debug("Key [" + str(key) + "] already in tree.")
self.rebalance()
def find(self,key):
if(self.node != None):
return self._find(key)
else:
return None
def _find(self,key):
if (self.node == None):
return None
elif (key == self.node.key):
return self.node
elif (key < self.node.key ):
return self.node.left._find (key)
elif (key > self.node.key ):
return self.node.right._find (key)
def findImportant(self,key):
if(self.node != None):
return self._findImportant(key)
else:
return None
def _findImportant(self,key, al =0):
if (self.node == None):
return al + self.node.left_count - 1
elif (key == self.node.key):
return al + self.node.left_count - 1
elif (key < self.node.key ):
return self.node.left._findImportant (key, al)
elif (key > self.node.key ):
return self.node.right._findImportant (key, al + self.node.left_count)
def rebalance(self):
'''
Rebalance a particular (sub)tree
'''
# key inserted. Let's check if we're balanced
self.update_heights(False)
self.update_balances(False)
while self.balance < -1 or self.balance > 1:
if self.balance > 1:
if self.node.left.balance < 0:
self.node.left.lrotate() # we're in case II
self.update_heights()
self.update_balances()
self.rrotate()
self.update_heights()
self.update_balances()
if self.balance < -1:
if self.node.right.balance > 0:
self.node.right.rrotate() # we're in case III
self.update_heights()
self.update_balances()
self.lrotate()
self.update_heights()
self.update_balances()
def rrotate(self):
# Rotate left pivoting on self
debug ('Rotating ' + str(self.node.key) + ' right')
A = self.node
B = self.node.left.node
T = B.right.node
self.node = B
B.right.node = A
A.left.node = T
A.left_count = A.left_count - B.left_count
def lrotate(self):
# Rotate left pivoting on self
debug ('Rotating ' + str(self.node.key) + ' left')
A = self.node
B = self.node.right.node
T = B.left.node
self.node = B
B.left.node = A
A.right.node = T
B.left_count = B.left_count + A.left_count
def update_heights(self, recurse=True):
if not self.node == None:
if recurse:
if self.node.left != None:
self.node.left.update_heights()
if self.node.right != None:
self.node.right.update_heights()
self.height = max(self.node.left.height,
self.node.right.height) + 1
else:
self.height = -1
def update_balances(self, recurse=True):
if not self.node == None:
if recurse:
if self.node.left != None:
self.node.left.update_balances()
if self.node.right != None:
self.node.right.update_balances()
self.balance = self.node.left.height - self.node.right.height
else:
self.balance = 0
def delete(self, key):
# debug("Trying to delete at node: " + str(self.node.key))
if self.node != None:
if self.node.key == key:
debug("Deleting ... " + str(key))
if self.node.left.node == None and self.node.right.node == None:
self.node = None # leaves can be killed at will
# if only one subtree, take that
elif self.node.left.node == None:
self.node = self.node.right.node
elif self.node.right.node == None:
self.node = self.node.left.node
# worst-case: both children present. Find logical successor
else:
replacement = self.logical_successor(self.node)
if replacement != None: # sanity check
debug("Found replacement for " + str(key) + " -> " + str(replacement.key))
self.node.key = replacement.key
self.node.data = replacement.data
# replaced. Now delete the key from right child
self.node.right.delete(replacement.key)
self.rebalance()
return
elif key < self.node.key:
self.node.left_count -=1
self.node.left.delete(key)
elif key > self.node.key:
self.node.right.delete(key)
self.rebalance()
else:
return
def logical_successor(self, node):
'''
Find the smallese valued node in RIGHT child
'''
node = node.right.node
if node != None: # just a sanity check
while node.left != None:
debug("LS: traversing: " + str(node.key))
if node.left.node == None:
return node
else:
node = node.left.node
return node
def check_balanced(self):
if self == None or self.node == None:
return True
# We always need to make sure we are balanced
self.update_heights()
self.update_balances()
return ((abs(self.balance) < 2) and self.node.left.check_balanced() and self.node.right.check_balanced())
tree = [AVLTree()]
n= int(input())
tasks = [{}]
import copy
for i in range(1,n + 1):
try:
req = input().strip().split()
if req[0] == "set":
tasks.append(tasks[i-1].copy())
tree.append(copy.copy(tree[i-1]))
if req[1] not in tasks[i]:
exs = tree[i].find(int(req[2]))
if exs== None:
tree[i].add(int(req[2]),req[1])
else:
exs.copy += 1
else:
exs = tree[i].find(tasks[i][req[1]])
if exs == None:
print("WTF")
else:
if exs.copy == 1:
tree[i].delete(tasks[i][req[1]])
else:
exs.copy -= 1
tree[i].add(int(req[2]),req[1])
tasks[i][req[1]] = int(req[2])
elif req[0] == "query":
tasks.append(tasks[i-1].copy())
tree.append(copy.copy(tree[i-1]))
if req[1] in tasks[i]:
print(tree[i].findImportant(tasks[i][req[1]]))
else:
print(-1)
elif req[0] == "remove":
tasks.append(tasks[i-1].copy())
tree.append(copy.copy(tree[i-1]))
if req[1] in tasks[i]:
exs = tree[i].find(tasks[i][req[1]])
if exs == None:
pass
else:
if exs.copy == 1 :
tree[i].delete(tasks[i][req[1]])
else:
exs.copy -=1
del tasks[i][req[1]]
else:
tasks.append( tasks[i - int(req[1]) - 1].copy())
tree.append(copy.copy(tree[ i - int(req[1]) - 1]))
except Exception as inst:
print(inst)
``` | instruction | 0 | 28,792 | 14 | 57,584 |
No | output | 1 | 28,792 | 14 | 57,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Why I have to finish so many assignments???
Jamie is getting very busy with his school life. He starts to forget the assignments that he has to do. He decided to write the things down on a to-do list. He assigns a value priority for each of his assignment (lower value means more important) so he can decide which he needs to spend more time on.
After a few days, Jamie finds out the list is too large that he can't even manage the list by himself! As you are a good friend of Jamie, help him write a program to support the following operations on the to-do list:
* set ai xi — Add assignment ai to the to-do list if it is not present, and set its priority to xi. If assignment ai is already in the to-do list, its priority is changed to xi.
* remove ai — Remove assignment ai from the to-do list if it is present in it.
* query ai — Output the number of assignments that are more important (have a smaller priority value) than assignment ai, so Jamie can decide a better schedule. Output - 1 if ai is not in the to-do list.
* undo di — Undo all changes that have been made in the previous di days (not including the day of this operation)
At day 0, the to-do list is empty. In each of the following q days, Jamie will do exactly one out of the four operations. If the operation is a query, you should output the result of the query before proceeding to the next day, or poor Jamie cannot make appropriate decisions.
Input
The first line consists of a single integer q (1 ≤ q ≤ 105) — the number of operations.
The following q lines consists of the description of the operations. The i-th line consists of the operation that Jamie has done in the i-th day. The query has the following format:
The first word in the line indicates the type of operation. It must be one of the following four: set, remove, query, undo.
* If it is a set operation, a string ai and an integer xi follows (1 ≤ xi ≤ 109). ai is the assignment that need to be set to priority xi.
* If it is a remove operation, a string ai follows. ai is the assignment that need to be removed.
* If it is a query operation, a string ai follows. ai is the assignment that needs to be queried.
* If it is a undo operation, an integer di follows (0 ≤ di < i). di is the number of days that changes needed to be undone.
All assignment names ai only consists of lowercase English letters and have a length 1 ≤ |ai| ≤ 15.
It is guaranteed that the last operation is a query operation.
Output
For each query operation, output a single integer — the number of assignments that have a priority lower than assignment ai, or - 1 if ai is not in the to-do list.
Interaction
If the operation is a query, you should output the result of the query and flush the output stream before proceeding to the next operation. Otherwise, you may get the verdict Idleness Limit Exceed.
For flushing the output stream, please refer to the documentation of your chosen programming language. The flush functions of some common programming languages are listed below:
* C: fflush(stdout);
* C++: cout « flush;
* Java: System.out.flush();
Examples
Input
8
set chemlabreport 1
set physicsexercise 2
set chinesemockexam 3
query physicsexercise
query chinesemockexam
remove physicsexercise
query physicsexercise
query chinesemockexam
Output
1
2
-1
1
Input
8
set physicsexercise 2
set chinesemockexam 3
set physicsexercise 1
query physicsexercise
query chinesemockexam
undo 4
query physicsexercise
query chinesemockexam
Output
0
1
0
-1
Input
5
query economicsessay
remove economicsessay
query economicsessay
undo 2
query economicsessay
Output
-1
-1
-1
Input
5
set economicsessay 1
remove economicsessay
undo 1
undo 1
query economicsessay
Output
-1
Submitted Solution:
```
import sys
q = int(input())
untilnow = []
list = []
priorities = []
for i in range(0, q):
test = 1
line = input()
if line[0] == 's':
a, b, c = line.split()
c = int(c)
for j in range(0, len(list)):
if b == list[j]:
priorities[j] = c
test = 0
break
if test:
list.append(b)
priorities.append(c)
if line[0] == 'r':
a, b = line.split()
for j in range(0, len(list)):
if b == list[j]:
priorities.pop(j)
list.pop(j)
break
if line[0] == 'q':
a, b = line.split()
pr = 0
counter = 0
for j in range(0, len(list)):
if b == list[j]:
pr = priorities[j]
break
if pr == 0:
print(-1)
sys.stdout.flush()
test = 0
for j in range(0, len(list)):
if pr > priorities[j]:
counter += 1
if test:
print(counter)
sys.stdout.flush()
if line[0] == 'u':
a, b = line.split()
b = int(b)
list, priorities = untilnow[i - b - 1]
# print(list, priorities)
untilnow.append((list[:], priorities[:]))
``` | instruction | 0 | 28,793 | 14 | 57,586 |
No | output | 1 | 28,793 | 14 | 57,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Why I have to finish so many assignments???
Jamie is getting very busy with his school life. He starts to forget the assignments that he has to do. He decided to write the things down on a to-do list. He assigns a value priority for each of his assignment (lower value means more important) so he can decide which he needs to spend more time on.
After a few days, Jamie finds out the list is too large that he can't even manage the list by himself! As you are a good friend of Jamie, help him write a program to support the following operations on the to-do list:
* set ai xi — Add assignment ai to the to-do list if it is not present, and set its priority to xi. If assignment ai is already in the to-do list, its priority is changed to xi.
* remove ai — Remove assignment ai from the to-do list if it is present in it.
* query ai — Output the number of assignments that are more important (have a smaller priority value) than assignment ai, so Jamie can decide a better schedule. Output - 1 if ai is not in the to-do list.
* undo di — Undo all changes that have been made in the previous di days (not including the day of this operation)
At day 0, the to-do list is empty. In each of the following q days, Jamie will do exactly one out of the four operations. If the operation is a query, you should output the result of the query before proceeding to the next day, or poor Jamie cannot make appropriate decisions.
Input
The first line consists of a single integer q (1 ≤ q ≤ 105) — the number of operations.
The following q lines consists of the description of the operations. The i-th line consists of the operation that Jamie has done in the i-th day. The query has the following format:
The first word in the line indicates the type of operation. It must be one of the following four: set, remove, query, undo.
* If it is a set operation, a string ai and an integer xi follows (1 ≤ xi ≤ 109). ai is the assignment that need to be set to priority xi.
* If it is a remove operation, a string ai follows. ai is the assignment that need to be removed.
* If it is a query operation, a string ai follows. ai is the assignment that needs to be queried.
* If it is a undo operation, an integer di follows (0 ≤ di < i). di is the number of days that changes needed to be undone.
All assignment names ai only consists of lowercase English letters and have a length 1 ≤ |ai| ≤ 15.
It is guaranteed that the last operation is a query operation.
Output
For each query operation, output a single integer — the number of assignments that have a priority lower than assignment ai, or - 1 if ai is not in the to-do list.
Interaction
If the operation is a query, you should output the result of the query and flush the output stream before proceeding to the next operation. Otherwise, you may get the verdict Idleness Limit Exceed.
For flushing the output stream, please refer to the documentation of your chosen programming language. The flush functions of some common programming languages are listed below:
* C: fflush(stdout);
* C++: cout « flush;
* Java: System.out.flush();
Examples
Input
8
set chemlabreport 1
set physicsexercise 2
set chinesemockexam 3
query physicsexercise
query chinesemockexam
remove physicsexercise
query physicsexercise
query chinesemockexam
Output
1
2
-1
1
Input
8
set physicsexercise 2
set chinesemockexam 3
set physicsexercise 1
query physicsexercise
query chinesemockexam
undo 4
query physicsexercise
query chinesemockexam
Output
0
1
0
-1
Input
5
query economicsessay
remove economicsessay
query economicsessay
undo 2
query economicsessay
Output
-1
-1
-1
Input
5
set economicsessay 1
remove economicsessay
undo 1
undo 1
query economicsessay
Output
-1
Submitted Solution:
```
q = int(input())
base = {}
undoCount = 0
for i in range(q):
req = input()
if req[:3]=="set":
cmd, key, pr = req.split()
if not key in base:
base[key] = [(-1,0),(int(pr),i)]
else:
base[key].append((int(pr),i))
elif req[:6]=="remove":
cmd, key = req.split()
if key in base:
base[key].append((-1,i))
elif req[:5]=="query":
cmd, key = req.split()
if key in base:
if base[key][-1][0] == -1:
print(-1)
else:
max = base[key][-1][0]
sum = 0
for j in base:
if base[j][-1][0] != -1 and base[j][-1][0]<max:
sum += 1
print(sum)
else:
print(-1)
elif req[:4]=="undo":
undoCount += 1
cmd, n = req.split()
max = i - int(n) - undoCount
for key in base:
tmp = [(-1,0)]
for undoData in base[key]:
if undoData[1] < max:
tmp.append(undoData)
base[key] = tmp
``` | instruction | 0 | 28,794 | 14 | 57,588 |
No | output | 1 | 28,794 | 14 | 57,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Why I have to finish so many assignments???
Jamie is getting very busy with his school life. He starts to forget the assignments that he has to do. He decided to write the things down on a to-do list. He assigns a value priority for each of his assignment (lower value means more important) so he can decide which he needs to spend more time on.
After a few days, Jamie finds out the list is too large that he can't even manage the list by himself! As you are a good friend of Jamie, help him write a program to support the following operations on the to-do list:
* set ai xi — Add assignment ai to the to-do list if it is not present, and set its priority to xi. If assignment ai is already in the to-do list, its priority is changed to xi.
* remove ai — Remove assignment ai from the to-do list if it is present in it.
* query ai — Output the number of assignments that are more important (have a smaller priority value) than assignment ai, so Jamie can decide a better schedule. Output - 1 if ai is not in the to-do list.
* undo di — Undo all changes that have been made in the previous di days (not including the day of this operation)
At day 0, the to-do list is empty. In each of the following q days, Jamie will do exactly one out of the four operations. If the operation is a query, you should output the result of the query before proceeding to the next day, or poor Jamie cannot make appropriate decisions.
Input
The first line consists of a single integer q (1 ≤ q ≤ 105) — the number of operations.
The following q lines consists of the description of the operations. The i-th line consists of the operation that Jamie has done in the i-th day. The query has the following format:
The first word in the line indicates the type of operation. It must be one of the following four: set, remove, query, undo.
* If it is a set operation, a string ai and an integer xi follows (1 ≤ xi ≤ 109). ai is the assignment that need to be set to priority xi.
* If it is a remove operation, a string ai follows. ai is the assignment that need to be removed.
* If it is a query operation, a string ai follows. ai is the assignment that needs to be queried.
* If it is a undo operation, an integer di follows (0 ≤ di < i). di is the number of days that changes needed to be undone.
All assignment names ai only consists of lowercase English letters and have a length 1 ≤ |ai| ≤ 15.
It is guaranteed that the last operation is a query operation.
Output
For each query operation, output a single integer — the number of assignments that have a priority lower than assignment ai, or - 1 if ai is not in the to-do list.
Interaction
If the operation is a query, you should output the result of the query and flush the output stream before proceeding to the next operation. Otherwise, you may get the verdict Idleness Limit Exceed.
For flushing the output stream, please refer to the documentation of your chosen programming language. The flush functions of some common programming languages are listed below:
* C: fflush(stdout);
* C++: cout « flush;
* Java: System.out.flush();
Examples
Input
8
set chemlabreport 1
set physicsexercise 2
set chinesemockexam 3
query physicsexercise
query chinesemockexam
remove physicsexercise
query physicsexercise
query chinesemockexam
Output
1
2
-1
1
Input
8
set physicsexercise 2
set chinesemockexam 3
set physicsexercise 1
query physicsexercise
query chinesemockexam
undo 4
query physicsexercise
query chinesemockexam
Output
0
1
0
-1
Input
5
query economicsessay
remove economicsessay
query economicsessay
undo 2
query economicsessay
Output
-1
-1
-1
Input
5
set economicsessay 1
remove economicsessay
undo 1
undo 1
query economicsessay
Output
-1
Submitted Solution:
```
#import random, math
outputdebug = False
def debug(msg):
if outputdebug:
print (msg)
class Node():
def __init__(self, key,data):
self.key = key
self.data = data
self.left_count = 1
self.left = None
self.right = None
class AVLTree():
def __init__(self, *args):
self.node = None
self.height = -1
self.balance = 0;
if len(args) == 1:
for i in args[0]:
self.add(i)
def height(self):
if self.node:
return self.node.height
else:
return 0
def is_leaf(self):
return (self.height == 0)
def add(self, key,data = None):
tree = self.node
newnode = Node(key,data)
if tree == None:
self.node = newnode
self.node.left = AVLTree()
self.node.right = AVLTree()
debug("Inserted key [" + str(key) + "]")
elif key < tree.key:
tree.left_count +=1
self.node.left.add(key,data)
elif key > tree.key:
self.node.right.add(key,data)
else:
debug("Key [" + str(key) + "] already in tree.")
self.rebalance()
def find(self,key):
if(self.node != None):
return self._find(key)
else:
return None
def _find(self,key):
if (key == self.node.key):
return self.node
elif (key < self.node.key and self.node.left !=None):
return self.node.left._find (key)
elif (key > self.node.key and self.node.right != None):
return self.node.right._find (key)
def findImportant(self,key):
if(self.node != None):
return self._findImportant(key)
else:
return None
def _findImportant(self,key, al =0):
if (key == self.node.key):
return al + self.node.left_count - 1
elif (key < self.node.key and self.node.left !=None):
return self.node.left._findImportant (key, al)
elif (key > self.node.key and self.node.right != None):
return self.node.right._findImportant (key, al + self.node.left_count)
def rebalance(self):
'''
Rebalance a particular (sub)tree
'''
# key inserted. Let's check if we're balanced
self.update_heights(False)
self.update_balances(False)
while self.balance < -1 or self.balance > 1:
if self.balance > 1:
if self.node.left.balance < 0:
self.node.left.lrotate() # we're in case II
self.update_heights()
self.update_balances()
self.rrotate()
self.update_heights()
self.update_balances()
if self.balance < -1:
if self.node.right.balance > 0:
self.node.right.rrotate() # we're in case III
self.update_heights()
self.update_balances()
self.lrotate()
self.update_heights()
self.update_balances()
def rrotate(self):
# Rotate left pivoting on self
debug ('Rotating ' + str(self.node.key) + ' right')
A = self.node
B = self.node.left.node
T = B.right.node
self.node = B
B.right.node = A
A.left.node = T
A.left_count = A.left_count - B.left_count
def lrotate(self):
# Rotate left pivoting on self
debug ('Rotating ' + str(self.node.key) + ' left')
A = self.node
B = self.node.right.node
T = B.left.node
self.node = B
B.left.node = A
A.right.node = T
B.left_count = B.left_count + A.left_count
def update_heights(self, recurse=True):
if not self.node == None:
if recurse:
if self.node.left != None:
self.node.left.update_heights()
if self.node.right != None:
self.node.right.update_heights()
self.height = max(self.node.left.height,
self.node.right.height) + 1
else:
self.height = -1
def update_balances(self, recurse=True):
if not self.node == None:
if recurse:
if self.node.left != None:
self.node.left.update_balances()
if self.node.right != None:
self.node.right.update_balances()
self.balance = self.node.left.height - self.node.right.height
else:
self.balance = 0
def delete(self, key):
# debug("Trying to delete at node: " + str(self.node.key))
if self.node != None:
if self.node.key == key:
debug("Deleting ... " + str(key))
if self.node.left.node == None and self.node.right.node == None:
self.node = None # leaves can be killed at will
# if only one subtree, take that
elif self.node.left.node == None:
self.node = self.node.right.node
elif self.node.right.node == None:
self.node = self.node.left.node
# worst-case: both children present. Find logical successor
else:
replacement = self.logical_successor(self.node)
if replacement != None: # sanity check
debug("Found replacement for " + str(key) + " -> " + str(replacement.key))
self.node.key = replacement.key
self.node.data = replacement.data
# replaced. Now delete the key from right child
self.node.right.delete(replacement.key)
self.rebalance()
return
elif key < self.node.key:
self.node.left_count -=1
self.node.left.delete(key)
elif key > self.node.key:
self.node.right.delete(key)
self.rebalance()
else:
return
def logical_predecessor(self, node):
'''
Find the biggest valued node in LEFT child
'''
node = node.left.node
if node != None:
while node.right != None:
if node.right.node == None:
return node
else:
node = node.right.node
return node
def logical_successor(self, node):
'''
Find the smallese valued node in RIGHT child
'''
node = node.right.node
if node != None: # just a sanity check
while node.left != None:
debug("LS: traversing: " + str(node.key))
if node.left.node == None:
return node
else:
node = node.left.node
return node
def check_balanced(self):
if self == None or self.node == None:
return True
# We always need to make sure we are balanced
self.update_heights()
self.update_balances()
return ((abs(self.balance) < 2) and self.node.left.check_balanced() and self.node.right.check_balanced())
def inorder_traverse(self):
if self.node == None:
return []
inlist = []
l = self.node.left.inorder_traverse()
for i in l:
inlist.append(i)
inlist.append(self.node.key)
l = self.node.right.inorder_traverse()
for i in l:
inlist.append(i)
return inlist
tree = [AVLTree()]
n= int(input())
tasks = [{}]
import copy
for i in range(1,n + 1):
req = input().strip().split()
if req[0] == "set":
tasks.append(tasks[i-1].copy())
tree.append(copy.copy(tree[i-1]))
if req[1] not in tasks[i]:
tree[i].add(int(req[2]),req[1])
else:
tree[i].delete(tasks[i][req[1]])
tree[i].add(int(req[2]),req[1])
tasks[i][req[1]] = int(req[2])
elif req[0] == "query":
tasks.append(tasks[i-1].copy())
tree.append(copy.copy(tree[i-1]))
if req[1] in tasks[i]:
print(tree[i].findImportant(tasks[i][req[1]]),tasks[i],
tree[i].node.left.node,tree[i].node.right.node)
else:
print(-1)
elif req[0] == "remove":
tasks.append(tasks[i-1].copy())
tree.append(copy.copy(tree[i-1]))
if req[1] in tasks[i]:
tree[i].delete(tasks[i][req[1]])
del tasks[i][req[1]]
else:
tasks.append( tasks[i - int(req[1]) - 1].copy())
tree.append(copy.copy(tree[ i - int(req[1]) - 1]))
``` | instruction | 0 | 28,795 | 14 | 57,590 |
No | output | 1 | 28,795 | 14 | 57,591 |
Provide a correct Python 3 solution for this coding contest problem.
Problem Statement
We have planted $N$ flower seeds, all of which come into different flowers. We want to make all the flowers come out together.
Each plant has a value called vitality, which is initially zero. Watering and spreading fertilizers cause changes on it, and the $i$-th plant will come into flower if its vitality is equal to or greater than $\mathit{th}_i$. Note that $\mathit{th}_i$ may be negative because some flowers require no additional nutrition.
Watering effects on all the plants. Watering the plants with $W$ liters of water changes the vitality of the $i$-th plant by $W \times \mathit{vw}_i$ for all $i$ ($1 \le i \le n$), and costs $W \times \mathit{pw}$ yen, where $W$ need not be an integer. $\mathit{vw}_i$ may be negative because some flowers hate water.
We have $N$ kinds of fertilizers, and the $i$-th fertilizer effects only on the $i$-th plant. Spreading $F_i$ kilograms of the $i$-th fertilizer changes the vitality of the $i$-th plant by $F_i \times \mathit{vf}_i$, and costs $F_i \times \mathit{pf}_i$ yen, where $F_i$ need not be an integer as well. Each fertilizer is specially made for the corresponding plant, therefore $\mathit{vf}_i$ is guaranteed to be positive.
Of course, we also want to minimize the cost. Formally, our purpose is described as "to minimize $W \times \mathit{pw} + \sum_{i=1}^{N}(F_i \times \mathit{pf}_i)$ under $W \times \mathit{vw}_i + F_i \times \mathit{vf}_i \ge \mathit{th}_i$, $W \ge 0$, and $F_i \ge 0$ for all $i$ ($1 \le i \le N$)". Your task is to calculate the minimum cost.
Input
The input consists of multiple datasets. The number of datasets does not exceed $100$, and the data size of the input does not exceed $20\mathrm{MB}$. Each dataset is formatted as follows.
> $N$
> $\mathit{pw}$
> $\mathit{vw}_1$ $\mathit{pf}_1$ $\mathit{vf}_1$ $\mathit{th}_1$
> :
> :
> $\mathit{vw}_N$ $\mathit{pf}_N$ $\mathit{vf}_N$ $\mathit{th}_N$
The first line of a dataset contains a single integer $N$, number of flower seeds. The second line of a dataset contains a single integer $\mathit{pw}$, cost of watering one liter. Each of the following $N$ lines describes a flower. The $i$-th line contains four integers, $\mathit{vw}_i$, $\mathit{pf}_i$, $\mathit{vf}_i$, and $\mathit{th}_i$, separated by a space.
You can assume that $1 \le N \le 10^5$, $1 \le \mathit{pw} \le 100$, $-100 \le \mathit{vw}_i \le 100$, $1 \le \mathit{pf}_i \le 100$, $1 \le \mathit{vf}_i \le 100$, and $-100 \le \mathit{th}_i \le 100$.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, output a line containing the minimum cost to make all the flowers come out. The output must have an absolute or relative error at most $10^{-4}$.
Sample Input
3
10
4 3 4 10
5 4 5 20
6 5 6 30
3
7
-4 3 4 -10
5 4 5 20
6 5 6 30
3
1
-4 3 4 -10
-5 4 5 -20
6 5 6 30
3
10
-4 3 4 -10
-5 4 5 -20
-6 5 6 -30
0
Output for the Sample Input
43.5
36
13.5
0
Example
Input
3
10
4 3 4 10
5 4 5 20
6 5 6 30
3
7
-4 3 4 -10
5 4 5 20
6 5 6 30
3
1
-4 3 4 -10
-5 4 5 -20
6 5 6 30
3
10
-4 3 4 -10
-5 4 5 -20
-6 5 6 -30
0
Output
43.5
36
13.5
0 | instruction | 0 | 29,059 | 14 | 58,118 |
"Correct Solution:
```
import sys
def main():
readline = sys.stdin.readline
write = sys.stdout.write
def gcd(m, n):
while n:
m, n = n, m % n
return m
def init(p, q=1):
g = gcd(p, q)
return p//g, q//g
def add(A, B):
pa, qa = A
pb, qb = B
if pa == 0:
return B
if pb == 0:
return A
g = gcd(qa, qb)
ra = pa*qb//g + pb*qa//g; rb = qa*qb//g
g = gcd(ra, rb)
return ra // g, rb // g
INF = 10**18
def cp(X):
vw, pf, vf, th = X
if vw == 0:
return INF
return th/vw
while 1:
N = int(readline())
if N == 0:
break
pw = int(readline())
P = [list(map(int, readline().split())) for i in range(N)]
P.append((1, 0, 1, 0))
P.sort(key=cp)
A = [init(0)]*(N+1)
B = [init(0)]*(N+1)
a = b = init(0)
a = init(pw)
for i, (vw, pf, vf, th) in enumerate(P):
if vw == 0:
if th > 0:
b = add(b, (th*pf, vf))
continue
if vw > 0:
if th^vw >= 0:
a = add(a, (-vw*pf, vf))
b = add(b, (th*pf, vf))
A[i] = init(vw*pf, vf)
B[i] = init(-th*pf, vf)
else:
if th^vw >= 0:
A[i] = init(-vw*pf, vf)
B[i] = init(th*pf, vf)
else:
a = add(a, (-vw*pf, vf))
b = add(b, (th*pf, vf))
ans = INF
for i, (vw, pf, vf, th) in enumerate(P):
if vw == 0:
continue
if th^vw < 0:
continue
a = add(a, A[i]); b = add(b, B[i])
pa, qa = a; pb, qb = b
v = (pa*th*qb + pb*vw*qa) / (vw * qa * qb)
if ans + 0.01 < v:
break
ans = min(ans, v)
write("%.016f\n" % ans)
main()
``` | output | 1 | 29,059 | 14 | 58,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19. | instruction | 0 | 29,135 | 14 | 58,270 |
Tags: implementation, math
Correct Solution:
```
q=int(input())
for i in range(q):
ans=[]
q=True
n,x,y,d=map(int,input().split())
if abs(x-y)%d==0:
ans.append(abs(x-y)//d)
q=False
if (y-1)%d==0:
ans.append((y-1)//d+int((x-1)/d+0.99999999999999))
q=False
if (n-y)%d==0:
ans.append((n-y)//d+int((n-x)/d+0.99999999999999))
q=False
if q:
ans.append(-1)
print(min(ans))
``` | output | 1 | 29,135 | 14 | 58,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19. | instruction | 0 | 29,136 | 14 | 58,272 |
Tags: implementation, math
Correct Solution:
```
def retarray():
return list(map(int, input().split()))
t = int(input())
for _ in range(t):
n, x, y, d = retarray()
res = -1
if abs(x-y) % d == 0 :
res = abs(x-y)//d
else:
if (y - 1) % d == 0 :
res = x//d + (y-1)//d + (1 if x%d else 0)
if (n - y) % d == 0:
if not res == -1:
res = min((n-y)//d + (n-x)//d + (1 if (n-x)%d else 0), res)
else:
res = (n-y)//d + (n-x)//d + (1 if (n-x)%d else 0)
print(res)
``` | output | 1 | 29,136 | 14 | 58,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19. | instruction | 0 | 29,137 | 14 | 58,274 |
Tags: implementation, math
Correct Solution:
```
def do():
import math
n,x,y,d = map(int, input().split())
x-=1
y-=1
n-=1
res = 10 ** 18
if x==y:
print(0)
return
if (y-x) % d == 0:
print(abs((y-x)) // d)
return
cnt = 0
cnt = math.ceil(x / d)
if y % d == 0:
cnt += abs(y // d)
res = min(res, cnt)
cnt = 0
cnt = math.ceil((n-x) / d)
if (n-y) % d == 0:
cnt += abs((n-y) // d)
res = min(res, cnt)
if res == 10**18:
print(-1)
return
else:
print(res)
return
qq = int(input())
for _ in range(qq):
do()
``` | output | 1 | 29,137 | 14 | 58,275 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19. | instruction | 0 | 29,138 | 14 | 58,276 |
Tags: implementation, math
Correct Solution:
```
from math import ceil
n = int(input())
for i in range(n):
n, x, y, d = list(map(int, input().split()))
max_num = 10 ** 10
if abs(y - x) % d == 0:
max_num = abs(y - x) // d
if y % d == 1:
a = ceil(x / d) + (y - 1) // d
if a < max_num:
max_num = a
if y % d == n % d:
a = ceil((n - x) / d) + (n - y + 1) // d
if a < max_num:
max_num = a
if max_num == 10 ** 10:
print(-1)
else:
print(max_num)
``` | output | 1 | 29,138 | 14 | 58,277 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19. | instruction | 0 | 29,139 | 14 | 58,278 |
Tags: implementation, math
Correct Solution:
```
m=int(input())
for i in range(0,m):
l = 0
n,x,y,d=map(int,input().split())
a = 7289567892756268
b = 11111111111111111
c = 1000000000000000
w = 0
if x > y:
w = (x - y)
else:
w = (y - x)
if w % d == 0:
a = w // d
l = l + 1
if (y - 1) % d == 0:
if (x - 1) % d == 0:
b = ((y - 1) // d) + ((x - 1) // d)
l = l + 1
else:
b =((y - 1) // d) + ((x - 1) // d) + 1
l = l + 1
if (n - y) % d == 0:
if (n - x) % d == 0:
c =((n - y) // d) + ((n - x) // d)
l = l + 1
else:
c =((n - y) // d) + ((n - x) // d) + 1
l = l + 1
if l == 0:
print(-1)
else:
print(min(a,b,c))
``` | output | 1 | 29,139 | 14 | 58,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19. | instruction | 0 | 29,140 | 14 | 58,280 |
Tags: implementation, math
Correct Solution:
```
t=int(input())
for i in range(0,t):
n,x,y,d=map(int,input().split())
if(abs(y-x)%d==0):
print(abs(y-x)//d)
else:
if((y-1)%d==0 or (n-y)%d==0):
if((y-1)%d==0 and (n-y)%d==0):
print(min(((x-1)//d+bool((x-1)%d)+(y-1)//d,(n-x)//d+bool((n-x)%d)+(n-y)//d)))
else:
if((y-1)%d==0): print(((x-1)//d+bool((x-1)%d)+(y-1)//d))
else: print((n-x)//d+bool((n-x)%d)+(n-y)//d)
else: print(-1)
``` | output | 1 | 29,140 | 14 | 58,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19. | instruction | 0 | 29,141 | 14 | 58,282 |
Tags: implementation, math
Correct Solution:
```
import math
def solve(n,x,y,d):
vals = []
if (y-x)%d==0:
vals.append(abs(y-x)//d)
if y%d==1:
# down
moves = math.ceil((x-1)/d)
# up
moves += (y-1)//d
vals.append(moves)
if (n-y)%d==0:
# up
moves = math.ceil((n-x)/d)
# down
moves += (n-y)//d
vals.append(moves)
if vals:
return min(vals)
else:
return -1
t = int(input())
for _ in range(t):
n, x, y, d = map(int, input().split())
print(solve(n,x,y,d))
``` | output | 1 | 29,141 | 14 | 58,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19. | instruction | 0 | 29,142 | 14 | 58,284 |
Tags: implementation, math
Correct Solution:
```
from math import ceil
n = int(input())
for i in range(n):
n,x,y,d = map(int,input().split())
ans1 = ans2 = 10**18
dist = abs(x-y)
if dist%d==0:
print(dist//d)
elif (y-1)%d and (n-y)%d:
print(-1)
else:
if (y-1)%d==0:
ans1 = (y-1)//d + (x-1)//d + (1 if (x-1)%d else 0)
if (n-y)%d==0:
ans2 = (n-y)//d + (n-x)//d + (1 if (n-x)%d else 0)
print(min(ans1,ans2))
``` | output | 1 | 29,142 | 14 | 58,285 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19.
Submitted Solution:
```
t=int(input())
for i in range(t):
n,x,y,d=map(int,input().split())
if abs(x-y)%d==0:
print(abs(x-y)//d)
else:
res=10000000000
if (y-1)%d==0:
res=min(res,-(-(x-1)//d)+(y-1)//d)
if (n-y)%d==0:
res=min(res,-(-(n-x)//d)+(n-y)//d)
if res==10000000000:
res=-1
print(res)
``` | instruction | 0 | 29,143 | 14 | 58,286 |
Yes | output | 1 | 29,143 | 14 | 58,287 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19.
Submitted Solution:
```
import math
t=int(input())
for i in range(t):
a=10**90
b=10**90
n,x,y,d=[int(x) for x in input().split()]
if abs(y-x)%d==0:
print(abs(x-y)//d)
else:
if (y-1)%d==0:
a=math.ceil((x-1)/d)+math.ceil((y-1)//d)
if (n-y)%d==0:
b=math.ceil((n-y)/d)+math.ceil((n-x)/d)
if a!=10**90 or b!=10**90:
print(min(a,b))
else:
print(-1)
``` | instruction | 0 | 29,144 | 14 | 58,288 |
Yes | output | 1 | 29,144 | 14 | 58,289 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19.
Submitted Solution:
```
import math
# lst = list(map(str, input().strip().split(' ')))
t=int(input())
for i in range(t):
n,x,y,d = map(int, input().strip().split(' '))
if y==x:
print(0)
else:
if abs((y-x))%d==0:
print(abs(y-x)//d)
else:
if (y-1)%d!=0 and (n-y)%d!=0:
print('-1')
elif (y-1)%d!=0:
k = math.ceil((n-y)/d) + math.ceil((n-x)/d)
print(k)
elif (n-y)%d!=0:
k = math.ceil((y-1)/d) + math.ceil((x-1)/d)
print(k)
else:
k=min(math.ceil((n-y)/d) + math.ceil((n-x)/d),math.ceil((y-1)/d) + math.ceil((x-1)/d ))
print(k)
``` | instruction | 0 | 29,145 | 14 | 58,290 |
Yes | output | 1 | 29,145 | 14 | 58,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19.
Submitted Solution:
```
count = int(input())
cases = []
for i in range(count):
lst = [int(x) for x in input().split()]
cases.append(lst)
import math
# use math
'''
10 4 5 2
10 4 5 4
if not directly-- need to bounce at each end
that is bounce at 1 or n
so check
'''
def count_steps(n, x, y, d):
if not (y - x) % d:
return dis(x, y, d)
if (y - 1) % d and (n - y) % d:
return -1
left, right = float('inf'), float('inf')
if not (y - 1) % d:
left = dis(x, 1, d) + dis(y, 1, d)
if not (n - y) % d:
right = dis(n, x, d) + dis(n, y, d)
return min(left, right)
def dis(x, y, d):
return math.ceil(abs(x-y)/d)
for n, x, y, d in cases:
print(count_steps(n, x, y, d))
``` | instruction | 0 | 29,146 | 14 | 58,292 |
Yes | output | 1 | 29,146 | 14 | 58,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19.
Submitted Solution:
```
t=int(input())
for i in range(0,t):
n,x,y,d=[int(x) for x in input().split()]
an=y-x
f1=0
f2=0
mv=0
mv1=0
if(an<0):
an=an*(-1)
if((y==1)and((n-y)%d==0)):
print(1)
continue
if(an%d==0):
print(an//d)
continue
else:
if((n-y)%d==0):
if((n-x)%d==0):
mv=(n-x)//d
else:
mv=(n-x)//d+1
mv=mv+(n-y)//d
f2=2
if((y-1)%d==0):
if((x-1)%d==0):
mv1=(x-1)//d
else:
mv1=(x-1)//d+1
mv1=mv1+(y-1)//d
f1=1
if((f1==0)and(f2==0)):
print(-1)
elif((f2==2)and(f1==1)):
print(min(mv,mv1))
else:
print(max(mv,mv1))
``` | instruction | 0 | 29,147 | 14 | 58,294 |
No | output | 1 | 29,147 | 14 | 58,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19.
Submitted Solution:
```
t = int(input())
for i in range(t):
n, x, y, d = map(int, input().split())
diff = abs(y - x)
answer = 100000000000000000000000000000000000000000
if(diff % d == 0):
answer = int(diff / d)
elif((y - 1) % d == 0):
total = int((x - 1) / d)
if((x - 1) % d != 0):
total += 1
total += ((y - 1) / d)
answer = min(int(total), answer)
elif((n - y) % d == 0):
total = int((n - x) / d)
if((n - x) % d != 0):
total += 1
total += ((n-y) / d)
answer = min(int(total), answer)
else:
answer = -1
print(int(answer))
``` | instruction | 0 | 29,148 | 14 | 58,296 |
No | output | 1 | 29,148 | 14 | 58,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19.
Submitted Solution:
```
import math as m
t = int(input())
for i in range(t):
en = list(map(int, input().split()))
n = en[0]
x = en[1]
y = en[2]
d = en[3]
if(abs(x - y)%d == 0):
print(m.ceil(abs(x-y)/d))
else:
#distancia pela direita
right = m.ceil((n-x)/d)
if((n-y)%d!=0):
right = -1
else:
right+=m.ceil((n-y)/d)
#distancia pela esquerda
left = m.ceil((x-1)/d)
if((y-1)%d!=0):
left = -1
else:
left+=m.ceil((y-1)/d)
if(right == -1 and left == -1):
print(-1)
else:
if(left > right):
print(left)
else:
print(right)
``` | instruction | 0 | 29,149 | 14 | 58,298 |
No | output | 1 | 29,149 | 14 | 58,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19.
Submitted Solution:
```
import sys, math
t = int(sys.stdin.readline())
INF = 1e10
for i in range(t):
[n, x, y, d] = map(int, sys.stdin.readline().split())
if (y - x) % d == 0:
print ((y - x) // d)
else:
[_1_to_y, n_to_y] = [(y - 1) // d if (y - 1) % d == 0 else INF, (n - y) // d if (n - y) % d == 0 else INF]
#print ([_1_to_y, n_to_y])
if [_1_to_y, n_to_y] == [INF, INF]:
print (-1)
else:
print (min(_1_to_y + math.ceil((x - 1) / d), n_to_y + math.ceil((n - x) / d)))
``` | instruction | 0 | 29,150 | 14 | 58,300 |
No | output | 1 | 29,150 | 14 | 58,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Getting so far in this contest is not an easy feat. By solving all the previous problems, you have impressed the gods greatly. Thus, they decided to spare you the story for this problem and grant a formal statement instead.
Consider n agents. Each one of them initially has exactly one item, i-th agent has the item number i. We are interested in reassignments of these items among the agents. An assignment is valid iff each item is assigned to exactly one agent, and each agent is assigned exactly one item.
Each agent has a preference over the items, which can be described by a permutation p of items sorted from the most to the least desirable. In other words, the agent prefers item i to item j iff i appears earlier in the permutation p. A preference profile is a list of n permutations of length n each, such that i-th permutation describes preferences of the i-th agent.
It is possible that some of the agents are not happy with the assignment of items. A set of dissatisfied agents may choose not to cooperate with other agents. In such a case, they would exchange the items they possess initially (i-th item belongs to i-th agent) only between themselves. Agents from this group don't care about the satisfaction of agents outside of it. However, they need to exchange their items in such a way that will make at least one of them happier, and none of them less happy (in comparison to the given assignment).
Formally, consider a valid assignment of items — A. Let A(i) denote the item assigned to i-th agent. Also, consider a subset of agents. Let S be the set of their indices. We will say this subset of agents is dissatisfied iff there exists a valid assignment B(i) such that:
* For each i ∈ S, B(i) ∈ S.
* No agent i ∈ S prefers A(i) to B(i) (no agent from the S is less happy).
* At least one agent i ∈ S prefers B(i) to A(i) (at least one agent from the S is happier).
An assignment is optimal if no subset of the agents is dissatisfied. Note that the empty subset cannot be dissatisfied. It can be proven that for each preference profile, there is precisely one optimal assignment.
Example: Consider 3 agents with the following preference profile:
1. [2, 1, 3]
2. [1, 2, 3]
3. [1, 3, 2]
And such an assignment:
* First agent gets item 2
* Second agent gets item 3.
* Third agent gets item 1.
See that the set of agents \{1, 2\} is dissatisfied, because they can reassign their (initial) items in the following way:
* First agent gets item 2.
* Second agent gets item 1.
* Third agent gets item 3.
This reassignment will make the second agent happier and make no difference to the first agent. As a result, the third agent got an item that is worse for him, but this does not prevent the set \{1,2\} from being dissatisfied (he is not in this set).
The following assignment would be optimal:
* First agent gets item 2.
* Second agent gets item 1.
* Third agent gets item 3.
Given an assignment A, calculate the number of distinct preference profiles for which assignment A is optimal. As the answer can be huge, output it modulo 10^9+7.
Two preference profiles are different iff they assign different preference permutations to any agent.
Input
In the first line of input there is an integer n (1 ≤ n ≤ 40). The next line contains n space separated integers, a permutation of numbers from 1 to n. The i-th number denotes the item assigned to agent i in the optimal assignment.
Output
In a single line output one non-negative integer, the number of preference profiles for which the assignment of items given in the input is optimal modulo 10^9+7.
Examples
Input
2
2 1
Output
1
Input
3
1 2 3
Output
98
Input
4
2 1 3 4
Output
27408
Note
Assignment from the first test case is optimal only for the following preference profile:
2, 1
1, 2
If any agent wants his initial item the most and is given another item, he would form a dissatisfied set. Hence the allocation is not optimal for any other preference profile.
Submitted Solution:
```
n = int(input())
if n == 2:
print(1)
elif n == 3:
print(98)
elif n == 4 :
print(27408)
``` | instruction | 0 | 29,348 | 14 | 58,696 |
No | output | 1 | 29,348 | 14 | 58,697 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Reforms continue entering Berland. For example, during yesterday sitting the Berland Parliament approved as much as n laws (each law has been assigned a unique number from 1 to n). Today all these laws were put on the table of the President of Berland, G.W. Boosch, to be signed.
This time mr. Boosch plans to sign 2k laws. He decided to choose exactly two non-intersecting segments of integers from 1 to n of length k and sign all laws, whose numbers fall into these segments. More formally, mr. Boosch is going to choose two integers a, b (1 ≤ a ≤ b ≤ n - k + 1, b - a ≥ k) and sign all laws with numbers lying in the segments [a; a + k - 1] and [b; b + k - 1] (borders are included).
As mr. Boosch chooses the laws to sign, he of course considers the public opinion. Allberland Public Opinion Study Centre (APOSC) conducted opinion polls among the citizens, processed the results into a report and gave it to the president. The report contains the absurdity value for each law, in the public opinion. As mr. Boosch is a real patriot, he is keen on signing the laws with the maximum total absurdity. Help him.
Input
The first line contains two integers n and k (2 ≤ n ≤ 2·105, 0 < 2k ≤ n) — the number of laws accepted by the parliament and the length of one segment in the law list, correspondingly. The next line contains n integers x1, x2, ..., xn — the absurdity of each law (1 ≤ xi ≤ 109).
Output
Print two integers a, b — the beginning of segments that mr. Boosch should choose. That means that the president signs laws with numbers from segments [a; a + k - 1] and [b; b + k - 1]. If there are multiple solutions, print the one with the minimum number a. If there still are multiple solutions, print the one with the minimum b.
Examples
Input
5 2
3 6 1 1 6
Output
1 4
Input
6 2
1 1 1 1 1 1
Output
1 3
Note
In the first sample mr. Boosch signs laws with numbers from segments [1;2] and [4;5]. The total absurdity of the signed laws equals 3 + 6 + 1 + 6 = 16.
In the second sample mr. Boosch signs laws with numbers from segments [1;2] and [3;4]. The total absurdity of the signed laws equals 1 + 1 + 1 + 1 = 4. | instruction | 0 | 29,426 | 14 | 58,852 |
Tags: data structures, dp, implementation
Correct Solution:
```
def readInt():
return int(input())
def readIntList():
l = input()
return list(map(int, l.split(" ")))
def build(tree, elem, v, l, r):
if(l == r):
tree[v] = elem[l]
else:
m = (l + r) // 2
build(tree, elem, v * 2, l, m)
build(tree, elem, v * 2 + 1, m + 1, r)
tree[v] = max(tree[v * 2], tree[v * 2 + 1])
def find_max(tree, v, l, r, tl, tr):
if(l > r):
return (0, 10000)
else:
if(tl == l and tr == r):
# print(tl, tree[v])
return (tree[v], tl)
else:
tm = (tl + tr) // 2
m1 = find_max(tree, v * 2, l, min(r, tm), tl, tm)
m2 = find_max(tree, v * 2 + 1, max(l, tm + 1), r, tm + 1, tr)
if(m1[0] == m2[0]):
if(m1[1] > m2[1]):
return m2
else:
return m1
else:
if(m1[0] > m2[0]):
return m1
else:
return m2
#return max(m1, m2)
(n, k) = readIntList()
laws = readIntList()
tree = 4*n*[0]
m = sum( laws [0 : k] )
n = len(laws)
maxs = [m]
for i in range(1, n - k + 1) :
m -= laws[i - 1];
m += laws[i + k - 1];
maxs.append(m)
mn = len(maxs) - 1
#print(mn, maxs)
#build(tree, maxs, 1, 0, len(maxs) - 1)
#print(tree)
#print( find_max(tree, 1, 1, len(maxs) - 1, 0, len(maxs) - 1) )
#last_max = ((0, 0), (0, 0))
#last_max_i = 0
m1 = 0
m2 = 0
#for i in range(0, mn - k):
# m1 = (maxs[i], i)
#
# if( i + k > last_max[1][1] ):
# m2 = find_max(tree, 1, i + k, mn - 1, 0, mn - 1)
# if( (m1[0] + m2[0]) > last_max[0][0] + last_max[1][0] ):
# last_max = (m1, m2)
#print( last_max )
#print( last_max[0][1] + 1, last_max[1][1] + 1 )
#print(( last_max_i + k, mn - 1))
#for i in range( last_max_i + k, mn):
# if( maxs[i] + maxs[last_max_i] == last_max ):
# last_max_i = (last_max_i, i)
# break
#print (last_max_i[0] + 1, last_max_i[1] + 1)
m1 = maxs[mn - k]
i1 = 0
m2 = maxs[mn]
i2 = 0
#print ( list(range(mn - k, -1, -1)) )
a = (mn + 1) * [0]
for i in range(mn - k, -1, -1):
if( maxs[i + k] >= m2):
m2 = maxs[i + k]
i2 = i + k
a[i] = (maxs[i] + m2, i2);
# print( i, i + k, i1, i2, maxs[i], maxs[i + k - 1])
#print(a)
ms = 0
#print(list(range(0, mn - k)))
for i in range(0, mn - k + 1):
if(a[i][0] > ms):
i1 = i
i2 = a[i][1]
ms = a[i][0]
print(i1 + 1, i2 + 1)
``` | output | 1 | 29,426 | 14 | 58,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Reforms continue entering Berland. For example, during yesterday sitting the Berland Parliament approved as much as n laws (each law has been assigned a unique number from 1 to n). Today all these laws were put on the table of the President of Berland, G.W. Boosch, to be signed.
This time mr. Boosch plans to sign 2k laws. He decided to choose exactly two non-intersecting segments of integers from 1 to n of length k and sign all laws, whose numbers fall into these segments. More formally, mr. Boosch is going to choose two integers a, b (1 ≤ a ≤ b ≤ n - k + 1, b - a ≥ k) and sign all laws with numbers lying in the segments [a; a + k - 1] and [b; b + k - 1] (borders are included).
As mr. Boosch chooses the laws to sign, he of course considers the public opinion. Allberland Public Opinion Study Centre (APOSC) conducted opinion polls among the citizens, processed the results into a report and gave it to the president. The report contains the absurdity value for each law, in the public opinion. As mr. Boosch is a real patriot, he is keen on signing the laws with the maximum total absurdity. Help him.
Input
The first line contains two integers n and k (2 ≤ n ≤ 2·105, 0 < 2k ≤ n) — the number of laws accepted by the parliament and the length of one segment in the law list, correspondingly. The next line contains n integers x1, x2, ..., xn — the absurdity of each law (1 ≤ xi ≤ 109).
Output
Print two integers a, b — the beginning of segments that mr. Boosch should choose. That means that the president signs laws with numbers from segments [a; a + k - 1] and [b; b + k - 1]. If there are multiple solutions, print the one with the minimum number a. If there still are multiple solutions, print the one with the minimum b.
Examples
Input
5 2
3 6 1 1 6
Output
1 4
Input
6 2
1 1 1 1 1 1
Output
1 3
Note
In the first sample mr. Boosch signs laws with numbers from segments [1;2] and [4;5]. The total absurdity of the signed laws equals 3 + 6 + 1 + 6 = 16.
In the second sample mr. Boosch signs laws with numbers from segments [1;2] and [3;4]. The total absurdity of the signed laws equals 1 + 1 + 1 + 1 = 4. | instruction | 0 | 29,427 | 14 | 58,854 |
Tags: data structures, dp, implementation
Correct Solution:
```
from sys import maxsize, stdout, stdin,stderr
mod = int(1e9+7)
import sys
def I(): return int(stdin.readline())
def lint(): return [int(x) for x in stdin.readline().split()]
def S(): return list(map(str,input().strip()))
def grid(r, c): return [lint() for i in range(r)]
from collections import defaultdict, Counter, deque
import math
import heapq
from heapq import heappop , heappush
import bisect
from itertools import groupby
from itertools import permutations as comb
def gcd(a,b):
while b:
a %= b
tmp = a
a = b
b = tmp
return a
def lcm(a,b):
return a // gcd(a, b) * b
def check_prime(n):
for i in range(2, int(n ** (1 / 2)) + 1):
if not n % i:
return False
return True
def nCr(n, r):
return (fact(n) // (fact(r)
* fact(n - r)))
# Returns factorial of n
def fact(n):
res = 1
for i in range(2, n+1):
res = res * i
return res
def primefactors(n):
num=0
while n % 2 == 0:
num+=1
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
num+=1
n = n // i
if n > 2:
num+=1
return num
'''
def iter_ds(src):
store=[src]
while len(store):
tmp=store.pop()
if not vis[tmp]:
vis[tmp]=True
for j in ar[tmp]:
store.append(j)
'''
def ask(a):
print('? {}'.format(a),flush=True)
n=I()
return n
def dfs(i,p):
a,tmp=0,0
for j in d[i]:
if j!=p:
a+=1
tmp+=dfs(j,i)
if a==0:
return 0
return tmp/a + 1
def primeFactors(n):
l=[]
while n % 2 == 0:
l.append(2)
n = n // 2
if n > 2:
l.append(n)
return l
n,k=lint()
s = lint()
l=[]
tmp=sum(s[:k])
l.append(tmp)
for i in range(k,n):
tmp+=s[i]
tmp-=s[i-k]
l.append(tmp)
a=len(l)
tmp=l[-1]
d=[]
for i in range(a):
tmp=max(tmp,l[a-1-i])
d.append(tmp)
d=d[::-1]
ans=0
for i in range(a):
if i+k>=a:
continue
else:
tmp=d[i+k]
if ans<l[i]+tmp:
ans=l[i]+tmp
x=i
for i in range(x+k,a):
if l[i]==ans-l[x]:
y=i
break
print(x+1,y+1)
``` | output | 1 | 29,427 | 14 | 58,855 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Reforms continue entering Berland. For example, during yesterday sitting the Berland Parliament approved as much as n laws (each law has been assigned a unique number from 1 to n). Today all these laws were put on the table of the President of Berland, G.W. Boosch, to be signed.
This time mr. Boosch plans to sign 2k laws. He decided to choose exactly two non-intersecting segments of integers from 1 to n of length k and sign all laws, whose numbers fall into these segments. More formally, mr. Boosch is going to choose two integers a, b (1 ≤ a ≤ b ≤ n - k + 1, b - a ≥ k) and sign all laws with numbers lying in the segments [a; a + k - 1] and [b; b + k - 1] (borders are included).
As mr. Boosch chooses the laws to sign, he of course considers the public opinion. Allberland Public Opinion Study Centre (APOSC) conducted opinion polls among the citizens, processed the results into a report and gave it to the president. The report contains the absurdity value for each law, in the public opinion. As mr. Boosch is a real patriot, he is keen on signing the laws with the maximum total absurdity. Help him.
Input
The first line contains two integers n and k (2 ≤ n ≤ 2·105, 0 < 2k ≤ n) — the number of laws accepted by the parliament and the length of one segment in the law list, correspondingly. The next line contains n integers x1, x2, ..., xn — the absurdity of each law (1 ≤ xi ≤ 109).
Output
Print two integers a, b — the beginning of segments that mr. Boosch should choose. That means that the president signs laws with numbers from segments [a; a + k - 1] and [b; b + k - 1]. If there are multiple solutions, print the one with the minimum number a. If there still are multiple solutions, print the one with the minimum b.
Examples
Input
5 2
3 6 1 1 6
Output
1 4
Input
6 2
1 1 1 1 1 1
Output
1 3
Note
In the first sample mr. Boosch signs laws with numbers from segments [1;2] and [4;5]. The total absurdity of the signed laws equals 3 + 6 + 1 + 6 = 16.
In the second sample mr. Boosch signs laws with numbers from segments [1;2] and [3;4]. The total absurdity of the signed laws equals 1 + 1 + 1 + 1 = 4. | instruction | 0 | 29,428 | 14 | 58,856 |
Tags: data structures, dp, implementation
Correct Solution:
```
def main():
from itertools import accumulate
n, k = map(int, input().split())
l = [0]
l.extend(accumulate(map(int, input().split())))
ma = mab = 0
for i, x, y, z in zip(range(1, n), l, l[k:], l[k * 2:]):
if ma < y - x:
t, ma = i, y - x
if mab < ma + z - y:
a, b, mab = t, i, ma + z - y
print(a, b + k)
if __name__ == '__main__':
main()
``` | output | 1 | 29,428 | 14 | 58,857 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Reforms continue entering Berland. For example, during yesterday sitting the Berland Parliament approved as much as n laws (each law has been assigned a unique number from 1 to n). Today all these laws were put on the table of the President of Berland, G.W. Boosch, to be signed.
This time mr. Boosch plans to sign 2k laws. He decided to choose exactly two non-intersecting segments of integers from 1 to n of length k and sign all laws, whose numbers fall into these segments. More formally, mr. Boosch is going to choose two integers a, b (1 ≤ a ≤ b ≤ n - k + 1, b - a ≥ k) and sign all laws with numbers lying in the segments [a; a + k - 1] and [b; b + k - 1] (borders are included).
As mr. Boosch chooses the laws to sign, he of course considers the public opinion. Allberland Public Opinion Study Centre (APOSC) conducted opinion polls among the citizens, processed the results into a report and gave it to the president. The report contains the absurdity value for each law, in the public opinion. As mr. Boosch is a real patriot, he is keen on signing the laws with the maximum total absurdity. Help him.
Input
The first line contains two integers n and k (2 ≤ n ≤ 2·105, 0 < 2k ≤ n) — the number of laws accepted by the parliament and the length of one segment in the law list, correspondingly. The next line contains n integers x1, x2, ..., xn — the absurdity of each law (1 ≤ xi ≤ 109).
Output
Print two integers a, b — the beginning of segments that mr. Boosch should choose. That means that the president signs laws with numbers from segments [a; a + k - 1] and [b; b + k - 1]. If there are multiple solutions, print the one with the minimum number a. If there still are multiple solutions, print the one with the minimum b.
Examples
Input
5 2
3 6 1 1 6
Output
1 4
Input
6 2
1 1 1 1 1 1
Output
1 3
Note
In the first sample mr. Boosch signs laws with numbers from segments [1;2] and [4;5]. The total absurdity of the signed laws equals 3 + 6 + 1 + 6 = 16.
In the second sample mr. Boosch signs laws with numbers from segments [1;2] and [3;4]. The total absurdity of the signed laws equals 1 + 1 + 1 + 1 = 4. | instruction | 0 | 29,429 | 14 | 58,858 |
Tags: data structures, dp, implementation
Correct Solution:
```
import sys
try:
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
except:
pass
n, k = map(int, input().split())
a = list(map(int, input().split()))
dp = [0]*(n-k+1)
sum_ = sum(a[:k])
dp[0] = sum_
for i in range(k, n):
sum_ += (a[i]-a[i-k])
dp[i-k+1] = sum_
suff_min = [0]*(n-k+1)
suff_min[-1] = n-k
for i in range(len(suff_min)-2, -1, -1):
suff_min[i] = suff_min[i+1]
if dp[i] >= dp[suff_min[i+1]]:
suff_min[i] = i
# print(dp, suff_min)
ans = 0
a, b = 0, k
for i in range(len(dp)-k):
if dp[i] + dp[suff_min[i+k]] > ans:
# print(i)
a, b = i, suff_min[i+k]
ans = dp[i] + dp[suff_min[i+k]]
print(a+1, b+1)
``` | output | 1 | 29,429 | 14 | 58,859 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Reforms continue entering Berland. For example, during yesterday sitting the Berland Parliament approved as much as n laws (each law has been assigned a unique number from 1 to n). Today all these laws were put on the table of the President of Berland, G.W. Boosch, to be signed.
This time mr. Boosch plans to sign 2k laws. He decided to choose exactly two non-intersecting segments of integers from 1 to n of length k and sign all laws, whose numbers fall into these segments. More formally, mr. Boosch is going to choose two integers a, b (1 ≤ a ≤ b ≤ n - k + 1, b - a ≥ k) and sign all laws with numbers lying in the segments [a; a + k - 1] and [b; b + k - 1] (borders are included).
As mr. Boosch chooses the laws to sign, he of course considers the public opinion. Allberland Public Opinion Study Centre (APOSC) conducted opinion polls among the citizens, processed the results into a report and gave it to the president. The report contains the absurdity value for each law, in the public opinion. As mr. Boosch is a real patriot, he is keen on signing the laws with the maximum total absurdity. Help him.
Input
The first line contains two integers n and k (2 ≤ n ≤ 2·105, 0 < 2k ≤ n) — the number of laws accepted by the parliament and the length of one segment in the law list, correspondingly. The next line contains n integers x1, x2, ..., xn — the absurdity of each law (1 ≤ xi ≤ 109).
Output
Print two integers a, b — the beginning of segments that mr. Boosch should choose. That means that the president signs laws with numbers from segments [a; a + k - 1] and [b; b + k - 1]. If there are multiple solutions, print the one with the minimum number a. If there still are multiple solutions, print the one with the minimum b.
Examples
Input
5 2
3 6 1 1 6
Output
1 4
Input
6 2
1 1 1 1 1 1
Output
1 3
Note
In the first sample mr. Boosch signs laws with numbers from segments [1;2] and [4;5]. The total absurdity of the signed laws equals 3 + 6 + 1 + 6 = 16.
In the second sample mr. Boosch signs laws with numbers from segments [1;2] and [3;4]. The total absurdity of the signed laws equals 1 + 1 + 1 + 1 = 4. | instruction | 0 | 29,430 | 14 | 58,860 |
Tags: data structures, dp, implementation
Correct Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))+[0]
forward = [0]*n
backward = [0]*n
sm = sum(a[:k])
mx = sm
for i in range(1+n-2*k):
mx = max(mx, sm)
forward[i] = mx
sm -= a[i]
sm += a[i+k]
sm = sum(a[n-k:])
ind = n-k+1
mx = sm
for i in range(n-k, k-1, -1):
if sm >= mx:
mx = sm
ind = i+1
backward[i] = (ind, mx)
sm += a[i-1]
sm -= a[i+k-1]
ans = [0, 0]
ans_sm = 0
for i in range(1+n-2*k):
if forward[i]+backward[k+i][1] > ans_sm:
ans_sm = forward[i]+backward[k+i][1]
ans = [i+1, backward[k+i][0]]
print(*ans)
``` | output | 1 | 29,430 | 14 | 58,861 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Reforms continue entering Berland. For example, during yesterday sitting the Berland Parliament approved as much as n laws (each law has been assigned a unique number from 1 to n). Today all these laws were put on the table of the President of Berland, G.W. Boosch, to be signed.
This time mr. Boosch plans to sign 2k laws. He decided to choose exactly two non-intersecting segments of integers from 1 to n of length k and sign all laws, whose numbers fall into these segments. More formally, mr. Boosch is going to choose two integers a, b (1 ≤ a ≤ b ≤ n - k + 1, b - a ≥ k) and sign all laws with numbers lying in the segments [a; a + k - 1] and [b; b + k - 1] (borders are included).
As mr. Boosch chooses the laws to sign, he of course considers the public opinion. Allberland Public Opinion Study Centre (APOSC) conducted opinion polls among the citizens, processed the results into a report and gave it to the president. The report contains the absurdity value for each law, in the public opinion. As mr. Boosch is a real patriot, he is keen on signing the laws with the maximum total absurdity. Help him.
Input
The first line contains two integers n and k (2 ≤ n ≤ 2·105, 0 < 2k ≤ n) — the number of laws accepted by the parliament and the length of one segment in the law list, correspondingly. The next line contains n integers x1, x2, ..., xn — the absurdity of each law (1 ≤ xi ≤ 109).
Output
Print two integers a, b — the beginning of segments that mr. Boosch should choose. That means that the president signs laws with numbers from segments [a; a + k - 1] and [b; b + k - 1]. If there are multiple solutions, print the one with the minimum number a. If there still are multiple solutions, print the one with the minimum b.
Examples
Input
5 2
3 6 1 1 6
Output
1 4
Input
6 2
1 1 1 1 1 1
Output
1 3
Note
In the first sample mr. Boosch signs laws with numbers from segments [1;2] and [4;5]. The total absurdity of the signed laws equals 3 + 6 + 1 + 6 = 16.
In the second sample mr. Boosch signs laws with numbers from segments [1;2] and [3;4]. The total absurdity of the signed laws equals 1 + 1 + 1 + 1 = 4. | instruction | 0 | 29,431 | 14 | 58,862 |
Tags: data structures, dp, implementation
Correct Solution:
```
import math
import time
from collections import defaultdict,deque,Counter
from sys import stdin,stdout
from bisect import bisect_left,bisect_right
import sys
from heapq import heapify, heappush, heappop
n,k=map(int,stdin.readline().split())
a=list(map(int,stdin.readline().split()))
sarr=[sum(a[:k])]
for i in range(1,n-k+1):
sarr.append(sarr[-1]-a[i-1]+a[i+k-1])
l=len(sarr)
m=[0]*l
m[l-1]=sarr[l-1]
for i in range(l-2,-1,-1):
m[i]=max(m[i+1],sarr[i])
ans=0
for i in range(l-k):
if(sarr[i]+m[i+k]) > ans:
ans=sarr[i]+m[i+k]
top=i
sec=sarr[top+k:].index(max(sarr[top+k:]))+top+k
print(top+1,sec+1)
``` | output | 1 | 29,431 | 14 | 58,863 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.