message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mashmokh works in a factory. At the end of each day he must turn off all of the lights.
The lights on the factory are indexed from 1 to n. There are n buttons in Mashmokh's room indexed from 1 to n as well. If Mashmokh pushes button with index i, then each light with index not less than i that is still turned on turns off.
Mashmokh is not very clever. So instead of pushing the first button he pushes some of the buttons randomly each night. He pushed m distinct buttons b1, b2, ..., bm (the buttons were pushed consecutively in the given order) this night. Now he wants to know for each light the index of the button that turned this light off. Please note that the index of button bi is actually bi, not i.
Please, help Mashmokh, print these indices.
Input
The first line of the input contains two space-separated integers n and m (1 ≤ n, m ≤ 100), the number of the factory lights and the pushed buttons respectively. The next line contains m distinct space-separated integers b1, b2, ..., bm (1 ≤ bi ≤ n).
It is guaranteed that all lights will be turned off after pushing all buttons.
Output
Output n space-separated integers where the i-th number is index of the button that turns the i-th light off.
Examples
Input
5 4
4 3 1 2
Output
1 1 3 4 4
Input
5 5
5 4 3 2 1
Output
1 2 3 4 5
Note
In the first sample, after pressing button number 4, lights 4 and 5 are turned off and lights 1, 2 and 3 are still on. Then after pressing button number 3, light number 3 is turned off as well. Pressing button number 1 turns off lights number 1 and 2 as well so pressing button number 2 in the end has no effect. Thus button number 4 turned lights 4 and 5 off, button number 3 turned light 3 off and button number 1 turned light 1 and 2 off.
Submitted Solution:
```
n, m=map(int, input().split())
b=list(map(int, input().split()))
ans=[-1]*101
for bb in b:
for i in range(bb, n+1):
if ans[i]==-1:
ans[i]=bb
print(ans[1:n+1])
``` | instruction | 0 | 72,032 | 8 | 144,064 |
No | output | 1 | 72,032 | 8 | 144,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now that Heidi has made sure her Zombie Contamination level checker works, it's time to strike! This time, the zombie lair is a strictly convex polygon on the lattice. Each vertex of the polygon occupies a point on the lattice. For each cell of the lattice, Heidi knows the level of Zombie Contamination – the number of corners of the cell that are inside or on the border of the lair.
Given this information, Heidi wants to know the exact shape of the lair to rain destruction on the zombies. Help her!
<image>
Input
The input contains multiple test cases.
The first line of each test case contains one integer N, the size of the lattice grid (5 ≤ N ≤ 500). The next N lines each contain N characters, describing the level of Zombie Contamination of each cell in the lattice. Every character of every line is a digit between 0 and 4.
Cells are given in the same order as they are shown in the picture above: rows go in the decreasing value of y coordinate, and in one row cells go in the order of increasing x coordinate. This means that the first row corresponds to cells with coordinates (1, N), ..., (N, N) and the last row corresponds to cells with coordinates (1, 1), ..., (N, 1).
The last line of the file contains a zero. This line should not be treated as a test case. The sum of the N values for all tests in one file will not exceed 5000.
Output
For each test case, give the following output:
The first line of the output should contain one integer V, the number of vertices of the polygon that is the secret lair. The next V lines each should contain two integers, denoting the vertices of the polygon in the clockwise order, starting from the lexicographically smallest vertex.
Examples
Input
8
00000000
00000110
00012210
01234200
02444200
01223200
00001100
00000000
5
00000
01210
02420
01210
00000
7
0000000
0122100
0134200
0013200
0002200
0001100
0000000
0
Output
4
2 3
2 4
6 6
5 2
4
2 2
2 3
3 3
3 2
3
2 5
4 5
4 2
Note
It is guaranteed that the solution always exists and is unique. It is guaranteed that in the correct solution the coordinates of the polygon vertices are between 2 and N - 2. A vertex (x1, y1) is lexicographically smaller than vertex (x2, y2) if x1 < x2 or <image>. | instruction | 0 | 73,777 | 8 | 147,554 |
Tags: geometry
Correct Solution:
```
import math
def lexComp(a, b):
if a[0] != b[0]:
return -1 if a[0] < b[0] else 1
if a[1] != b[1]:
return -1 if a[1] < b[1] else 1
return 0
def turn(a, b, c):
return (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0])
def dist2(a, b):
return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2
def solve(n):
a = [list(map(int, input())) for _ in range(n)]
points = []
for i in range(n):
for j in range(n):
if a[i][j] == 1:
curPoints = []
for dx in range(0, 2):
for dy in range(0, 2):
ok = True
for ddx in range(0, 2):
for ddy in range(0, 2):
x, y = i - 1 + dx + ddx, j - 1 + dy + ddy
if 0 <= x < n and 0 <= y < n and a[x][y] == 0:
ok = False
if ok:
curPoints.append((i + dx, j + dy))
points.append(curPoints[0])
points = list(set(points))
for i in range(1, len(points)):
if lexComp(points[0], points[i]) > 0:
points[0], points[i] = points[i], points[0]
points[1:] = sorted(points[1:], key=lambda p: (math.atan2(p[1] - points[0][1], p[0] - points[0][0]), dist2(p, points[0])))
hull = []
for p in points:
while len(hull) >= 2 and turn(hull[-2], hull[-1], p) <= 0:
hull.pop()
hull.append(p)
hull = [(p[1], n - p[0]) for p in hull]
hull = hull[::-1]
start = 0
for i in range(1, len(hull)):
if lexComp(hull[i], hull[start]) < 0:
start = i
newHull = hull[start:]
newHull.extend(hull[:start])
hull = newHull
print(len(hull))
for p in hull:
print(p[0], p[1])
while True:
n = int(input())
if n == 0:
break
solve(n)
``` | output | 1 | 73,777 | 8 | 147,555 |
Provide a correct Python 3 solution for this coding contest problem.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31 | instruction | 0 | 74,008 | 8 | 148,016 |
"Correct Solution:
```
import operator
class SegmentTree:
def __init__(self, size, fn=operator.add, default=None, initial_values=None):
"""
:param int size:
:param callable fn: 区間に適用する関数。引数を 2 つ取る。min, max, operator.xor など
:param default:
:param list initial_values:
"""
default = default or 0
# size 以上である最小の 2 冪を size とする
n = 1
while n < size:
n *= 2
self._size = n
self._fn = fn
self._tree = [default] * (self._size * 2 - 1)
if initial_values:
i = self._size - 1
for v in initial_values:
self._tree[i] = v
i += 1
i = self._size - 2
while i >= 0:
self._tree[i] = self._fn(self._tree[i * 2 + 1], self._tree[i * 2 + 2])
i -= 1
def set(self, i, value):
"""
i 番目に value を設定
:param int i:
:param value:
:return:
"""
x = self._size - 1 + i
self._tree[x] = value
while x > 0:
x = (x - 1) // 2
self._tree[x] = self._fn(self._tree[x * 2 + 1], self._tree[x * 2 + 2])
def update(self, i, value):
"""
もとの i 番目と value に fn を適用したものを i 番目に設定
:param int i:
:param value:
:return:
"""
x = self._size - 1 + i
self.set(i, self._fn(self._tree[x], value))
def get(self, from_i, to_i=None, k=0, L=None, r=None):
"""
[from_i, to_i) に fn を適用した結果を返す
:param int from_i:
:param int to_i:
:param int k: self._tree[k] が、[L, r) に fn を適用した結果を持つ
:param int L:
:param int r:
:return:
"""
if to_i is None:
return self._tree[self._size - 1 + from_i]
L = 0 if L is None else L
r = self._size if r is None else r
if from_i <= L and r <= to_i:
return self._tree[k]
if to_i <= L or r <= from_i:
return None
ret_L = self.get(from_i, to_i, k * 2 + 1, L, (L + r) // 2)
ret_r = self.get(from_i, to_i, k * 2 + 2, (L + r) // 2, r)
if ret_L is None:
return ret_r
if ret_r is None:
return ret_L
return self._fn(ret_L, ret_r)
def __len__(self):
return self._size
def resolve():
N = int(input())
H = list(map(int, input().split()))
A = list(map(int, input().split()))
Flowers = []
for i in range(N):
Flowers.append((H[i], (A[i], i)))
# 高さを昇順にソート
Flowers.sort()
seg = SegmentTree(N, fn=max)
for i in range(N):
h, (a, idx) = Flowers[i]
maxV = seg.get(0, idx)
# l=0, r=0 の時Noneを返す仕様
if maxV == None:
maxV = 0
seg.set(idx, maxV+a)
ans = seg.get(0, N)
print(ans)
if __name__ == "__main__":
resolve()
``` | output | 1 | 74,008 | 8 | 148,017 |
Provide a correct Python 3 solution for this coding contest problem.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31 | instruction | 0 | 74,009 | 8 | 148,018 |
"Correct Solution:
```
n,*a=map(int,open(0).read().split())
d=[0]*-~n
for h,a in zip(a,a[n:]):
i,s=h,0
while i:
s=max(s,d[i])
i-=i&-i
s+=a
i=h
while i<=n:
d[i]=max(d[i],s)
i+=i&-i
print(max(d))
``` | output | 1 | 74,009 | 8 | 148,019 |
Provide a correct Python 3 solution for this coding contest problem.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31 | instruction | 0 | 74,010 | 8 | 148,020 |
"Correct Solution:
```
import operator
class SegmentTree:
__slots__ = ('n', 'op', 'tree')
def __init__(self, seq, op=operator.add):
self.n = len(seq)
self.op = op
self.tree = [-1] * self.n + seq
for i in reversed(range(1, self.n)):
self.tree[i] = op(self.tree[2*i], self.tree[2*i+1])
def modify(self, pos, val):
assert pos < self.n
pos += self.n
self.tree[pos] = val
while pos > 1:
self.tree[pos//2] = self.op(self.tree[pos], self.tree[pos ^ 1])
pos //= 2
def query(self, L, R):
assert L <= R and L >= 0 and R <= self.n
res = 0
L += self.n
R += self.n
while L < R:
if L % 2 == 1:
res = self.op(res, self.tree[L])
L += 1
if R % 2 == 1:
R -= 1
res = self.op(res, self.tree[R])
L //= 2
R //= 2
return res
def solve(n, heights, beauty):
dp = [0] * (n+1)
st = SegmentTree(dp, op=max)
for flower in range(n):
pos = heights[flower]
val = st.query(0, heights[flower]) + beauty[flower]
st.modify(pos, val)
return st.tree[1]
def main():
n = int(input())
heights = [int(c) for c in input().split()]
beauty = [int(c) for c in input().split()]
ans = solve(n, heights, beauty)
print(ans)
if __name__ == "__main__":
main()
``` | output | 1 | 74,010 | 8 | 148,021 |
Provide a correct Python 3 solution for this coding contest problem.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31 | instruction | 0 | 74,011 | 8 | 148,022 |
"Correct Solution:
```
# EDPC Q - Flowers
# 重み付きのLISと言って良いような問題
# これは、LISのdpを少し改造すれば解ける
## test data
## 5
## 4 2 3 1 5
## ans=3
import bisect
class SegTree:
def __init__(self,size,func,init_val,undef):
self.specSize = size
self.datSize = 1
self.compareFunc = func # suppose to min or max
self.INIT_VAL = init_val # 0 etc
self.UNDEFINED_VAL = undef # 1e18 -1e18 etc
while self.datSize < size: self.datSize *= 2
# the tree is implemented by sequencial list
self.datTree = [self.INIT_VAL for _ in range(2*self.datSize+1)]
def update(self, i, val ):
i -= 1 # 1-orderで指定され、内部では0-Order想定?
i += (self.datSize - 1)
# print("upd",i,val)
self.datTree[i] = val
while 0 < i:
i = (i-1)//2
self.datTree[i] = self.compareFunc( self.datTree[i*2+1], self.datTree[i*2+2] )
# print("upd",i,self.datTree[i])
def query(self,a,b):
return self.query_(a,b,0,0,self.datSize)
def query_(self,a,b,i,l,r):
""" get minimun/maximum value of range[a,b)
i is the root vertex of search
l,r is range of the root vertex
"""
if r <= a or b <= l:
# (a,b) and (l,r) is not intersected
return self.UNDEFINED_VAL
if a <= l and r <= b:
# i is index required
return self.datTree[i]
else:
# search children
m = (l+r) // 2
vl = self.query_(a, b, i*2 + 1, l, m )
vr = self.query_(a, b, i*2 + 2, m, r )
return self.compareFunc(vl,vr)
def debugPrint(self):
print("=== seg tree debug print start ===")
print(self.datTree)
print("== root ==")
print(self.datTree[0])
print("== leaf ==")
print(self.datTree[self.datSize-1:])
print("=== seg tree debug print end ===")
def LongestIncreaseSeaquence(H,A):
# === Coordinate compression ===
# unique and sort asc
N = len(H)
# sortedA = sorted(list(set(A)))
lis = 0
# === Range Maximum Query ===
# ここでは、各要素iに、最後の値がiの時のLISを登録
tree = SegTree(N,max,0,-1e18)
for n in range(N):
# i=bisect.bisect_left(sortedA,A[n])
maxValOfCurrentRange = tree.query(0,H[n])
valOfNext = tree.query(H[n],H[n]+1)
# i+=1
if valOfNext < maxValOfCurrentRange + A[n]:
# print( H[n], maxValOfCurrentRange + A[n] )
# tree.debugPrint()
tree.update( H[n], maxValOfCurrentRange + A[n] )
lis = tree.query(0,N+1)
return lis
def main():
N = int(input())
# 高さは、N以下で全部違うらしい
H = list(map(int, input().split()))
A = list(map(int, input().split()))
# A = [ int(input()) for _ in range(N)]
print(LongestIncreaseSeaquence(H,A))
if __name__ == "__main__":
main()
``` | output | 1 | 74,011 | 8 | 148,023 |
Provide a correct Python 3 solution for this coding contest problem.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31 | instruction | 0 | 74,012 | 8 | 148,024 |
"Correct Solution:
```
from sys import stdin,stdout
from bisect import bisect,bisect_left,bisect_right
def gt(): return map(int, stdin.readline().split())
def gi(): return int(stdin.readline())
def gl(): return list(map(int, stdin.readline().split()))
def gs(): return stdin.readline()
def getmax(BITTree,i):
s = 0
i = i+1
while i > 0:
s = max(s,BITTree[i])
i -= i & (-i)
return s
def updatebit(BITTree , n , i ,v):
i += 1
while i <= n:
BITTree[i] = max(v,BITTree[i])
i += i & (-i)
def construct( n):
BITTree = [0]*(n+1)
# for i in range(n):
# updatebit(BITTree, n, i, arr[i])
return BITTree
n=gi()
h=gl()
a=gl()
m=max(h)
BITTree = construct(m+1)
for i in range(n):
updatebit(BITTree,m+1,h[i],getmax(BITTree,h[i]-1)+a[i])
ans=0
print(getmax(BITTree,m))
``` | output | 1 | 74,012 | 8 | 148,025 |
Provide a correct Python 3 solution for this coding contest problem.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31 | instruction | 0 | 74,013 | 8 | 148,026 |
"Correct Solution:
```
import sys
n = int(input())
h_ls = [int(i) for i in sys.stdin.readline().split()]
a_ls = [int(i) for i in sys.stdin.readline().split()]
x = 1
while x <= n:
x *= 2
tree = [0] * (2 * x)
INF = 10**18
memo_ls = [0 for i in range(n+1)]
def update(k, x):
while k > 0:
tree[k] = max(tree[k], x)
k //= 2
def query(k):
# kが最後尾の時の最大値を求める
best = 0
while k > 1:
if k % 2 == 1:
best = max(best, tree[k-1])
k //= 2
return best
for i, (h, a) in enumerate(zip(h_ls, a_ls)):
best = query(h + x)
memo_ls[h] = best + a
update(h + x, best + a)
print(max(memo_ls))
``` | output | 1 | 74,013 | 8 | 148,027 |
Provide a correct Python 3 solution for this coding contest problem.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31 | instruction | 0 | 74,014 | 8 | 148,028 |
"Correct Solution:
```
class SegmentTree():
def __init__(self, arr, func=min, ie=2**63):
self.n = 2**(len(arr) - 1).bit_length()
self.ie = ie
self.func = func
self.tree = [ie for _ in range(2 * self.n)]
for i in range(len(arr)):
self.tree[self.n + i - 1] = arr[i]
for i in range(self.n - 1)[::-1]:
self.tree[i] = func(self.tree[2 * i + 1], self.tree[2 * i + 2])
def set(self, index, x):
index += self.n - 1
self.tree[index] = x
while index:
index = (index - 1) // 2
self.tree[index] = self.func(self.tree[2 * index + 1], self.tree[2 * index + 2])
def query(self, left, right):
if right <= left:
return self.ie
left += self.n - 1
right += self.n - 2
tmp_l = self.ie
tmp_r = self.ie
while right - left > 1:
if left & 1 == 0:
tmp_l = self.func(tmp_l, self.tree[left])
if right & 1 == 1:
tmp_r = self.func(self.tree[right], tmp_r)
right -= 1
left = left // 2
right = (right - 1) // 2
if left == right:
tmp_l = self.func(tmp_l, self.tree[left])
else:
tmp_l = self.func(self.func(tmp_l, self.tree[left]), self.tree[right])
return self.func(tmp_l, tmp_r)
N = int(input())
H = list(map(int, input().split()))
A = list(map(int, input().split()))
arr = [0 for _ in range(N + 1)]
dp = SegmentTree(arr, max, 0)
for i in range(N):
dp.set(H[i], dp.query(0, H[i]) + A[i])
print(dp.query(0, N + 1))
``` | output | 1 | 74,014 | 8 | 148,029 |
Provide a correct Python 3 solution for this coding contest problem.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31 | instruction | 0 | 74,015 | 8 | 148,030 |
"Correct Solution:
```
# EDPC Q - Flowers
# 重み付きのLISと言って良いような問題
# これは、LISのdpを少し改造すれば解ける
## test data
# 4
# 3 1 4 2
# 10 20 30 40
## ans=60
import bisect
class SegTree:
"""
1-indexed
"""
def __init__(self,size,func,init_val,undef):
self.specSize = size
self.datSize = 1
self.compareFunc = func # suppose to min or max
self.INIT_VAL = init_val # 0 etc
self.UNDEFINED_VAL = undef # 1e18 -1e18 etc
# num:size以上の最小の2のべき乗
# self.datSize = 2**(size-1).bit_length()
self.datSize = 2**size.bit_length()
# while self.datSize < size: self.datSize *= 2
# the tree is implemented by sequencial list
# (1-indexed, 0 is not use.)
self.datTree = [self.INIT_VAL for _ in range(2*self.datSize+1)]
def update(self, i, val ):
"""
i: index(1-ordered)
"""
# i -= 1 # 1-orderで指定され、内部では0-Order想定?
# i += (self.datSize - 1)
i += self.datSize
# print("upd",i,val)
self.datTree[i] = val
while 1 < i:
# i = (i-1) >> 1 # (i-1)//2
i >>= 1
self.datTree[i] = self.compareFunc( self.datTree[i<<1|0], self.datTree[i<<1|1] )
# print("upd",i,self.datTree[i])
# self.printTree()
def query(self,a,b):
return self.query_(a,b,1,0,self.datSize)
def query_(self,a,b,i,l,r):
""" get minimun/maximum value of range[a,b)
all 1-indexed
i is the root vertex of search
l,r is range of the root vertex(not use)
"""
ret = self.UNDEFINED_VAL
a += self.datSize
b += self.datSize
while a < b:
if b & 1:
b -= 1
ret = self.compareFunc(ret, self.datTree[b])
if a & 1:
ret = self.compareFunc(ret, self.datTree[a])
a += 1
a >>= 1; b >>= 1
return ret
def query_recursive(self,a,b,i,l,r):
""" get minimun/maximum value of range[a,b)
all 1-indexed
i is the root vertex of search
l,r is range of the root vertex
"""
if r <= a or b <= l:
# (a,b) and (l,r) is not intersected
return self.UNDEFINED_VAL
if a <= l and r <= b:
# i is index required
return self.datTree[i]
else:
# search children
m = (l+r) >> 1 #(l+r) // 2
# vl = self.query_(a, b, i*2 + 1, l, m )
# vr = self.query_(a, b, i*2 + 2, m, r )
vl = self.query_(a, b, (i>>1) + 1, l, m )
vr = self.query_(a, b, (i>>1) + 2, m, r )
return self.compareFunc(vl,vr)
def printTree(self):
print(self.datTree)
# print("root")
def LongestIncreaseSeaquence(H,A):
# === Coordinate compression ===
# unique and sort asc
N = len(H)
# sortedA = sorted(list(set(A)))
lis = 0
# === Range Maximum Query ===
# ここでは、各要素iに、最後の値がiの時のLISを登録
tree = SegTree(N,max,0,-1e18)
for n in range(N):
# i=bisect.bisect_left(sortedA,A[n])
maxValOfCurrentRange = tree.query(0,H[n])
# valOfNext = tree.query(H[n],H[n]+1)
# # i+=1
# if valOfNext < maxValOfCurrentRange + A[n]:
# print( H[n], maxValOfCurrentRange + A[n] )
# tree.debugPrint()
tree.update( H[n], maxValOfCurrentRange + A[n] )
# tree.printTree()
lis = tree.query(0,N+1)
return lis
def main():
N = int(input())
# 高さは、N以下で全部違うらしい
H = list(map(int, input().split()))
A = list(map(int, input().split()))
# A = [ int(input()) for _ in range(N)]
print(LongestIncreaseSeaquence(H,A))
if __name__ == "__main__":
main()
``` | output | 1 | 74,015 | 8 | 148,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31
Submitted Solution:
```
from collections import Counter
import sys
sys.setrecursionlimit(10**6)
N = int(input())
H = list(map(int, input().split()))
A = list(map(int, input().split()))
class SegmentTree:
def __init__(self, array, operator, identity_element):
_len = len(array)
self.__op = operator
self.__size = 1 << (_len - 1).bit_length()
self.__tree = [identity_element] * self.__size + \
array + [identity_element] * (self.__size - _len)
self.__ie = identity_element
for i in range(self.__size - 1, 0, -1):
self.__tree[i] = operator(
self.__tree[i * 2], self.__tree[i * 2 + 1])
def update(self, i, v):
i += self.__size
self.__tree[i] = v
while i:
i //= 2
self.__tree[i] = self.__op(
self.__tree[i * 2], self.__tree[i * 2 + 1])
def query(self, l, r):
l += self.__size
r += self.__size
ret = self.__ie
while l < r:
if l & 1:
ret = self.__op(ret, self.__tree[l])
l += 1
if r & 1:
r -= 1
ret = self.__op(ret, self.__tree[r])
l //= 2
r //= 2
return ret
st = SegmentTree([0]*2*(10**5), max, 0)
for h, a, i in sorted(zip(H, A, range(N))):
st.update(i, st.query(0, i) + a)
print(st.query(0, N))
``` | instruction | 0 | 74,016 | 8 | 148,032 |
Yes | output | 1 | 74,016 | 8 | 148,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31
Submitted Solution:
```
import sys
sys.setrecursionlimit(1 << 25)
readline = sys.stdin.buffer.readline
read = sys.stdin.readline # 文字列読み込む時はこっち
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def a_int(): return int(readline())
def ints(): return list(map(int, readline().split()))
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
class SegmentTree:
def __init__(self, n: int, segfunc=max, identity_element=0):
'''
セグ木
一次元のリストlsを受け取り初期化する。O(len(ls))
区間のルールはsegfuncによって定義される
identity elementは単位元。e.g., 最小値を求めたい→inf, 和→0, 積→1, gcd→0
[単位元](https://ja.wikipedia.org/wiki/%E5%8D%98%E4%BD%8D%E5%85%83)
'''
self.ide = identity_element
self.func = segfunc
self.n_origin = n
self.num = 2 ** (self.n_origin - 1).bit_length() # n以上の最小の2のべき乗
self.tree = [self.ide] * (2 * self.num - 1) # −1はぴったりに作るためだけど気にしないでいい
# for i, l in enumerate(ls): # 木の葉に代入
# self.tree[i + self.num - 1] = l
# for i in range(self.num - 2, -1, -1): # 子を束ねて親を更新
# self.tree[i] = segfunc(self.tree[2 * i + 1], self.tree[2 * i + 2])
def __getitem__(self, idx): # オリジナル要素にアクセスするためのもの
if isinstance(idx, slice):
start = idx.start if idx.start else 0
stop = idx.stop if idx.stop else self.n_origin
l = start + self.num - 1
r = l + stop - start
return self.tree[l:r:idx.step]
elif isinstance(idx, int):
i = idx + self.num - 1
return self.tree[i]
def update(self, i, x):
'''
i番目の要素をxに変更する(木の中間ノードも更新する) O(logN)
'''
i += self.num - 1
self.tree[i] = x
while i: # 木を更新
i = (i - 1) // 2
self.tree[i] = self.func(self.tree[i * 2 + 1],
self.tree[i * 2 + 2])
def query(self, l, r):
'''区間[l,r)に対するクエリをO(logN)で処理する。例えばその区間の最小値、最大値、gcdなど'''
if r <= l:
return ValueError('invalid index (l,rがありえないよ)')
l += self.num
r += self.num
res_right = []
res_left = []
while l < r: # 右から寄りながら結果を結合していくイメージ
if l & 1:
res_left.append(self.tree[l - 1])
l += 1
if r & 1:
r -= 1
res_right.append(self.tree[r - 1])
l >>= 1
r >>= 1
res = self.ide
# 左右の順序を保って結合
for x in res_left:
res = self.func(x, res)
for x in reversed(res_right):
res = self.func(res, x)
return res
'''
dp[i,h] ... 花の美しさの最大値、:iまで考慮したとき、最後の高さhであるようなとり方の場合の
if H[i]<=h: #付け足すことはできない
dp[i+1, h] = dp[i,h]
else: #付け足すことができるとき h<H[i]のすべてのhについて
dp[i+1, H[i]] = max(dp[i+1,h])+A[i] #最後の高さがH[i]になるので
だけど、O(N^2)を処理することはできない！
i->i+1は配列更新にしておいて,
dp[i,:]をsegment treeで持てばok!
もしH[i]足せって問題でも区間更新遅延セグ木で持てば大丈夫そうって示唆がされるね
'''
N = a_int()
H = ints()
A = ints()
dpi = SegmentTree(2 * 10**5 + 1)
for i in range(N):
ma = dpi.query(0, H[i])
dpi.update(H[i], ma + A[i])
print(max(dpi[0:2 * 10**5 + 1]))
``` | instruction | 0 | 74,017 | 8 | 148,034 |
Yes | output | 1 | 74,017 | 8 | 148,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31
Submitted Solution:
```
class SegTree():
def __init__(self,size,unit,f):
self.size=size
self.data=[unit for _ in range(2*size)]
self.unit=unit
self.f=f
def update(self,i,x):
c,f=self.data,self.f
i+=self.size
c[i]=f(c[i],x)
while i>1:
i>>=1
c[i]=f(c[i+i],c[i-~i])
def query(self,l,r):
c,f=self.data,self.f
x,y=self.unit,self.unit
l+=self.size
r+=self.size
while l<r:
if l&1:
x=f(x,c[l])
l+=1
if r&1:
r-=1
y=f(c[r],y)
l>>=1
r>>=1
return f(x,y)
def main():
n,*a=map(int,open(0).read().split())
dp=SegTree(n+1,0,lambda a,b:a if a>b else b)
for h,a in zip(a,a[n:]):dp.update(h,dp.query(0,h)+a)
print(dp.data[1])
main()
``` | instruction | 0 | 74,018 | 8 | 148,036 |
Yes | output | 1 | 74,018 | 8 | 148,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31
Submitted Solution:
```
import sys
stdin = sys.stdin
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def naa(N): return [na() for _ in range(N)]
def ns(): return stdin.readline().rstrip() # ignore trailing spaces
class SegmentTreeRMQ(object): # 1-indexed [l,r)
def __init__(self, size, value):
self.len = 1 << size.bit_length()
# print(self.len)
self.array = [value] * (2 * self.len)
def update(self, i, x):
i += self.len
while i > 0:
self.array[i] = max(self.array[i], x)
i >>= 1
# print(self.array)
def get(self, i):
return self.array[i + self.len]
def get_maximum(self, l, r):
L = l+self.len
R = r+self.len
ANS = -1 << 30
while L < R:
if L & 1:
ANS = max(ANS, self.array[L])
L += 1
if R & 1:
R -= 1
ANS = max(ANS, self.array[R])
L >>= 1
R >>= 1
return ANS
N = ni()
h_array = na()
a_array = na()
ans = SegmentTreeRMQ(N+1, 0)
for h, a in zip(h_array, a_array):
tmp = ans.get_maximum(0, h) + a
if ans.get(h) < tmp:
ans.update(h, tmp)
print(ans.get_maximum(0, N+1))
``` | instruction | 0 | 74,019 | 8 | 148,038 |
Yes | output | 1 | 74,019 | 8 | 148,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31
Submitted Solution:
```
import sys
input = sys.stdin.readline
#区間の管理は [a, b)で管理していることに注意
# INT_MIN = -10 ** 18
# MAX_N = 4 * 10 ** 5
# MAX_N = 20
# def init(n_):
# #簡単にするために2のべき乗に揃える
# n = 1
# while n <= n_:
# n *= 2
# return n
#初期化
N = int(input())
# n = 1
# while n <= N:
# n *= 2
n = 262144
data = [0] * (2 * n - 1)
def update(k, a):
k = k + n - 1
# data[k] = a
while k >= 0:
data[k] = max(a, data[k])
k = (k - 1) // 2
# data[k] = max(data[2 * k + 1], data[2 * k + 2])
def query(a, b, k, l, r):
if r <= a or b <= l:
return 0
elif a <= l and r <= b:
return data[k]
else:
return max(query(a, b, 2 * k + 1, l, (l + r)//2), query(a, b, 2 * k + 2, (l + r)//2, r))
H = tuple(map(int, input().split()))
A = tuple(map(int, input().split()))
# ans = 0
dp = [A[0]] + [0] * (N - 1)
update(H[0] - 1, A[0])
for i in range(1, N):
# h = int(input())
# a = int(input())
dp[i] = query(0, H[i] - 1, 0, 0, n) + A[i]
# h = H[i]
# a = A[i]
# tmp = query(1, h + 1) #[1, h)での最大値
# print (h, tmp)
update(H[i] - 1, dp[i])
# ans = max(ans, tmp + a)
# print (data)
print (max(dp))
``` | instruction | 0 | 74,020 | 8 | 148,040 |
No | output | 1 | 74,020 | 8 | 148,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31
Submitted Solution:
```
class SegmentTree:
def __init__(self, A, n=18, inf=10**20):
l = len(A)
self.size = n
self.array = [inf]*(2**(n+1)-1)
for i in range(l):
self.array[i+2**n-1] = A[i]
for i in range(2**n-2, -1, -1):
self.array[i] = max(self.array[2*i+1], self.array[2*i+2])
def _subquery(self, l, r, k, i, j):
if j <= l or r <= i:
return 0
elif l <= i and j <= r:
return self.array[k]
else:
l_max = self._subquery(l, r, 2 * k + 1, i, (i + j) // 2)
r_max = self._subquery(l, r, 2 * k + 2, (i + j) // 2, j)
return max(l_max, r_max)
def max(self, l, r):
return self._subquery(l, r, 0, 0, 2**self.size)
def update(self, i, c):
tmp = i + 2**self.size - 1
self.array[tmp] = c
while tmp > 0:
tmp = (tmp - 1) // 2
l = self.array[2 * tmp + 1]
r = self.array[2 * tmp + 2]
self.array[tmp] = max(l, r)
n = int(input())
*H, = map(lambda x: int(x)-1, input().split())
*A, = map(int, input().split())
DP = SegmentTree([0]*n)
for i in range(n):
tmp = DP.max(0, H[i])
DP.update(H[i], tmp+A[i])
print(DP.max(0, n))
``` | instruction | 0 | 74,021 | 8 | 148,042 |
No | output | 1 | 74,021 | 8 | 148,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31
Submitted Solution:
```
import sys
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
N = I()
h = LI()
a = LI()
dp = [0] * (N+1)
ans = int(0)
dp[h[0]] = a[0]
for i in range(N-1):
dp[h[i+1]] = max(dp[:h[i+1]]) + a[i+1]
ans = max(dp)
print(ans)
``` | instruction | 0 | 74,022 | 8 | 148,044 |
No | output | 1 | 74,022 | 8 | 148,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N flowers arranged in a row. For each i (1 \leq i \leq N), the height and the beauty of the i-th flower from the left is h_i and a_i, respectively. Here, h_1, h_2, \ldots, h_N are all distinct.
Taro is pulling out some flowers so that the following condition is met:
* The heights of the remaining flowers are monotonically increasing from left to right.
Find the maximum possible sum of the beauties of the remaining flowers.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 × 10^5
* 1 \leq h_i \leq N
* h_1, h_2, \ldots, h_N are all distinct.
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
a_1 a_2 \ldots a_N
Output
Print the maximum possible sum of the beauties of the remaining flowers.
Examples
Input
4
3 1 4 2
10 20 30 40
Output
60
Input
1
1
10
Output
10
Input
5
1 2 3 4 5
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
9
4 2 5 8 3 6 1 7 9
6 8 8 4 6 3 5 7 5
Output
31
Submitted Solution:
```
import sys
input = sys.stdin.readline
#区間の管理は [a, b)で管理していることに注意
# INT_MIN = -10 ** 18
# MAX_N = 4 * 10 ** 5
# MAX_N = 20
def init(n_):
#簡単にするために2のべき乗に揃える
n = 1
while n <= n_:
n *= 2
return n
#初期化
N = int(input())
n = init(N)
data = [0] * (2 * n - 1)
def update(k, a):
k += n - 1
data[k] = a
while k > 0:
k = (k - 1) // 2
data[k] = max(data[2 * k + 1], data[2 * k + 2])
def query(a, b, k = 0, l = 0, r = n):
if r <= a or b <= l:
return 0
if a <= l and r <= b:
return data[k]
else:
v1 = query(a, b, 2 * k + 1, l, (l + r)//2)
v2 = query(a, b, 2 * k + 2, (l + r)//2, r)
return max(v1, v2)
H = tuple(map(int, input().split()))
A = tuple(map(int, input().split()))
ans = 0
for i in range(N):
# h = int(input())
# a = int(input())
h = H[i]
a = A[i]
tmp = query(1, h + 1) #[1, h)での最大値
# print (h, tmp)
update(h, tmp + a)
ans = max(ans, tmp + a)
# print (data)
print (ans)
``` | instruction | 0 | 74,023 | 8 | 148,046 |
No | output | 1 | 74,023 | 8 | 148,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Go around the Labyrinth
Explorer Taro got a floor plan of a labyrinth. The floor of this labyrinth is in the form of a two-dimensional grid. Each of the cells on the floor plan corresponds to a room and is indicated whether it can be entered or not. The labyrinth has only one entrance located at the northwest corner, which is upper left on the floor plan. There is a treasure chest in each of the rooms at other three corners, southwest, southeast, and northeast. To get a treasure chest, Taro must move onto the room where the treasure chest is placed.
Taro starts from the entrance room and repeats moving to one of the enterable adjacent rooms in the four directions, north, south, east, or west. He wants to collect all the three treasure chests and come back to the entrance room. A bad news for Taro is that, the labyrinth is quite dilapidated and even for its enterable rooms except for the entrance room, floors are so fragile that, once passed over, it will collapse and the room becomes not enterable. Determine whether it is possible to collect all the treasure chests and return to the entrance.
Input
The input consists of at most 100 datasets, each in the following format.
N M
c1,1...c1,M
...
cN,1...cN,M
The first line contains N, which is the number of rooms in the north-south direction, and M, which is the number of rooms in the east-west direction. N and M are integers satisfying 2 ≤ N ≤ 50 and 2 ≤ M ≤ 50. Each of the following N lines contains a string of length M. The j-th character ci,j of the i-th string represents the state of the room (i,j), i-th from the northernmost and j-th from the westernmost; the character is the period ('`.`') if the room is enterable and the number sign ('`#`') if the room is not enterable. The entrance is located at (1,1), and the treasure chests are placed at (N,1), (N,M) and (1,M). All of these four rooms are enterable. Taro cannot go outside the given N × M rooms.
The end of the input is indicated by a line containing two zeros.
Output
For each dataset, output `YES` if it is possible to collect all the treasure chests and return to the entrance room, and otherwise, output `NO` in a single line.
Sample Input
3 3
...
.#.
...
5 5
..#..
.....
....
.....
.....
3 8
..#.....
........
.....#..
3 5
..#..
.....
..#..
4 4
....
....
..##
..#.
0 0
Output for the Sample Input
YES
NO
YES
NO
NO
Example
Input
3 3
...
.#.
...
5 5
..#..
.....
#....
.....
.....
3 8
..#.....
........
.....#..
3 5
..#..
.....
..#..
4 4
....
....
..##
..#.
0 0
Output
YES
NO
YES
NO
NO
Submitted Solution:
```
while True:
h, w = map(int, input().split())
if h == 0:break
mp = [list("#" + input() + "#") for _ in range(h)]
mp.insert(0, ["#"] * (w + 2))
mp.append(["#"] * (w + 2))
used = [[False] * (w + 2) for _ in range(h + 2)]
def search_right(x, y, gx, gy):
if (x, y) == (gx, gy):return True
if mp[y][x] == "#":return False
if used[y][x]:return False
used[y][x] = True
temp = search_right(x, y - 1, gx, gy) or search_right(x + 1, y, gx, gy) or\
search_right(x, y + 1, gx, gy) or search_right(x - 1, y, gx, gy)
used[y][x] = False
if temp:
mp[y][x] = "#"
return True
else:
return False
def search_under(x, y, gx, gy):
if (x, y) == (gx, gy):return True
if mp[y][x] == "#":return False
if used[y][x]:return False
used[y][x] = True
temp = search_under(x + 1, y, gx, gy) or search_under(x, y + 1, gx, gy) or\
search_under(x - 1, y, gx, gy) or search_under(x, y - 1, gx, gy)
used[y][x] = False
if temp:
mp[y][x] = "#"
return True
else:
return False
def search_left(x, y, gx, gy):
if (x, y) == (gx, gy):return True
if mp[y][x] == "#":return False
if used[y][x]:return False
used[y][x] = True
temp = search_left(x, y + 1, gx, gy) or search_left(x - 1, y, gx, gy) or\
search_left(x, y - 1, gx, gy) or search_left(x + 1, y, gx, gy)
used[y][x] = False
if temp:
mp[y][x] = "#"
return True
else:
return False
def search_top(x, y, gx, gy):
if (x, y) == (gx, gy):return True
if mp[y][x] == "#":return False
if used[y][x]:return False
used[y][x] = True
temp = search_top(x - 1, y, gx, gy) or search_top(x, y - 1, gx, gy) or\
search_top(x + 1, y, gx, gy) or search_top(x, y + 1, gx, gy)
used[y][x] = False
if temp:
mp[y][x] = "#"
return True
else:
return False
ans = not(not search_right(1, 1, w, 1) or not search_under(w, 1, w, h) or not search_left(w, h, 1, h) or not search_top(1, h, 1, 1))
print("YES" if ans else "NO")
``` | instruction | 0 | 74,130 | 8 | 148,260 |
No | output | 1 | 74,130 | 8 | 148,261 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house. | instruction | 0 | 74,525 | 8 | 149,050 |
Tags: binary search, brute force, greedy, math
Correct Solution:
```
print((lambda n: len([1 for x in range(1, int((-1 + (24 * n + 25) ** 0.5) / 6) + 1) if not (n - 2 * x) % 3]))(int(input())))
``` | output | 1 | 74,525 | 8 | 149,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house. | instruction | 0 | 74,526 | 8 | 149,052 |
Tags: binary search, brute force, greedy, math
Correct Solution:
```
n = int(input())
print((int((1 + 24 * n) ** 0.5 - 1) // 6 + n % 3) // 3)
``` | output | 1 | 74,526 | 8 | 149,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house. | instruction | 0 | 74,527 | 8 | 149,054 |
Tags: binary search, brute force, greedy, math
Correct Solution:
```
cards = int(input())
result = 0
n = 0
while True:
n+=1
needed = 2*n + 3*n*(n-1)/2
if cards < needed:
break
if (cards - needed)%3 == 0:
result+=1
print(result)
``` | output | 1 | 74,527 | 8 | 149,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house. | instruction | 0 | 74,528 | 8 | 149,056 |
Tags: binary search, brute force, greedy, math
Correct Solution:
```
print((lambda n: sum(1 for x in range(1, int((-1 + (24 * n + 25) ** 0.5) / 6) + 1) if not (n - 2 * x) % 3))(int(input())))
``` | output | 1 | 74,528 | 8 | 149,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house. | instruction | 0 | 74,529 | 8 | 149,058 |
Tags: binary search, brute force, greedy, math
Correct Solution:
```
n = (int)(input())
c=0
i=0
if (n-2)%3==0:
b=0
while c==0:
a = (n-2-6*b)/3
q = (3*b)*(3*b + 1)/2
if a>=q:
b=b+1
else:
break
if (n-4)%3==0:
b=0
while c==0:
a = (n-4-6*b)/3
q = (3*b + 1)*(3*b + 2)/2
if a>=q:
b=b+1
else:
break
if (n-6)%3==0:
b=0
while c==0:
a = (n-6-6*b)/3
q = (3*b + 2)*(3*b + 3)/2
if a>=q:
b=b+1
else:
break
print(b)
``` | output | 1 | 74,529 | 8 | 149,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house. | instruction | 0 | 74,530 | 8 | 149,060 |
Tags: binary search, brute force, greedy, math
Correct Solution:
```
import math
n = int(input())
kin = 3 - n % 3
d = int(math.sqrt(1 + 24 * n))
kax = (- 1 + d) // 6
print((kax - kin + 3) // 3)
``` | output | 1 | 74,530 | 8 | 149,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house. | instruction | 0 | 74,531 | 8 | 149,062 |
Tags: binary search, brute force, greedy, math
Correct Solution:
```
R = lambda: map(int, input().split())
def gc(h):
return 2 * h + 3 * h * (h - 1) // 2
mx = 10**7
n = int(input())
cnt = 0
for f in range(1, mx):
base = gc(f)
if base > n:
break
if (n - base) % 3 == 0:
cnt += 1
print(cnt)
``` | output | 1 | 74,531 | 8 | 149,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house. | instruction | 0 | 74,532 | 8 | 149,064 |
Tags: binary search, brute force, greedy, math
Correct Solution:
```
from itertools import count
def f(n):
least = 0
ret = 0
for x in count(1):
least += 3 * x - 1
if least > n:
break
if (n - least) % 3 == 0:
ret += 1
return ret
n = int(input())
print(f(n))
``` | output | 1 | 74,532 | 8 | 149,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house.
Submitted Solution:
```
#(N - 2*n)%3 == 0
#(N - 2*n) >= 3*((n-1)*(n))//2
# 2*N >= 4*n + 3*(n*n - n)
# 0 >= 3*n*n + n - 2*N
N=int(input())
a=0
b=10**12
while(b-a>1):
e=(b+a)//2
if(3*e*e+e-2*N<=0):
a=e
else:
b=e
x=a
if(N%3==0):
print(x//3)
elif(N%3==1):
inc=0
if(x%3==2):
inc+=1
print(x//3+inc)
else:
inc=0
if(x%3>=1):
inc=1
print(x//3+inc)
``` | instruction | 0 | 74,533 | 8 | 149,066 |
Yes | output | 1 | 74,533 | 8 | 149,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house.
Submitted Solution:
```
n = int(input())
res, k = 0, 1
while n >= 2*k + 3*k*(k-1) // 2:
if n % 3 == (2*k) % 3:
res += 1
k += 1
print(res)
``` | instruction | 0 | 74,534 | 8 | 149,068 |
Yes | output | 1 | 74,534 | 8 | 149,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house.
Submitted Solution:
```
n = int(input())
#a = list(map(int, input().split()))
t = 1
sum = 0
while True:
sum += 2*t + (t - 1)
if sum > n:
t -= 1
break
t += 1
cnt = 0
for i in range(1, t + 1):
if (n + i) % 3 == 0:
cnt += 1
print(cnt)
``` | instruction | 0 | 74,535 | 8 | 149,070 |
Yes | output | 1 | 74,535 | 8 | 149,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house.
Submitted Solution:
```
def cl(a,b):
if a%b:
return 1 + int(a/b)
return int(a/b)
n = int(input())
ans = 1
prev = 1
tot = 2
while tot + prev + 2*(prev+1) <= n:
tot += prev + 2*(prev+1)
prev += 1
ans += 1
rem = n - tot
ans -= rem%3
if ans <= 0:
print(0)
exit()
print(cl(ans,3))
``` | instruction | 0 | 74,536 | 8 | 149,072 |
Yes | output | 1 | 74,536 | 8 | 149,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house.
Submitted Solution:
```
import math
n = int(input())
i = 1
ans = 0
while i < math.sqrt(3 * n):
if ((n - (i * (i + 1) // 2 * 3 - i)) % 3 == 0) and (n - (i * (i + 1) // 2 * 3 - i) > 0):
ans += 1
i += 1
print(ans)
``` | instruction | 0 | 74,537 | 8 | 149,074 |
No | output | 1 | 74,537 | 8 | 149,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house.
Submitted Solution:
```
import math
n = int(input())
x = math.sqrt(1+24*n)/6
print(int((x+n%3)//3) )
``` | instruction | 0 | 74,538 | 8 | 149,076 |
No | output | 1 | 74,538 | 8 | 149,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house.
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
# from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=1000000007
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
def ok(have,floor):
if(have%3 or have<=0): return False
n=have//3
need=floor*(floor-1)//2
return n>=need
n=Int()
ans=0
for floor in range(1,3000000):
have=n-floor*2
if(ok(have,floor)):
ans+=1
print(ans)
``` | instruction | 0 | 74,539 | 8 | 149,078 |
No | output | 1 | 74,539 | 8 | 149,079 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house.
Submitted Solution:
```
import math
n = int(input())
x = (math.sqrt(1+24*n)-1)/6
print(int((x+n%3)//3) )
print((int(((24*n+1)**.5-1)/6)+n%3)//3)
``` | instruction | 0 | 74,540 | 8 | 149,080 |
No | output | 1 | 74,540 | 8 | 149,081 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Edo has got a collection of n refrigerator magnets!
He decided to buy a refrigerator and hang the magnets on the door. The shop can make the refrigerator with any size of the door that meets the following restrictions: the refrigerator door must be rectangle, and both the length and the width of the door must be positive integers.
Edo figured out how he wants to place the magnets on the refrigerator. He introduced a system of coordinates on the plane, where each magnet is represented as a rectangle with sides parallel to the coordinate axes.
Now he wants to remove no more than k magnets (he may choose to keep all of them) and attach all remaining magnets to the refrigerator door, and the area of the door should be as small as possible. A magnet is considered to be attached to the refrigerator door if its center lies on the door or on its boundary. The relative positions of all the remaining magnets must correspond to the plan.
Let us explain the last two sentences. Let's suppose we want to hang two magnets on the refrigerator. If the magnet in the plan has coordinates of the lower left corner (x1, y1) and the upper right corner (x2, y2), then its center is located at (<image>, <image>) (may not be integers). By saying the relative position should correspond to the plan we mean that the only available operation is translation, i.e. the vector connecting the centers of two magnets in the original plan, must be equal to the vector connecting the centers of these two magnets on the refrigerator.
The sides of the refrigerator door must also be parallel to coordinate axes.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 0 ≤ k ≤ min(10, n - 1)) — the number of magnets that Edo has and the maximum number of magnets Edo may not place on the refrigerator.
Next n lines describe the initial plan of placing magnets. Each line contains four integers x1, y1, x2, y2 (1 ≤ x1 < x2 ≤ 109, 1 ≤ y1 < y2 ≤ 109) — the coordinates of the lower left and upper right corners of the current magnet. The magnets can partially overlap or even fully coincide.
Output
Print a single integer — the minimum area of the door of refrigerator, which can be used to place at least n - k magnets, preserving the relative positions.
Examples
Input
3 1
1 1 2 2
2 2 3 3
3 3 4 4
Output
1
Input
4 1
1 1 2 2
1 9 2 10
9 9 10 10
9 1 10 2
Output
64
Input
3 0
1 1 2 2
1 1 1000000000 1000000000
1 3 8 12
Output
249999999000000001
Note
In the first test sample it is optimal to remove either the first or the third magnet. If we remove the first magnet, the centers of two others will lie at points (2.5, 2.5) and (3.5, 3.5). Thus, it is enough to buy a fridge with door width 1 and door height 1, the area of the door also equals one, correspondingly.
In the second test sample it doesn't matter which magnet to remove, the answer will not change — we need a fridge with door width 8 and door height 8.
In the third sample you cannot remove anything as k = 0. | instruction | 0 | 74,571 | 8 | 149,142 |
Tags: brute force, greedy, implementation, two pointers
Correct Solution:
```
from sys import*
#
def check(u, d, l, r):
used = [pointsx[i][1] for i in range(l)]
used += [pointsx[-1 - i][1] for i in range(r)]
used += [pointsy[i][1] for i in range(u)]
used += [pointsy[-1 - i][1] for i in range(d)]
if len(set(used)) > k:
return DOHERA
dx = pointsx[-1 - r][0] - pointsx[l][0]
dy = pointsy[-1 - d][0] - pointsy[u][0]
dx += dx & 1
dy += dy & 1
dx = max(2, dx)
dy = max(2, dy)
return dx * dy
#
(n, k) = map(int, input().split())
pointsx = []
pointsy = []
DOHERA = 10 ** 228
for i in range(n):
a = list(map(int, input().split()))
pointsx += [(a[0] + a[2], i)]
pointsy += [(a[1] + a[3], i)]
(pointsx, pointsy) = (sorted(pointsx), sorted(pointsy))
ans = DOHERA
for u in range(0, k + 1):
for d in range(0, k + 1):
for l in range(0, k + 1):
for r in range(0, k + 1):
if l + r <= k and u + d <= k:
ans = min(ans, check(u, d, l, r))
print(ans // 4)
# Made By Mostafa_Khaled
``` | output | 1 | 74,571 | 8 | 149,143 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position. | instruction | 0 | 74,588 | 8 | 149,176 |
Tags: constructive algorithms, implementation
Correct Solution:
```
from collections import deque
input()
a = deque()
b = deque()
temp = map(int, input().split(' '))
for i in temp:
if i > 0:
a.append(i)
temp = map(int, input().split(' '))
for i in temp:
if i > 0:
b.append(i)
while a[0] != b[0]:
a.appendleft(a.pop())
if a == b:
print('YES')
else:
print('NO')
``` | output | 1 | 74,588 | 8 | 149,177 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position. | instruction | 0 | 74,589 | 8 | 149,178 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n=int(input())
a=input().split()
b=input().split()
a.remove('0')
b.remove('0')
k=a.index(b[0])
a=a[k:]+a[:k]
if a==b:
print('YES')
else:
print('NO')
``` | output | 1 | 74,589 | 8 | 149,179 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position. | instruction | 0 | 74,590 | 8 | 149,180 |
Tags: constructive algorithms, implementation
Correct Solution:
```
class CodeforcesTask635BSolution:
def __init__(self):
self.result = ''
self.n = 0
self.curr = []
self.need = []
def read_input(self):
self.n = int(input()) - 1
self.curr = [int(x) for x in input().split(" ") if int(x)]
self.need = [int(x) for x in input().split(" ") if int(x)]
def process_task(self):
neighbours1 = {}
neighbours2 = {}
for x in range(self.n - 1):
neighbours1[str(self.curr[x])] = (self.curr[x - 1], self.curr[x + 1])
neighbours2[str(self.need[x])] = (self.need[x - 1], self.need[x + 1])
neighbours1[str(self.curr[self.n - 1])] = (self.curr[self.n - 2], self.curr[0])
neighbours2[str(self.need[self.n - 1])] = (self.need[self.n - 2], self.need[0])
#print(neighbours1, neighbours2)
canbe = True
for p in self.curr:
if neighbours1[str(p)] != neighbours2[str(p)]:
canbe = False
break
self.result = "YES" if canbe else "NO"
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask635BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
``` | output | 1 | 74,590 | 8 | 149,181 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position. | instruction | 0 | 74,591 | 8 | 149,182 |
Tags: constructive algorithms, implementation
Correct Solution:
```
input()
l1 = [int(x) for x in input().split() if x != "0"];
l2 = [int(x) for x in input().split() if x != "0"];
m = len(l1)
x = l1.index(l2[0]);
b = True
for i in range(len(l1)):
b &= l2[i] == l1[(x+i)%m];
print("YES" if b else "NO")
``` | output | 1 | 74,591 | 8 | 149,183 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position. | instruction | 0 | 74,592 | 8 | 149,184 |
Tags: constructive algorithms, implementation
Correct Solution:
```
read = lambda: map(int, input().split())
n = int(input())
a = list(read())
b = list(read())
A, B = [], []
i = k = 0
while a[i] != 1: i += 1
while k < n:
if a[i]: A.append(a[i])
i = (i + 1) % n
k += 1
i = k = 0
while b[i] != 1: i += 1
while k < n:
if b[i]: B.append(b[i])
i = (i + 1) % n
k += 1
ans = 'YES' if A == B else 'NO'
print(ans)
``` | output | 1 | 74,592 | 8 | 149,185 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position. | instruction | 0 | 74,593 | 8 | 149,186 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
x = A.index(1)
y = B.index(1)
z = 0
for i in range(n):
x += A[(x + i) % n] == 0
y += B[(y + i) % n] == 0
z += A[(x + i) % n] == B[(y + i) % n]
#print(z)
if z == n:
print('YES')
else:
print('NO')
``` | output | 1 | 74,593 | 8 | 149,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position. | instruction | 0 | 74,594 | 8 | 149,188 |
Tags: constructive algorithms, implementation
Correct Solution:
```
#!/usr/bin/env python3
n = int(input())
a = [int(x) for x in input().split() if x != '0']
b = [int(x) for x in input().split() if x != '0']
# print(repr(a))
# print(repr(b))
for i in range(0, len(b)):
if b[i] == a[0]:
break
# print('i == {0}'.format(i))
result = True
k = 0
for j in range(i, len(b)):
# print('b[{0}] == {1}, a[{2}] == {3}'.format(j, b[j], k, a[k]))
if b[j] != a[k]:
result = False
break
k += 1
if result:
for j in range(0, i):
# print('b[{0}] == {1}, a[{2}] == {3}'.format(j, b[j], k, a[k]))
if b[j] != a[k]:
result = False
break
k += 1
if result:
print("YES")
else:
print("NO")
``` | output | 1 | 74,594 | 8 | 149,189 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position. | instruction | 0 | 74,595 | 8 | 149,190 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
a.remove(0)
b = list(map(int,input().split()))
b.remove(0)
start = b.index(a[0])
for i in range(n-1):
if a[i] != b[(i+start)%(n-1)]:
print('NO')
exit(0)
print('YES')
``` | output | 1 | 74,595 | 8 | 149,191 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position.
Submitted Solution:
```
n = int(input())
before = list(map(int, input().split()))
after = list(map(int, input().split()))
before.pop(before.index(0))
after.pop(after.index(0))
index = after.index(before[-1])
n -= 1
for i in range(1, n):
if after[(index - i + 1) % n] != before[-i % n]:
print('No')
break
else:
print('Yes')
``` | instruction | 0 | 74,596 | 8 | 149,192 |
Yes | output | 1 | 74,596 | 8 | 149,193 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position.
Submitted Solution:
```
n = int(input())
res = True
l = list(map(int, input().split()))
m = list(map(int, input().split()))
l.remove(0)
m.remove(0)
t = m.index(l[0])
for i in range(n - 1):
if l[i] != m[(i + t) % (n - 1)]:
res = False
if res:
print("YES")
else:
print("NO")
``` | instruction | 0 | 74,597 | 8 | 149,194 |
Yes | output | 1 | 74,597 | 8 | 149,195 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.remove(0)
b.remove(0)
print(('NO', 'YES')[''.join(map(str, b)) in ''.join(map(str, a + a))])
``` | instruction | 0 | 74,599 | 8 | 149,198 |
Yes | output | 1 | 74,599 | 8 | 149,199 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position.
Submitted Solution:
```
x=int(input())
y=list(map(int,input().split(' ')))
z=list(map(int,input().split(' ')))
kq=[i for i in y if i != 0]
jl=[i for i in z if i != 0]
o=[0]*200001
p=[0]*200001
t=[]
for i in range(len(kq)):
o[kq[i]] = i+1
for i in range(len(jl)):
p[jl[i]] = i+1
for i in range(1,x):
t.append(p[i]-o[i])
f=t[0]
s=0
for i in t:
if i!=f:
s=i
ff=t.count(f)
ss=t.count(s)
if ff+ss==len(t) and (ff==1 or ss==1):
print("YES")
else:
print("NO")
``` | instruction | 0 | 74,600 | 8 | 149,200 |
No | output | 1 | 74,600 | 8 | 149,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
pos = a.index(b[0])
col = 1
f = True
while col != n:
pos = (pos + 1) % n
if a[pos] == 0:
pos = (pos + 1) % n
elif b[col] == 0:
col += 1
else:
if a[pos] != b[col]:
f = False
break
else:
col += 1
if f:
print('YES')
else:
print('NO')
``` | instruction | 0 | 74,601 | 8 | 149,202 |
No | output | 1 | 74,601 | 8 | 149,203 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position.
Submitted Solution:
```
x=int(input())
if x==2:
print("YES")
quit()
y=list(map(int,input().split(' ')))
z=list(map(int,input().split(' ')))
kq=[i for i in y if i != 0]
jl=[i for i in z if i != 0]
o=[0]*200001
p=[0]*200001
t=[]
for i in range(len(kq)):
o[kq[i]] = i+1
for i in range(len(jl)):
p[jl[i]] = i+1
for i in range(1,x):
t.append((p[i]-o[i])%x)
if t.count(t[0])==len(t):
print("YES")
else:
print("NO")
``` | instruction | 0 | 74,602 | 8 | 149,204 |
No | output | 1 | 74,602 | 8 | 149,205 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.