input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import pprint
n = int(eval(input()))
ls = input().split()
lst = [int(e) for e in ls]
#print(lst)
m = n //2
d = n % 2
#print(m,d)
def ns ( l1, l2 ):
res = 0
for i in range(len(l1)):
res += l1[i]*l2[i]
return res
def mklst(no):
ret = []
if no % 2 == 0:
m = no // 2
for i in range(m+1):
wk = [0]*no
for j in range(m):
if j < i :
wk[j*2] = 1
else:
wk[j*2+1] = 1
ret.append(wk)
else:
#wk = [0]*no
if no == 1:
ret.append([0])
return ret
if no == 3:
ret.append([1,0,0])
ret.append([0,1,0])
ret.append([0,0,1])
return ret
for elst in mklst(no-1):
ret.append([0]+elst)
if no >= 5:
for elst in mklst(no-3):
ret.append([1,0]+elst+[0])
if no >= 5:
for elst in mklst(no-4):
ret.append([1,0]+elst+[0,1])
return ret
mmm = lst[0]
for el in mklst(n):
ans = ns(lst,el)
if mmm < ans :
mmm = ans
print(mmm)
| import pprint
n = int(eval(input()))
ls = input().split()
lst = [int(e) for e in ls]
m = n //2
d = n % 2
def sum_lst(plst):
no = len(plst)
ret = []
if no % 2 == 0:
m = no // 2
for i in range(m+1):
sum = 0
for j in range(m):
if j < i :
sum += plst[j*2]
else:
sum += plst[j*2+1]
ret.append(sum)
else:
if no == 1:
return [plst[0]]
if no == 3:
return [max(plst)]
for elst in sum_lst(plst[1:no]):
ret.append(elst)
if no >= 5:
for elst in sum_lst(plst[2:no-1]):
ret.append(plst[0]+elst)
if no >= 5:
for elst in sum_lst(plst[2:no-2]):
ret.append(plst[0]+elst+plst[no-1])
return [max(ret)]
mmm = sum_lst(lst)
print((mmm[0]))
| p02716 |
# coding: utf-8
N=int(eval(input()))
A=list(map(int,input().split()))
INF=10**18
dp=[[-INF for i in range(N+1)] for i in range(N+1)]
dp[0][0]=0
dp[1][0]=0
dp[2][0]=0
dp[1][1]=A[0]
dp[2][1]=A[1]
for i in range(3,N+1):
for j in range((i//2),((i+1)//2)+1):
dp[i][j]=max(dp[i-2][j-1]+A[i-1],dp[i-3][j-1]+A[i-1],dp[i-2][j],dp[i-3][j])
print((max(dp[N][N//2],dp[N-1][N//2],dp[N-2][N//2])))
| # coding: utf-8
N=int(eval(input()))
A=list(map(int,input().split()))
INF=10**18
dp=[[-INF for i in range(2)] for j in range(N+1)]
dp[0][0]=0
dp[1][0]=0
dp[2][0]=0
dp[1][1]=A[0]
dp[2][1]=A[1]
for i in range(3,N+1):
dp[i][0]=max(dp[i-2][0]+A[i-1],dp[i-2][1])
if i%2==0:
dp[i][0]=max(dp[i][0],dp[i-3][0]+A[i-1])
else:
dp[i][0]=max(dp[i][0],dp[i-3][1]+A[i-1])
dp[i][1]=dp[i-2][1]+A[i-1]
if i%2==0:
dp[i][1]=max(dp[i][1],dp[i-3][1]+A[i-1])
if N%2==0:
print((max(dp[N][1],dp[N-1][1])))
else:
print((max(dp[N][0],dp[N-1][1],dp[N-2][1])))
| p02716 |
import sys, math
def input(): return sys.stdin.readline().strip()
def main():
N = int(eval(input()))
A = [0] + list(map(int, input().split()))
"""
dp[i][j] = (1からi番目の数のうちどの２個も連続しないようにj個選んだ時の和の最大)
と置くらしい。何故その発想になるんだ？？
最初は左右で分けて尺取りみたいなことをすれば行けると思ったが、左右の分け目を１つずらしたら
最適解がガラッと変わって困った → じゃあDP、って感じなのかなあ
このままだとO(N^2)なので状態数を減らす。
１．j個は連続しないようにとるので、j <= (1 + i) // 2は確定。(iは1-indexedなことに注意)
２．残った(N - i)から連続しないように(N // 2 - j)個選ぶには、(N // 2 - j) <= (1 + N - i) // 2、
すなわち(i - 3) // 2 <= jが必要。
（j = 0,1,とか考えてもいいが、最終的にdp[N][N // 2]を求めるのにこれらは寄与しない）
以上より、(i - 3) // 2 <= j <= (i + 1) // 2の範囲のみでdpすれば十分。
肝心の遷移だが、A = [3, 1, 4, 1, 5, 9, 2]を例にとると
i\j| 0 1 2 3 4 dp[5][1] = max(A[5], dp[4][1])
---------------------- dp[5][2] = max(A[5] + dp[3][1], dp[4][2])
1| 0 3 dp[5][3] = A[5] + dp[3][2]
2| 0 3
3| 0 4 7 dp[6][2] = max(A[6] + dp[4][1], dp[5][2])
4| 4 7 dp[6][3] = max(A[6] + dp[4][2], dp[5][3])
5| 5 9 12
6| 9 12 のように、最後の数をとるか取らないかで場合分けすればよい。
7| 9 12 14 ただしiが奇数の場合、dp[i][(i + 1) // 2]は必ずA[i]を
加えざるを得ないため場合分けは起きないことに注意。
"""
dp = [[0] * (N // 2 + 2) for _ in range(N + 1)]
dp[1][1] = A[1]
dp[2][1] = max(A[1], A[2])
for i in range(3, N + 1):
if i % 2 == 0:
dp[i][i // 2 - 1] = max(A[i] + dp[i - 2][i // 2 - 1], dp[i - 1][i // 2 - 1])
dp[i][i // 2] = max(A[i] + dp[i - 2][i // 2 - 1], dp[i - 1][i // 2])
elif i > 3:
dp[i][(i - 3) // 2] = max(A[i] + dp[i - 2][(i - 5) // 2], dp[i - 1][(i - 3) // 2])
dp[i][(i - 1) // 2] = max(A[i] + dp[i - 2][(i - 3) // 2], dp[i - 1][(i - 1) // 2])
dp[i][(i + 1) // 2] = A[i] + dp[i - 2][(i - 1) // 2]
else:
dp[3][1] = max(A[1:4])
dp[3][2] = A[1] + A[3]
print((dp[N][N // 2]))
if __name__ == "__main__":
main()
| import sys, math
def input(): return sys.stdin.readline().strip()
def main():
N = int(eval(input()))
A = [0] + list(map(int, input().split()))
"""
dp[i][j] = (1からi番目の数のうちどの２個も連続しないようにj個選んだ時の和の最大)
と置くらしい。何故その発想になるんだ？？
最初は左右で分けて尺取りみたいなことをすれば行けると思ったが、左右の分け目を１つずらしたら
最適解がガラッと変わって困った → じゃあDP、って感じなのかなあ
このままだとO(N^2)なので状態数を減らす。
１．j個は連続しないようにとるので、j <= (1 + i) // 2は確定。(iは1-indexedなことに注意)
２．残った(N - i)から連続しないように(N // 2 - j)個選ぶには、(N // 2 - j) <= (1 + N - i) // 2、
すなわち(i - 3) // 2 <= jが必要。
（j = 0,1,とか考えてもいいが、最終的にdp[N][N // 2]を求めるのにこれらは寄与しない）
以上より、(i - 3) // 2 <= j <= (i + 1) // 2の範囲のみでdpすれば十分。
肝心の遷移だが、A = [3, 1, 4, 1, 5, 9, 2]を例にとると
i\j| 0 1 2 3 4 dp[5][1] = max(A[5], dp[4][1])
---------------------- dp[5][2] = max(A[5] + dp[3][1], dp[4][2])
1| 0 3 dp[5][3] = A[5] + dp[3][2]
2| 0 3
3| 0 4 7 dp[6][2] = max(A[6] + dp[4][1], dp[5][2])
4| 4 7 dp[6][3] = max(A[6] + dp[4][2], dp[5][3])
5| 5 9 12
6| 9 12 のように、最後の数をとるか取らないかで場合分けすればよい。
7| 9 12 14 ただしiが奇数の場合、dp[i][(i + 1) // 2]は必ずA[i]を
加えざるを得ないため場合分けは起きないことに注意。
"""
# iの偶奇でdp[i]をeven, oddに分割してメモリ削減
odd = [0, A[1], 0]
even = [0, max(A[1], A[2])]
for i in range(3, N + 1):
if i % 2 == 0:
even[0] = max(A[i] + even[0], odd[1])
even[1] = max(A[i] + even[1], odd[2])
elif i > 3:
odd[0] = max(A[i] + odd[0], even[0])
odd[1] = max(A[i] + odd[1], even[1])
odd[2] = A[i] + odd[2]
else:
odd[1] = max(A[1:4])
odd[2] = A[1] + A[3]
if N % 2 == 0:
print((even[1]))
else:
print((odd[1]))
if __name__ == "__main__":
main()
| p02716 |
import sys
sys.setrecursionlimit(10**6)
N = int(eval(input()))
A = [int(i) for i in input().split()]
def f(i,j):
a = 0
if not 2*j-1 <= i <= 2*j+1+(N-2*int(N/2)):
a = 0
elif i == 1 and j == 0:
a = 0
elif i == 1 and j == 1:
a = A[0]
elif i == 2 and j == 1:
a = max(A[0],A[1])
elif i == 2 and j == 0:
a = 0
else:
a = max(f(i-2,j-1)+A[i-1],f(i-1,j))
return a
print((f(N,int(N/2)))) | import math
N = int(eval(input()))
A = list(map(int, input().split()))
B = [{} for _ in range(N+1)]
for i in range(1,N+1):
if i == 1:
B[1][0] = 0
B[1][1] = A[0]
elif i == 2:
B[2][1] = max(A[0],A[1])
if N % 2 == 1:
B[2][0] = 0
else:
if N % 2 == 0:
for j in range(math.ceil((i-1)/2),(i+1)//2+1):
m1 = B[i-2][j-1]+A[i-1] if j-1 in B[i-2] else -float('inf')
m2 = B[i-1][j] if j in B[i-1] else -float('inf')
B[i][j] = max(m1,m2)
else:
for j in range(math.ceil((i-2)/2),(i+1)//2+1):
m1 = B[i-2][j-1]+A[i-1] if j-1 in B[i-2] else -float('inf')
m2 = B[i-1][j] if j in B[i-1] else -float('inf')
B[i][j] = max(m1,m2)
print((B[N][N//2]))
| p02716 |
import sys
#import copy
#import numpy as np
#import itertools
#import collections
#from collections import deque
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
#read = sys.stdin.buffer.read
inf = float('inf')
def main():
# input
N = int(readline())
A = list(map(int, readline().split()))
K = N//2
DP = [[-inf] * (K) for _ in range(N)]
DP[0][0] = A[0]
DP[1][0] = max(A[0], A[1])
for i in range(2, N):
i2 = i+1
start = max(0, i2//2 - 1)
end = min((i2 + 1)//2, K)
for j in range(start, end):
if j == 0:
DP[i][j] = max(A[i], DP[i-1][j])
else:
DP[i][j] = max(DP[i-2][j-1] + A[i], DP[i-1][j])
ans = DP[N-1][K-1]
#print(DP)
print(ans)
if __name__ == "__main__":
main()
| import sys
#import copy
#import numpy as np
#import itertools
#import collections
#from collections import deque
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
#read = sys.stdin.buffer.read
inf = float('inf')
#inf = pow(10, 10)
def main():
# input
N = int(readline())
A = list(map(int, readline().split()))
K = N//2
DP0 = [-inf] * N
DP1 = [-inf] * N
DP2 = [-inf] * N
DP2[0] = A[0]
DP2[1] = max(A[0], A[1])
DP1[:2] = [0] * 2
DP0[:4] = [0] * 4
for i in range(2, N):
if i%2 == 0:
DP2[i] = DP2[i-2] + A[i]
DP1[i] = max(DP2[i-1], DP1[i-2] + A[i])
DP0[i] = max(DP1[i-1], DP0[i-2] + A[i])
else:
DP2[i] = max(DP2[i-2] + A[i], DP2[i-1])
DP1[i] = max(DP1[i-1], DP1[i-2] + A[i])
DP0[i] = max(DP0[i-1], DP0[i-2] + A[i])
if N%2 == 0:
ans = DP2[N-1]
else:
ans = DP1[N-1]
#print(DP0)
#print(DP1)
#print(DP2)
print(ans)
if __name__ == "__main__":
main()
| p02716 |
def calc():
n=int(eval(input()))
arr=list(map(int,input().split()))
acum1=[0]
acum2=[0]
for i in range(n):
if i%2==0:
acum1.append(acum1[-1]+arr[i])
acum2.append(acum2[-1]+0)
else:
acum1.append(acum1[-1]+0)
acum2.append(acum2[-1]+arr[i])
if n%2==0:
ans=max(acum1[n-1],acum2[n])
for i in range(1,n+1,2):
if i+3>n:
continue
tmp=(acum1[i]-acum1[0])+(acum2[n]-acum2[i+2])
ans=max(ans,tmp)
else:
ans=max(acum1[n-2]-acum1[0],acum2[n-1]-acum2[1],acum1[n]-acum1[2])
for i in range(1,n+1,2):
if i+3>n-1:
continue
tmp=(acum1[i]-acum1[0])+(acum2[n-1]-acum2[i+2])
ans=max(ans,tmp)
for i in range(2,n+1,2):
if i+3>n:
continue
tmp=(acum2[i]-acum2[1])+(acum1[n]-acum1[i+2])
ans=max(ans,tmp)
for i in range(1,n+1,2):
if i+4>n:
continue
tmp=(acum1[i]-acum1[0])+(acum1[n]-acum1[i+3])
ans=max(ans,tmp)
for i in range(1,n+1,2):
for j in range(i+3,n+1,2):
if j+3>n:
continue
tmp=(acum1[i]-acum1[0]-acum2[i+2])+(acum2[j]+acum1[n]-acum1[j+2])
ans=max(ans,tmp)
print(ans)
calc() | n=int(eval(input()))
arr=list(map(int,input().split()))
if n<=3:
print((max(arr)))
exit()
lim=n%2+2
dp=[[0]*lim for _ in range(n+1)]
for i in range(n):
dp[i+1][0]=dp[i-1][0]+arr[i]
dp[i+1][1]=max(dp[i-1][1]+arr[i],dp[i-2][0]+arr[i])
if lim==3:
dp[i+1][2]=max(dp[i-1][2]+arr[i],dp[i-2][1]+arr[i],dp[i-3][0]+arr[i])
print((max(dp[-1][:lim]))) | p02716 |
import sys
input=sys.stdin.readline
n=int(eval(input()))
a=list(map(int,input().split()))
m=n//2
dp=[[-10**18]*n for _ in range(m)]
if n%2==0:
dp[0][0]=a[0]
dp[0][1]=a[1]
for i in range(1,m):
for j in range(2*i,2*(i+1)):
for k in range(2*(i-1),2*i):
if j-k>1:
dp[i][j]=max(dp[i][j],dp[i-1][k]+a[j])
else:
dp[0][0]=a[0]
dp[0][1]=a[1]
dp[0][2]=a[2]
for i in range(1,m):
for j in range(2*i,2*(i+1)+1):
for k in range(2*(i-1),2*i+1):
if j-k>1:
#print(j)
dp[i][j]=max(dp[i][j],dp[i-1][k]+a[j])
print((max(dp[-1]))) | import sys
input=sys.stdin.readline
n=int(eval(input()))
a=list(map(int,input().split()))
m=n//2
if n%2==0:
dp=[[-10**18]*2 for _ in range(m)]
dp[0][0]=a[0]
dp[0][1]=a[1]
for i in range(1,m):
for j in range(2*i,2*(i+1)):
for k in range(2*(i-1),2*i):
if j-k>1:
dp[i][j%2]=max(dp[i][j%2],dp[i-1][k%2]+a[j])
else:
dp=[[-10**18]*3 for _ in range(m)]
dp[0][0]=a[0]
dp[0][1]=a[1]
dp[0][2]=a[2]
for i in range(1,m):
for j in range(2*i,2*(i+1)+1):
for k in range(2*(i-1),2*i+1):
if j-k>1:
dp[i][j-2*i]=max(dp[i][j-2*i],dp[i-1][k-2*(i-1)]+a[j])
print((max(dp[-1]))) | p02716 |
N = int(eval(input()))
A = list(map(int,input().split()))
s = [0]*N
for i in range(N):
s[i] = s[i-2]+A[i]
dp = [0]*N
dp[1] = max(A[0],A[1])
if N>=3:
dp[2] = max(A[0],A[1],A[2])
for n in range(3,N):
if n%2==1:
dp[n] = max(A[n]+dp[n-2],s[n-1])
else:
dp[n] = max(A[n]+dp[n-2],A[n-1]+dp[n-3],s[n-2])
print((dp[-1])) | N = int(eval(input()))
A = list(map(int,input().split()))
s = [0]*N
for i in range(N):
s[i] = s[i-2]+A[i]
dp = [0]*N
for n in range(N):
if n%2==1:
dp[n] = max(A[n]+dp[n-2],s[n-1])
else:
dp[n] = max(A[n]+dp[n-2],dp[n-1])
print((dp[-1])) | p02716 |
n = int(eval(input()))
A = list(map(int,input().split()))
def zenbu(m, B):
dp = [-10**9]*m
if dp[m-1] > -10**9:
return dp[m-1]
elif m == 1:
dp[0] = B[0]
return dp[0]
elif m == 2:
dp[1] = max(B[0],B[1])
return dp[1]
elif m == 3:
dp[2] = max(B[0],B[1],B[2])
return dp[2]
elif m%2 == 0: #偶数の場合
temp = 0
for i in range(m//2-1):
temp += B[i*2]
dp[m-1] = max(temp+ max(B[m-2],B[m-1]), zenbu(m-2, B)+ B[m-1])
return dp[m-1]
else:#奇数の場合
temp = 0
for i in range((m-1)//2):
temp += B[i*2]
dp[m-1] = max(temp, zenbu(m-2,B)+ B[m-1], zenbu(m-3,B)+ max(B[m-2],B[m-1]))
return dp[m-1]
ans = zenbu(n,A)
print(ans) | import sys
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int,input().split()))
if N%2 == 0:
dp = [[0]*2 for _ in range(N)] #0index
dp[0][0] = A[0]
dp[1][1] = A[1]
for i in range(2,N):
dp[i][0] = dp[i-2][0]+A[i]
if i-3>=0:
dp[i][1] = max(dp[i-2][1],dp[i-3][0])+A[i]
else:
dp[i][1] = max(dp[i-2][1],0)+A[i]
ans = max(dp[-2][0],dp[-1][1])
print(ans)
#i個目を使ってj(0-2)回多く飛んでいる。
else: #N%2 == 1:
dp = [[0]*3 for _ in range(N)] #0index
dp[0][0] = A[0]
dp[1][1] = A[1]
dp[2][2] = A[2]
dp[2][0] = A[0]+A[2]
#print(dp)
for i in range(3,N):
dp[i][0] = dp[i-2][0]+A[i]
if i-3 >= 0:
dp[i][1] = max(dp[i-2][1],dp[i-3][0])+A[i]
else:
dp[i][1] = max(dp[i-2][1],0)+A[i]
if i-4 >= 0:
dp[i][2] = max(dp[i-2][2],dp[i-3][1],dp[i-4][0])+A[i]
elif i-3 >= 0:
dp[i][2] = max(dp[i-2][2],dp[i-3][1],0)+A[i]
#else:
# dp[i][2] = max(dp[i-2][2],0,0)+A[i]
#print(dp[-1],dp[-2],dp[-3])
ans = max(dp[-3][0],dp[-2][1],dp[-1][2])
print(ans)
exit() | p02716 |
# -*- coding: utf-8 -*-
"""
Spyder Editor
This is a temporary script file.
"""
#f = open("C:/Users/naoki/Desktop/Atcoder/input.txt")
N = int(eval(input()))
A = list(map(int, input().split()))
A.insert(0, 0)
select_num = N//2
Dp_f = [[-9999]*(N+1) for _ in range(N+1)]
Dp_s = [[-9999]*(N+1) for _ in range(N+1)]
for i in range(1,N+1):
Start = (i-1)//2
End = (i+1)//2
for j in range(Start,End+1):
Dp_f[i][j] = max(Dp_s[i-1][j], Dp_f[i-1][j])
# [0] in 3rd dimension not chosen at last num
# must be transfered from [i-1]
for j in range(Start,End+1):
if Dp_f[i-1][j-1] == -9999 and j == 1:
Dp_s[i][j] = 0 + A[i]
else:
Dp_s[i][j] = Dp_f[i-1][j-1]+A[i]
print((max(Dp_f[-1][select_num], Dp_s[-1][select_num])))
|
#f = open("C:/Users/naoki/Desktop/Atcoder/input.txt")
N = int(eval(input()))
A = list(map(int, input().split()))
A.insert(0, 0)
select_num = N//2
inf = -10e+100
Dp_f = [[inf] * (3) for _ in range(N+1)]
Dp_s = [[inf] * (3) for _ in range(N+1)]
# 3 次元はそれぞれStart~3つに該当
pre_margin = 0
for i in range(1,N+1):
Start = (i-1)//2
End = (i+1)//2
cur_margin = Start
for j in range(Start,End+1):
Dp_f[i][j-cur_margin] = max(Dp_s[i-1][j-pre_margin], Dp_f[i-1][j-pre_margin])
# [0] in 3rd dimension not chosen at last num
# must be transfered from [i-1]
for j in range(Start,End+1):
if j-1 == 0:
Dp_s[i][j-cur_margin] = 0 + A[i]
else:
Dp_s[i][j-cur_margin] = Dp_f[i-1][j-1-pre_margin]+A[i]
pre_margin = cur_margin
print((max(Dp_f[-1][select_num - cur_margin], Dp_s[-1][select_num - cur_margin])))
| p02716 |
# unfinished
INF = 1 << 64
def find_max(a):
n = len(a)
odd_a = [a[i] for i in range(n) if i % 2 == 0]
even_a = [a[i] for i in range(n) if i % 2 == 1]
cum_odd_a = [0]
sum_odd_a = 0
for odd_a_elem in odd_a:
cum_odd_a.append(cum_odd_a[-1] + odd_a_elem)
sum_odd_a += odd_a_elem
cum_even_a = [0]
sum_even_a = 0
for even_a_elem in even_a:
cum_even_a.append(cum_even_a[-1] + even_a_elem)
sum_even_a += even_a_elem
max_sum_half_a = -INF
if n % 2 == 0: # nが偶数である場合
# 奇数と偶数の境目
for i in range(n // 2 + 1):
odd_part_sum = cum_odd_a[i]
even_part_sum = sum_even_a - cum_even_a[i]
sum_half_a = odd_part_sum + even_part_sum
if sum_half_a > max_sum_half_a:
max_sum_half_a = sum_half_a
else: # nが奇数である場合
# 奇数と偶数の境目
for i in range(n // 2 + 1):
odd_part_sum_1 = cum_odd_a[i]
# 偶数と奇数の境目
for j in range(i, n // 2 + 1):
even_part_sum = cum_even_a[j] - cum_even_a[i]
odd_part_sum_2 = sum_odd_a - cum_odd_a[j + 1]
sum_half_a = odd_part_sum_1 + even_part_sum + odd_part_sum_2
if sum_half_a > max_sum_half_a:
max_sum_half_a = sum_half_a
return max_sum_half_a
def main():
_ = int(eval(input()))
a = list(map(int, input().split()))
print((find_max(a)))
main()
| def find_max(a):
n = len(a)
if n <= 3:
return max(a)
dp = [[-(1 << 64)] * (2 + n % 2) for _ in range(n)]
for i in range(2 + n % 2):
dp[i][i] = a[i]
dp[i + 1][i] = a[i]
for i in range(2, n):
for j in range(2 + n % 2):
for extra_space in range(j + 1):
curr_sum = dp[i - (2 + extra_space)][j - extra_space] + a[i]
if curr_sum > dp[i][j]:
dp[i][j] = curr_sum
return dp[-1][1 + n % 2]
def main():
_ = int(eval(input()))
a = list(map(int, input().split()))
print((find_max(a)))
main()
| p02716 |
n=int(eval(input()))
a=list(map(int,input().split()))
if n<=3:print((max(a)));exit()
if n&1:
dp=[3*[-(10**20)]for _ in range(n)]
dp[0][0]=a[0]
for i in range(1,n):
if i%2==0:
dp[i][0]=dp[i-2][0]+a[i]
if i>=3:dp[i][2]=max(dp[i-2][2]+a[i],dp[i-3][1]+a[i])
else:dp[i][2]=a[i]
else:
if i>=3:dp[i][1]=max(dp[i-2][1]+a[i],dp[i-3][0]+a[i])
else:dp[i][1]=a[i]
print((max(dp[-1][2],dp[-2][1],dp[-3][0])))
else:
b=[a[0]]
c=[a[1]]
for i in range(2,n):
if i%2==0:b.append(b[-1]+a[i])
else:c.append(c[-1]+a[i])
ans=max(b[-1],c[-1])
for i in range(n//2-1):
ans=max(ans,b[i]+c[-1]-c[i])
print(ans)
| n=int(eval(input()));l=list(map(int,input().split()));p=[0]*n;d=[0]*n
for i in range(n):p[i]=l[i]+(p[i-2]if i>1else 0)
for i in range(1,n):
d[i]=p[i-1]if(i&1)else d[i-1]
d[i]=max(d[i],l[i]+(d[i-2]if i>1else 0))
print((d[-1])) | p02716 |
n=int(eval(input()));l=list(map(int,input().split()));p=[0]*n;d=[0]*n
for i in range(n):p[i]=l[i]+(p[i-2]if i>1else 0)
for i in range(1,n):
d[i]=p[i-1]if(i&1)else d[i-1]
d[i]=max(d[i],l[i]+(d[i-2]if i>1else 0))
print((d[-1])) | n=int(eval(input()));l=list(map(int,input().split()));p=[0]*n;d=[0]*n;p[0]=l[0]
for i in range(1,n):p[i]=l[i]+(p[i-2]if i>1else 0);d[i]=max(p[i-1]if(i&1)else d[i-1],l[i]+(d[i-2]if i>1else 0))
print((d[-1])) | p02716 |
n=int(eval(input()));l=list(map(int,input().split()));p=[0]*n;d=[0]*n;p[0]=l[0]
for i in range(1,n):p[i]=l[i]+(p[i-2]if i>1else 0);d[i]=max(p[i-1]if(i&1)else d[i-1],l[i]+(d[i-2]if i>1else 0))
print((d[-1])) | n=int(eval(input()));l=list(map(int,input().split()));p=[0]*n;d=[0]*n;p[0]=l[0]
for i in range(1,n):p[i]=l[i]+p[i-2];d[i]=max(p[i-1]if(i&1)else d[i-1],l[i]+(d[i-2]if i>1else 0))
print((d[-1])) | p02716 |
n=int(eval(input()));l=list(map(int,input().split()));p=[0]*n;d=[0]*n;p[0]=l[0]
for i in range(1,n):p[i]=l[i]+p[i-2];d[i]=max(p[i-1]if(i&1)else d[i-1],l[i]+(d[i-2]if i>1else 0))
print((d[-1])) | n=int(eval(input()));l=list(map(int,input().split()));p=[0]*n;d=[0]*n;p[0]=l[0]
for i in range(1,n):p[i]=l[i]+p[i-2];d[i]=max(p[i-1]if(i&1)else d[i-1],l[i]+d[i-2])
print((d[-1])) | p02716 |
N = int(eval(input()))
A = list(map(int, input().split()))
# if N % 2 == 0: #偶数のとき
# B = [0] * (N // 2 + 1)
# W = [0] * (N // 2 + 1)
# for i in range(N // 2):
# B[i + 1] = B[i] + A[2 * i]
# for i in range(N // 2 - 1, -1, -1):
# W[i] = W[i + 1] + A[2 * i + 1]
# # print (B)
# # print (W)
# ans = 0
# for i in range(N // 2 + 1):
# ans = max(ans, B[i] + W[i])
# print (ans)
# exit()
DP0 = [[-10 ** 16] * 2 for _ in range(N + 1)]
DP1 = [[-10 ** 16] * 2 for _ in range(N + 1)]
DP2 = [[-10 ** 16] * 2 for _ in range(N + 1)]
DP0[N][0] = 0 #右端の外側を0に設定してスタート
for i in range(N - 1, -1, -1):
a = A[i]
DP0[i][0] = DP0[i + 1][1]
DP0[i][1] = DP0[i + 1][0] + a
DP1[i][0] = max(DP1[i + 1][1], DP0[i + 1][0])
DP1[i][1] = DP1[i + 1][0] + a
DP2[i][0] = max(DP2[i + 1][1], DP1[i + 1][0])
DP2[i][1] = DP2[i + 1][0] + a
if N % 2 == 1:
print((max(DP1[0][0], DP2[0][1])))
else:
print((max(DP0[0][0], DP1[0][1])))
# for i in DP0:
# print (i)
# for i in DP1:
# print (i)
# for j in DP2:
# print (j) | N = int(eval(input()))
A = list(map(int, input().split()))
if N % 2 == 0: #偶数のとき
B = [0] * (N // 2 + 1)
W = [0] * (N // 2 + 1)
for i in range(N // 2):
B[i + 1] = B[i] + A[2 * i]
for i in range(N // 2 - 1, -1, -1):
W[i] = W[i + 1] + A[2 * i + 1]
# print (B)
# print (W)
ans = -10 ** 16
for i in range(N // 2 + 1):
ans = max(ans, B[i] + W[i])
print (ans)
exit()
DP0 = [[-10 ** 16] * 2 for _ in range(N + 1)]
DP1 = [[-10 ** 16] * 2 for _ in range(N + 1)]
DP2 = [[-10 ** 16] * 2 for _ in range(N + 1)]
DP0[N][0] = 0 #右端の外側を0に設定してスタート
for i in range(N - 1, -1, -1):
a = A[i]
DP0[i][0] = DP0[i + 1][1]
DP0[i][1] = DP0[i + 1][0] + a
DP1[i][0] = max(DP1[i + 1][1], DP0[i + 1][0])
DP1[i][1] = DP1[i + 1][0] + a
DP2[i][0] = max(DP2[i + 1][1], DP1[i + 1][0])
DP2[i][1] = DP2[i + 1][0] + a
if N % 2 == 1:
print((max(DP1[0][0], DP2[0][1])))
else:
print((max(DP0[0][0], DP1[0][1])))
# for i in DP0:
# print (i)
# for i in DP1:
# print (i)
# for j in DP2:
# print (j) | p02716 |
C = -(10**9 + 7)
def main():
from collections import defaultdict
N = int(eval(input()))
K = N//2
A = [int(i) for i in input().split()]
dp = defaultdict(lambda: C)
for i in range(N+1):
dp[(i, 0)] = 0
if i != 0:
dp[(i, 1)] = max(dp[(i-1, 1)], A[i-1])
for i in range(2, N+1):
for j in range((i+2)//2-1, (i+2)//2 + 1):
if j < 0:
continue
cur = dp[(i, j)]
for k in range(2, i+1-j):
if 0 < i-k <= N:
cur = max(cur, dp[(i-k, j-1)] + A[i-1])
dp[(i, j)] = cur
print((dp[(N, K)]))
if __name__ == '__main__':
main()
| C = -(10**15 + 7)
def main():
from collections import defaultdict
N = int(eval(input()))
K = N//2
A = [int(i) for i in input().split()]
dp = defaultdict(lambda: C)
for i in range(N+1):
dp[i, 0] = 0
if i != 0:
dp[(i, 1)] = max(dp[i-1, 1], A[i-1])
for i in range(2, N+1):
for j in range(i//2-1, (i+1)//2 + 1):
if j < 0:
continue
# A_i(1-index)でj個選ばなければいけない
dp[i, j] = max(dp[i, j], dp[i-2, j-1] + A[i-1],
dp[i-3, j-1] + A[i-1], dp[i-4, j-1] + A[i-1])
print((max(dp[N, K], dp[N-1, K], dp[N-2, K])))
# for i in range(N+1):
# for j in range(K+1):
# print("{:>4}".format(dp[i, j] if dp[i, j] != C else "C"),
# end=" " if j != K else "\n")
if __name__ == '__main__':
main()
| p02716 |
C = -(10**15 + 7)
def main():
from collections import defaultdict
N = int(eval(input()))
K = N//2
A = [int(i) for i in input().split()]
dp = defaultdict(lambda: C)
for i in range(N+1):
dp[i, 0] = 0
if i != 0:
dp[(i, 1)] = max(dp[i-1, 1], A[i-1])
for i in range(2, N+1):
for j in range(i//2-1, (i+1)//2 + 1):
if j < 0:
continue
# A_i(1-index)でj個選ばなければいけない
dp[i, j] = max(dp[i, j], dp[i-2, j-1] + A[i-1],
dp[i-3, j-1] + A[i-1], dp[i-4, j-1] + A[i-1])
print((max(dp[N, K], dp[N-1, K], dp[N-2, K])))
# for i in range(N+1):
# for j in range(K+1):
# print("{:>4}".format(dp[i, j] if dp[i, j] != C else "C"),
# end=" " if j != K else "\n")
if __name__ == '__main__':
main()
| def main():
N = int(eval(input()))
A = [int(i) for i in input().split()]
if N % 2 == 0:
dp = [[0]*2 for _ in range(N//2 + 1)]
for i in range(N//2):
dp[i+1][0] = dp[i][0] + A[2*i]
dp[i+1][1] = max(dp[i][0], dp[i][1]) + A[2*i+1]
print((max(dp[-1])))
else:
dp = [[0]*3 for _ in range(N//2 + 1)]
for i in range(N//2):
dp[i+1][0] = dp[i][0] + A[2*i]
dp[i+1][1] = max(dp[i][0], dp[i][1]) + A[2*i+1]
dp[i+1][2] = max(dp[i][0], dp[i][1], dp[i][2]) + A[2*i+2]
print((max(dp[-1])))
if __name__ == '__main__':
main()
| p02716 |
n = int(eval(input()))
A = list(map(int, input().split()))
pick_DP = [-float('INF')] * n
unpick_DP = [-float('INF')] * n
pick_DP[0] = 0
unpick_DP[0] = 0
for i, a in enumerate(A, 1):
mini = (i-1)//2 - 1
if mini <= 0:
mini = 1
maxi = (i+1)//2
temp = []
for num in range(mini, maxi+1):
temp.append(pick_DP[num])
pick_DP[num] = max(unpick_DP[num-1] + a, pick_DP[num])
for num, pre_pick in enumerate(temp, mini):
if unpick_DP[num] < pre_pick:
unpick_DP[num] = pre_pick
print((max(pick_DP[n//2], unpick_DP[n//2]))) | n = int(eval(input()))
A = list(map(int, input().split()))
pick_DP = [-float('INF')] * (n//2 + 2)
unpick_DP = [-float('INF')] * (n//2 + 2)
pick_DP[0] = 0
unpick_DP[0] = 0
for i, a in enumerate(A, 1):
mini = (i-1)//2 - 1
if mini <= 0:
mini = 1
maxi = (i+1)//2
for num in range(maxi, mini-1, -1):
if unpick_DP[num] < pick_DP[num]:
unpick_DP[num] = pick_DP[num]
pick_DP[num] = max(unpick_DP[num-1] + a, pick_DP[num])
print((max(pick_DP[n//2], unpick_DP[n//2]))) | p02716 |
#!/usr/bin/env python3
# coding: utf-8
import collections
import math
def debug(arg):
if __debug__:
pass
else:
import sys
print(arg, file=sys.stderr)
N, *A = map(int, open(0).read().split())
a = dict(enumerate(A, 1))
# dp = collections.defaultdict(int)
dp = collections.defaultdict(lambda: -float("inf"))
dp[0, 0] = 0
dp[1, 0] = 0
dp[1, 1] = a[1]
for i in range(2, N + 1):
jj = range(max(math.floor(i // 2 - 1), 1), math.ceil((i + 1) // 2) + 1)
debug(jj)
for j in jj:
x = dp[i - 2, j - 1] + a[i]
y = dp[i - 1, j]
dp[i, j] = max(x, y)
debug([i - 2, j - 1])
debug([i - 1, j])
debug([i, j])
debug(dp[i, j])
print(dp[N, N // 2])
| #!/usr/bin/env python3
# coding: utf-8
import collections
import math
def debug(arg):
if __debug__:
pass
else:
import sys
print(arg, file=sys.stderr)
def main():
pass
N, *A = map(int, open(0).read().split())
a = dict(enumerate(A, 1))
dp = collections.defaultdict(lambda: -float("inf"))
dp[0, 0] = 0
dp[1, 0] = 0
dp[1, 1] = a[1]
for i in range(2, N + 1):
jj = range(max(math.floor(i // 2 - 1), 1), math.ceil((i + 1) // 2) + 1)
for j in jj:
x = dp[i - 2, j - 1] + a[i]
y = dp[i - 1, j]
dp[i, j] = max(x, y)
print(dp[N, N // 2])
if __name__ == "__main__":
main()
| p02716 |
#!/usr/bin/env python3
# coding: utf-8
import collections
import math
def debug(arg):
if __debug__:
pass
else:
import sys
print(arg, file=sys.stderr)
def main():
pass
N, *A = map(int, open(0).read().split())
a = dict(enumerate(A, 1))
dp = collections.defaultdict(lambda: -float("inf"))
dp[0, 0] = 0
dp[1, 0] = 0
dp[1, 1] = a[1]
for i in range(2, N + 1):
jj = range(max(math.floor(i // 2 - 1), 1), math.ceil((i + 1) // 2) + 1)
for j in jj:
x = dp[i - 2, j - 1] + a[i]
y = dp[i - 1, j]
dp[i, j] = max(x, y)
print(dp[N, N // 2])
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
# coding: utf-8
import collections
def debug(arg):
if __debug__:
pass
else:
import sys
print(arg, file=sys.stderr)
def main():
pass
N, *A = map(int, open(0).read().split())
a = dict(enumerate(A, 1))
dp = collections.defaultdict(lambda: -float("inf"))
dp[0, 0] = 0
dp[1, 0] = 0
dp[1, 1] = a[1]
for i in range(2, N + 1):
jj = range(max(i // 2 - 1, 1), (i + 1) // 2 + 1)
for j in jj:
x = dp[i - 2, j - 1] + a[i]
y = dp[i - 1, j]
dp[i, j] = max(x, y)
print(dp[N, N // 2])
if __name__ == "__main__":
main()
| p02716 |
N = int(eval(input()))
A = list(map(int, input().split()))
INF = 10**18
dp0 = [-INF] * (N + 2)
dp1 = [-INF] * (N + 2)
dp2 = [-INF] * (N + 2)
dp0[0] = 0
dp0[1] = 0
dp1[0] = 0
dp1[1] = 0
for i, a in enumerate(A, start=2):
dp0[i] = dp0[i - 2] + a
dp1[i] = max(dp1[i - 2] + a, dp0[i - 1])
dp2[i] = max(dp2[i - 2] + a, dp1[i - 1], dp0[i - 2])
if N % 2 == 1:
print((dp2[-1]))
else:
print((max(dp1[-1], dp0[-1])))
| N = int(eval(input()))
A = list(map(int, input().split()))
INF = 10**18
dp0 = 0
dp1 = -INF
dp2 = -INF
for i, a in enumerate(A):
if i % 2 == 0:
dp1 = max(dp1, dp0)
dp0 += a
dp2 += a
else:
dp2 = max(dp2, dp1)
dp1 += a
if N % 2 == 1:
print((max(dp1, dp2)))
else:
print((max(dp0, dp1)))
| p02716 |
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
#solve
def solve():
n = II()
a = LI()
if n == 3:
print((max(a)))
return
dp = [[-inf] * 3 for i in range(n + 1)]
dp[0] = [0, 0, 0]
dp[1][0] = a[0]
dp[2][1] = a[1]
for i in range(3, n+1):
dp[i][0] = dp[i - 2][0] + a[i-1]
dp[i][1] = max(dp[i - 2][1], dp[i - 3][0]) + a[i-1]
dp[i][2] = max(dp[i - 2][2], dp[i - 3][1], dp[i - 4][0]) + a[i-1]
if n & 1:
print((max(dp[-3][0], dp[-1][1], dp[-1][2])))
else:
print((max(dp[-1][1], dp[-2][0])))
return
#main
if __name__ == '__main__':
solve()
| #!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
#solve
def solve():
n = II()
a = LI()
if n == 3:
print((max(a)))
return
dp = [[-inf] * 3 for i in range(n + 1)]
dp[0] = [0, 0, 0]
dp[1][0] = a[0]
dp[2][1] = a[1]
for i in range(3, n+1):
dp[i][0] = dp[i - 2][0] + a[i-1]
dp[i][1] = max(dp[i - 2][1], dp[i - 3][0]) + a[i-1]
dp[i][2] = max(dp[i - 2][2], dp[i - 3][1], dp[i - 4][0]) + a[i-1]
if n & 1:
print((max(dp[-3][0], dp[-2][1], dp[-1][2])))
else:
print((max(dp[-1][1], dp[-2][0])))
return
#main
if __name__ == '__main__':
solve()
| p02716 |
from collections import defaultdict
N,*A = list(map(int, open(0).read().split()))
dp_not = defaultdict(lambda :-10**18)
dp_take = defaultdict(lambda :-10**18)
dp_not[(0,0)] = 0
for i,x in enumerate(A,1):
for j in ((i-1)//2,(i-1)//2+1):
dp_not[(i,j)] = max(dp_not[(i-1,j)],dp_take[(i-1,j)])
dp_take[(i,j)] = dp_not[(i-1,j-1)] + x
print((max(dp_not[(N,N//2)], dp_take[(N,N//2)]))) | from collections import defaultdict
N,*A = list(map(int, open(0).read().split()))
dp_not = defaultdict(lambda :-10**18)
dp_take = defaultdict(lambda :-10**18)
dp_not[(0,0)] = 0
for i,x in enumerate(A,1):
for j in range(N//2-(N-i+1)//2,(i+1)//2+1):
dp_not[(i,j)] = max(dp_not[(i-1,j)],dp_take[(i-1,j)])
dp_take[(i,j)] = dp_not[(i-1,j-1)] + x
print((max(dp_not[(N,N//2)], dp_take[(N,N//2)])))
| p02716 |
N=int(eval(input()))
A=list(map(int,input().split()))
from collections import deque
q=deque([(-1,0,-2,0)])
ans=-10**18
for i,a in enumerate(A):
while q and q[0][0]<i:
j,n,r,x=q.popleft()
if r<-1:
if n==N//2-1:
ans=max(ans,x+a)
else:
q.append((i,n+1,-1,x+a))
if (j+1)//2<=n:
q.append((i,n,r-1,x))
print(ans) | N=int(eval(input()))
A=list(map(int,input().split()))
from collections import deque
q=deque([(-1,0,-2,0)])
ans=-10**18
for i,a in enumerate(A):
d={}
while q and q[0][0]<i:
j,n,r,x=q.popleft()
if r<-1:
if n==N//2-1:
ans=max(ans,x+a)
elif n not in d:
d[n]=x
elif d[n]<x:
d[n]=x
if (j+1)//2<=n:
q.append((i,n,r-1,x))
for n,x in list(d.items()):
q.append((i,n+1,-1,x+a))
print(ans) | p02716 |
import sys
n = int(eval(input()))
A = [int(_) for _ in input().split()]
# dp = [[0 for i in range((n//2)+1)] for j in range(n)]
if n == 1 or n == 2 or n == 3:
print((max(A)))
sys.exit()
dp = [[0, 0] for j in range(n)]
M = - float('inf')
for i in range(4):
M = max(M, A[i])
dp[i][0] = M
dp[2][1] = dp[0][0] + A[2]
dp[3][1] = max(dp[1][0] + A[3], dp[2][1])
# for i in range(len(dp)):
# print(dp[i])
# for i in range(4, n):
# for j in range(max(0, i // 2 - 1), (i + 2) // 2):
# # print(i, j)
# if i % 2 == 0 and j == (i + 2) // 2 - 1 :
# dp[i][j] = dp[i-2][j-1] + A[i]
# else:
# dp[i][j] = max(dp[i-2][j-1] + A[i], dp[i-1][j])
for i in range(4, n):
for j in range(2):
# print(i, j)
if i % 2 == 0 and j == 1:
dp[i][j] = dp[i-2][1] + A[i]
elif i % 2 == 0 and j == 0:
dp[i][j] = max(dp[i-2][0] + A[i], dp[i-1][1])
elif i % 2 == 1 and j == 1:
dp[i][j] = max(dp[i-2][1] + A[i], dp[i-1][1])
else:
dp[i][j] = max(dp[i-2][0] + A[i], dp[i-1][0])
# for i in range(len(dp)):
# print(dp[i])
print((dp[n-1][(n+1)%2])) | import sys
n = int(eval(input()))
A = [int(_) for _ in input().split()]
if n == 1 or n == 2 or n == 3:
print((max(A)))
sys.exit()
dp = [[0, 0] for j in range(n)]
M = - float('inf')
for i in range(4):
M = max(M, A[i])
dp[i][0] = M
dp[2][1] = dp[0][0] + A[2]
dp[3][1] = max(dp[1][0] + A[3], dp[2][1])
for i in range(4, n):
for j in range(2):
if i % 2 == 0 and j == 1:
dp[i][j] = dp[i-2][1] + A[i]
elif i % 2 == 0 and j == 0:
dp[i][j] = max(dp[i-2][0] + A[i], dp[i-1][1])
elif i % 2 == 1 and j == 1:
dp[i][j] = max(dp[i-2][1] + A[i], dp[i-1][1])
else:
dp[i][j] = max(dp[i-2][0] + A[i], dp[i-1][0])
print((dp[n-1][(n+1)%2])) | p02716 |
import sys
sys.setrecursionlimit(10**8)
n = int(eval(input()))
a = list(map(int, input().split()))
d = {}
def func(b, m):
if m == 0:
return 0
if m == 1:
return b[0]
if m == 2:
return max(b[0], b[1])
if m in d:
return d[m]
if m % 2 == 0:
ans0 = b[0] + func(b[2:], m - 2)
ans1 = sum(b[i] for i in range(1, m, 2))
ans = max(ans0, ans1)
else:
ans0 = b[0] + func(b[2:], m - 2)
ans1 = b[1] + func(b[3:], m - 3)
ans2 = sum(b[i] for i in range(2, m, 2))
ans = max(ans0, ans1, ans2)
d[m] = ans
return ans
ans = func(a, n)
print(ans)
| import sys
sys.setrecursionlimit(10**8)
n = int(eval(input()))
a = list(map(int, input().split()))
a_cs = [0] * (n + 1)
a_cs[-2] = a[-1]
for i in reversed(list(range(n - 1))):
a_cs[i] = a[i] + a_cs[i + 2]
# print(a_cs)
def func(i):
if i == n:
return 0
if i == n - 1:
return a[-1]
m = n - i
if m % 2 == 0:
ans0 = a[i] + func(i + 2)
ans1 = a_cs[i + 1]
ans = max(ans0, ans1)
else:
ans0 = a[i + 0] + func(i + 2)
ans1 = a[i + 1] + func(i + 3)
ans2 = a_cs[i + 2]
ans = max(ans0, ans1, ans2)
return ans
ans = func(0)
print(ans)
| p02716 |
import sys
sys.setrecursionlimit(10**8)
n = int(eval(input()))
a = list(map(int, input().split()))
a_cs = [0] * (n + 1)
a_cs[-2] = a[-1]
for i in reversed(list(range(n - 1))):
a_cs[i] = a[i] + a_cs[i + 2]
# print(a_cs)
def func(i):
if i == n:
return 0
if i == n - 1:
return a[-1]
m = n - i
if m % 2 == 0:
ans0 = a[i] + func(i + 2)
ans1 = a_cs[i + 1]
ans = max(ans0, ans1)
else:
ans0 = a[i + 0] + func(i + 2)
ans1 = a[i + 1] + func(i + 3)
ans2 = a_cs[i + 2]
ans = max(ans0, ans1, ans2)
return ans
ans = func(0)
print(ans)
| import sys
sys.setrecursionlimit(10**8)
n = int(eval(input()))
a = list(map(int, input().split()))
a_cs = [0] * (n + 1)
a_cs[-2] = a[-1]
for i in reversed(list(range(n - 1))):
a_cs[i] = a[i] + a_cs[i + 2]
# print(a_cs)
d = {}
def func(i):
if i == n:
return 0
if i == n - 1:
return a[-1]
if i in d:
return d[i]
m = n - i
if m % 2 == 0:
ans0 = a[i] + func(i + 2)
ans1 = a_cs[i + 1]
ans = max(ans0, ans1)
else:
ans0 = a[i + 0] + func(i + 2)
ans1 = a[i + 1] + func(i + 3)
ans2 = a_cs[i + 2]
ans = max(ans0, ans1, ans2)
d[i] = ans
return ans
ans = func(0)
print(ans)
| p02716 |
# -*- coding: utf-8 -*-
import sys
from collections import defaultdict
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N = INT()
A = LIST()
# dp0[i][j] := i個目の要素まで見て、選んだ要素-選ばなかった要素=jで、直前を使っていない時の最大値
dp0 = [defaultdict(lambda: -INF) for i in range(N+1)]
# dp1[i][j] := i個目の要素まで見て、選んだ要素-選ばなかった要素=jで、直前を使った時の最大値
dp1 = [defaultdict(lambda: -INF) for i in range(N+1)]
dp0[0][0] = 0
for i, a in enumerate(A):
for j in range(-2, 2):
if j != -2:
# 今回のaを使わない
dp0[i+1][j-1] = max(dp0[i+1][j-1], dp0[i][j])
dp0[i+1][j-1] = max(dp0[i+1][j-1], dp1[i][j])
# 今回のaを使う
dp1[i+1][j+1] = max(dp1[i+1][j+1], dp0[i][j] + a)
# 最終的に欲しい位置は偶奇で場合分け
if N % 2 == 0:
# 偶数の時は使った数と使わなかった数が同じ
ans = max(dp0[N][0], dp1[N][0])
else:
# 奇数の時は使わなかった数が1つ多い
ans = max(dp0[N][-1], dp1[N][-1])
print(ans)
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N = INT()
A = LIST()
dp0 = list2d(N+1, 4, -INF)
dp1 = list2d(N+1, 4, -INF)
dp0[0][2] = 0
for i, a in enumerate(A):
for j in range(4):
if j != 0:
dp0[i+1][j-1] = max(dp0[i+1][j-1], dp0[i][j])
dp0[i+1][j-1] = max(dp0[i+1][j-1], dp1[i][j])
if j != 3:
dp1[i+1][j+1] = max(dp1[i+1][j+1], dp0[i][j] + a)
if N % 2 == 0:
ans = max(dp0[N][2], dp1[N][2])
else:
ans = max(dp0[N][1], dp1[N][1])
print(ans)
| p02716 |
import sys
sys.setrecursionlimit(10 ** 9)
def solve(pick, idx):
if pick == 0: return 0
if idx >= n: return -float('inf')
if (pick, idx) in dp: return dp[pick, idx]
# if n-idx+2 < pick*2: return -float('inf')
total = max(A[idx] + solve(pick-1, idx+2), solve(pick, idx+1))
dp[(pick, idx)] = total
return total
n = int(eval(input()))
A = list(map(int, input().split()))
dp = {}
pick = n//2
print((solve(pick, 0))) | import sys
sys.setrecursionlimit(10 ** 9)
def solve(pick, idx):
if pick == 0: return 0
if idx >= n: return -float('inf')
if (pick, idx) in dp: return dp[pick, idx]
if n-idx+2 < pick*2: return -float('inf')
total = max(A[idx] + solve(pick-1, idx+2), solve(pick, idx+1))
dp[(pick, idx)] = total
return total
n = int(eval(input()))
A = list(map(int, input().split()))
dp = {}
pick = n//2
print((solve(pick, 0))) | p02716 |
# coding: utf-8
import sys
from functools import lru_cache
sys.setrecursionlimit(10 ** 9)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
# 奇数の時と偶数の時、奇数の場合は真ん中を選ぶかどうか
INF = 10 ** 17
@lru_cache(None)
def F(index, n):
if index >= N:
return -INF
if n == 0:
return 0
elif n == 1:
return max(A[index:])
ret = max(A[index] + F(index+2, n-1), F(index+1, n))
return ret
answer = F(0, N//2)
print(answer)
| # coding: utf-8
import sys
from functools import lru_cache
sys.setrecursionlimit(10 ** 9)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
# 奇数の時と偶数の時、奇数の場合は真ん中を選ぶかどうか
INF = 10 ** 17
@lru_cache(None)
def F(index, n):
if index >= N:
return -INF
if N - index + 2 < 2 * n:
return -INF
if n == 0:
return 0
elif n == 1:
return max(A[index:])
ret = max(A[index] + F(index+2, n-1), F(index+1, n))
return ret
answer = F(0, N//2)
print(answer)
| p02716 |
# coding: utf-8
import sys
from functools import lru_cache
sys.setrecursionlimit(10 ** 9)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
INF = 10 ** 17
def F(index, n):
if index >= N:
return -INF
if N - index + 2 < 2 * n:
return -INF
if n == 0:
return 0
elif n == 1:
return max(A[index:])
ret = max(A[index] + F(index+2, n-1), F(index+1, n))
return ret
answer = F(0, N//2)
print(answer)
| # coding: utf-8
import sys
from functools import lru_cache
sys.setrecursionlimit(10 ** 9)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
INF = 10 ** 17
@lru_cache(None)
def F(index, n):
if index >= N:
return -INF
if N - index < 2 * n - 1:
return -INF
if n == 0:
return 0
elif n == 1:
return max(A[index:])
ret = max(A[index] + F(index+2, n-1), F(index+1, n))
return ret
answer = F(0, N//2)
print(answer)
| p02716 |
from collections import deque, Counter
from itertools import chain, combinations
import json
# import numpy as np
import bisect
import sys
import math
import bisect
sys.setrecursionlimit(10 ** 8)
M = 10 ** 9 + 7
def main():
N = int(eval(input()))
A = [int(a) for a in input().split()]
DP = [[0] * (N + 1) for _ in range(N + 1)]
DP[1][1] = A[0]
for i in range(2, N + 1):
a = math.floor((i - 1) / 2)
b = math.floor((i + 1) / 2)
for j in range(a, b + 1):
DP[i][j] = max(DP[i - 1][j], DP[i - 2][j - 1] + A[i - 1])
print((int(DP[N][math.floor(N / 2)])))
if __name__ == "__main__":
main()
| from collections import deque, Counter, defaultdict
from itertools import chain, combinations
import json
# import numpy as np
import bisect
import sys
import math
import bisect
from functools import lru_cache
sys.setrecursionlimit(10 ** 8)
M = 10 ** 9 + 7
INF = 10 ** 17
def main():
N = int(eval(input()))
A = [int(a) for a in input().split()]
@lru_cache()
def f(i, j):
if i < 0 or j < 0:
return -INF
if i == 0:
return -INF
if j == 0:
return 0
if j == 1:
return max(A[:i])
return max(A[i - 1] + f(i - 2, j - 1), f(i - 1, j))
print((f(N, math.floor(N / 2))))
if __name__ == "__main__":
main()
| p02716 |
from collections import deque, Counter, defaultdict
from itertools import chain, combinations
import json
# import numpy as np
import bisect
import sys
import math
import bisect
from functools import lru_cache
sys.setrecursionlimit(10 ** 8)
M = 10 ** 9 + 7
INF = 10 ** 17
def main():
N = int(eval(input()))
A = [int(a) for a in input().split()]
@lru_cache(None)
def f(i, j):
if i < 0 or j < 0:
return -INF
if i == 0:
return -INF
if j == 0:
return 0
if j == 1:
return max(A[:i])
return max(A[i - 1] + f(i - 2, j - 1), f(i - 1, j))
print((f(N, math.floor(N / 2))))
if __name__ == "__main__":
main()
| from collections import deque, Counter, defaultdict
from itertools import chain, combinations
import json
# import numpy as np
import bisect
import sys
import math
import bisect
from functools import lru_cache
sys.setrecursionlimit(10 ** 8)
M = 10 ** 9 + 7
INF = 10 ** 17
def main():
N = int(eval(input()))
A = [int(a) for a in input().split()]
@lru_cache(None)
def f(i, j):
if i < 0 or j < 0:
return -INF
if i == 0:
return -INF
if abs(j - i // 2 - 1) >= 2:
return -INF
if j == 0:
return 0
if j == 1:
return max(A[:i])
return max(A[i - 1] + f(i - 2, j - 1), f(i - 1, j))
print((f(N, math.floor(N / 2))))
if __name__ == "__main__":
main()
| p02716 |
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time
def I(): return int(eval(input()))
def S(): return eval(input())
def MI(): return list(map(int, input().split()))
def MS(): return list(map(str, input().split()))
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in eval(input())]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def main():
N = I()
a = LI()
dp = [0] * N
dp[1] = max(a[0], a[1])
c = a[0]
for i in range(2, N):
if i % 2 == 0:
c += a[i]
dp[i] = max(dp[i-2] + a[i], dp[i-1])
else:
dp[i] = max(dp[i-2] + a[i], c)
print((dp[-1]))
if __name__ == '__main__':
main()
| n = int(eval(input()))
A = list(map(int, input().split()))
INF = 10**18
dp_use = [-INF] * 5
dp_not_use = [-INF] * 5
dp_not_use[0] = 0
for a in A:
tmp_use = [-INF] * 5
tmp_not_use = [-INF] * 5
for current_dif in range(-3,2):
if current_dif-1 >= -3:
tmp_use[current_dif] = dp_not_use[current_dif - 1] + a
if current_dif+1 < 2:
tmp_not_use[current_dif] = max(dp_use[current_dif+1], dp_not_use[current_dif+1])
dp_use = tmp_use
dp_not_use = tmp_not_use
dif = n//2 - (n-n//2)
print((max(dp_use[dif], dp_not_use[dif]))) | p02716 |
n = int(eval(input()))
a = list(map(int, input().split()))
if n % 2 == 0:
ans, cnt = 0, 0
for i in range(n):
if i % 2 == 1:
ans += a[i]
cnt += a[i]
for i in range(n):
if i % 2 == 0:
cnt += a[i]
else:
cnt -= a[i]
ans = max(cnt, ans)
else:
a.insert(0, 0)
dp = [[0] * (n + 1) for _ in range(3)]
for i in range(3):
for j in range(1 + i, n + i - 1, 2):
if i == 0:
if j == 1:
dp[i][j] = a[j]
else:
dp[i][j] = dp[i][j - 2] + a[j]
else:
dp[i][j] = max(dp[i - 1][j - 1], dp[i][j - 2] + a[j])
ans = dp[2][n]
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
a.insert(0, 0)
dp = [[0] * (n + 1) for _ in range(3)]
for i in range(n % 2 + 2):
for j in range(1 + i, n + i, 2):
if i == 0:
if j == 1:
dp[i][j] = a[j]
else:
dp[i][j] = dp[i][j - 2] + a[j]
else:
dp[i][j] = max(dp[i - 1][j - 1], dp[i][j - 2] + a[j])
ans = dp[n % 2 + 1][n]
print(ans) | p02716 |
n,*l=list(map(int,open(0).read().split()));p=[0]*n;d=p[:]
for i,l in enumerate(l):p[i]+=l+p[i-2];d[i]=max(l+d[i-2],[d,p][i&1][i-1])
print((d[-1])) | n,*l=list(map(int,open(0).read().split()));p=[0]*n;d=p[:]
for i,l in enumerate(l):p[i]=l+p[i-2];d[i]=max(l+d[i-2],[d,p][i&1][i-1])
print((d[-1])) | p02716 |
n,*l=list(map(int,open(0).read().split()))
p=0,0
d=p
i=0
for l in l:d+=max(l+d[-2],[d,p][i&1][-1]),;p+=l+p[-2],;i+=1
print((d[-1])) | n,*l=list(map(int,open(0).read().split()))
p=[0,0]
d=[0,0]
i=0
for l in l:d+=max(l+d[-2],[d,p][i&1][-1]),;p+=l+p[-2],;i+=1
print((d[-1])) | p02716 |
from sys import stdin
import sys
# sys.setrecursionlimit(10**8)
def nextLine(): return next(stdin)
def nextStrList(): return nextLine().split()
def nextIntList(): return [int(_) for _ in nextStrList()]
def main():
n=int(nextLine())
aList=nextIntList()
num=n//2
score=[[None for _ in range(num)] for i in range(n)]
for i in range(n):
if i==0:
score[i][0]=aList[i]
else:
score[i][0]=max(aList[i], score[i-1][0])
for j in range(1, num):
nextScore=[]
if i>=1:
s=score[i-1][j]
if s is not None:
nextScore.append(s)
if i>=2:
s=score[i-2][j-1]
if s is not None:
s+=aList[i]
nextScore.append(s)
if len(nextScore)>0:
nextScore=max(nextScore)
score[i][j]=nextScore
# print(i, *[str(s) for s in score[i]], sep="\t")
print((score[-1][-1]))
if __name__=="__main__":
main()
| from sys import stdin
import sys
# sys.setrecursionlimit(10**8)
def nextLine(): return next(stdin)
def nextStrList(): return nextLine().split()
def nextIntList(): return [int(_) for _ in nextStrList()]
# def comp0(n, aList):
# num=n//2
# score=[[None for _ in range(num)] for i in range(n)]
#
# for i in range(n):
#
# if i==0:
# score[i][0]=aList[i]
# else:
# score[i][0]=max(aList[i], score[i-1][0])
#
# for j in range(1, num):
# nextScore=[]
# if i>=1:
# s=score[i-1][j]
# if s is not None:
# nextScore.append(s)
# if i>=2:
# s=score[i-2][j-1]
# if s is not None:
# s+=aList[i]
# nextScore.append(s)
# if len(nextScore)>0:
# nextScore=max(nextScore)
# score[i][j]=nextScore
#
# # print(i, aList[i], *[str(s) for s in score[i]], sep="\t")
#
# print(score[-1][-1])
def comp(n, aList):
num=n//2
score=[[None for _ in range(num)] for i in range(3)]
# base=[0 for _ in range(num)]
for i in range(n):
for j in range(max(0, num-(n-i)//2-1), min(i//2+1,num)):
if j==0:
if i==0:
ns=aList[i]
else:
ns=max(aList[i], score[(i-1)%3][0])
else:
nextScore=[]
if i>=1:
s=score[(i-1)%3][j]
if s is not None:
nextScore.append(s)
if i>=2:
s=score[(i-2)%3][j-1]
if s is not None:
s+=aList[i]
nextScore.append(s)
if len(nextScore)>0:
ns=max(nextScore)
score[i%3][j]=ns
# print(i, *[str(s) for s in score[i%3]], sep="\t")
print((score[(n-1)%3][-1]))
def main():
n=int(nextLine())
aList=nextIntList()
# import numpy as np
# n=200000
# # aList=list(np.random.randint(-1000000000, 1000000001, n))
# # n=22
# aList=list(np.random.randint(-9, 10, n))
comp(n, aList)
# comp0(n, aList)
if __name__=="__main__":
main()
| p02716 |
import sys
N = int(eval(input()))
A = list(map(int,input().split()))
INF = 10**20
dp = [[[-INF]*2 for _ in range(2)] for _ in range(N+1)]
if N&1:
dp[0][1][0] = 0
for i in range(N):
if i&1:
dp[i+1][0][0] = max(dp[i][0][0], dp[i][0][1])
dp[i+1][1][0] = max(dp[i][1][0], dp[i][1][1])
dp[i+1][1][1] = dp[i][0][0] + A[i]
else:
dp[i+1][0][0] = max(dp[i][1][0], dp[i][1][1])
dp[i+1][0][1] = dp[i][0][0] + A[i]
dp[i+1][1][1] = dp[i][1][0] + A[i]
ans = max(dp[N][0][0], dp[N][0][1])
else:
dp[0][1][0] = 0
for i in range(N):
if i&1:
dp[i+1][1][0] = dp[i][1][1]
dp[i+1][1][1] = dp[i][0][0] + A[i]
else:
dp[i+1][0][0] = max(dp[i][1][0], dp[i][1][1])
dp[i+1][1][1] = dp[i][1][0] + A[i]
ans = max(dp[N][1][0], dp[N][1][1])
print(ans) | import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int,input().split()))
dp = [0]*n
c = a[0]
dp[1] = max(a[0],a[1])
for i in range(2,n):
if i%2 == 0:
c += a[i]
dp[i] = max(dp[i-2]+a[i],dp[i-1])
else:
dp[i] = max(dp[i-2]+a[i],c)
print((dp[-1]))
| p02716 |
from collections import defaultdict
n = int(eval(input()))
m = n//2
INF = 10**18
dp = [defaultdict(lambda: -INF)for _ in range(n+2)]
for i, a in enumerate(map(int, input().split()), 2):
for j in range(1, -(-i//2)+1):
if j-1 == 0:
dp[i-2][j-1] = 0
dp[i][j] = max(dp[i-1][j], dp[i-2][j-1]+a)
print((dp[n+1][m]))
| from collections import defaultdict
n = int(eval(input()))
m = n//2
INF = 10**18
dp = [defaultdict(lambda: -INF)for _ in range(n+2)]
for i, a in enumerate(map(int, input().split()), 2):
for j in range(max(1, i//2-1), -(-i//2)+1):
if j-1 == 0:
dp[i-2][j-1] = 0
dp[i][j] = max(dp[i-1][j], dp[i-2][j-1]+a)
print((dp[n+1][m]))
| p02716 |
n = int(eval(input()))
a = list(map(int,input().split()))
dp = [[0 for i in range(3)] for j in range(n+1)]
for i in range(1,n+1):
ai = a[i-1]
dp[i] = dp[i-1][:]
if i%2:
dp[i][0] += +ai
dp[i][1] = max(dp[i-1][0],dp[i-1][1])
if i%2 == 0:
dp[i][1] += ai
dp[i][2] = max(dp[i-1][1],dp[i-1][2])
if i >= 3 and i%2:
dp[i][2] += ai
if n%2 == 0:
print((max(dp[-1][0],dp[-1][1])))
else:
print((max(dp[-1][1],dp[-1][2]))) | n = int(eval(input()))
a = list(map(int,input().split()))
dp = [0 for i in range(3)]
for i in range(1,n+1):
ai = a[i-1]
if i%2:
dp[1] = max(dp[0],dp[1])
dp[0] += ai
if i%2 == 0:
dp[2] = max(dp[1],dp[2])
dp[1] += ai
if i >= 3 and i%2:
dp[2] += ai
if n%2 == 0:
print((max(dp[0],dp[1])))
else:
print((max(dp[1],dp[2]))) | p02716 |
import sys
sys.setrecursionlimit(10**9)
N = int(eval(input()))
A = list(map(int, input().split()))
def solve_even(a, n):
s = sum(a[::2])
ans = s
i = n - 2
while i >= 0:
s += a[i+1] - a[i]
ans = max(ans, s)
i -= 2
return ans
def solve_odd(a, n):
if n == 1:
return 0
ans = solve_even(a[:-1], n-1)
s = a.pop()
a.pop()
ans = max(ans, s + solve_odd(a, n-2))
return ans
if N%2 == 0:
print((solve_even(A, N)))
else:
print((solve_odd(A, N))) | N = int(eval(input()))
A = list(map(int, input().split()))
dp = [0] * (N + 1)
dp[2] = max(A[0], A[1])
s = A[0]
for i, a in enumerate(A, 1):
if i <= 2:
continue
if i%2: # 奇数
dp[i] = max(dp[i-1], a+dp[i-2])
s += a
else: # 偶数
dp[i] = max(a+dp[i-2], s)
print((dp[-1])) | p02716 |
import math
import sys
sys.setrecursionlimit(1000000)
N = int(eval(input()))
A = [int(i) for i in input().split()]
memo = {}
def sub_max(n, m):
if((n, m) in memo):
return memo[(n, m)]
if(m == 1 and n >= 1):
memo[(n, m)] = max(A[-n:])
return memo[(n, m)]
if(m >= n):
memo[(n, m)] = -float('inf')
return -float('inf')
res = -float('inf')
for i in range(3):
res = max(res, A[-n + i] + sub_max(n - i - 2, m - 1))
memo[(n, m)] = res
return res
print((sub_max(N, N//2))) | import math
import sys
sys.setrecursionlimit(1000000)
N = int(eval(input()))
A = [int(i) for i in input().split()]
memo = {}
def sub_max(n, m):
if((n, m) in memo):
return memo[(n, m)]
if(m == 1 and n >= 1):
memo[(n, m)] = max(A[-n:])
return memo[(n, m)]
if(m > math.ceil(n/2)):
memo[(n, m)] = -float('inf')
return -float('inf')
res = -float('inf')
for i in range(3):
res = max(res, A[-n + i] + sub_max(n - i - 2, m - 1))
memo[(n, m)] = res
return res
print((sub_max(N, N//2)))
# print(memo) | p02716 |
import bisect
import sys
import math
import itertools
sys.setrecursionlimit(10000)
INF = float('inf')
# input macro
def i():
return int(input())
def ii():
return list(map(int,input().split(" ")))
def s():
return input()
def ss():
return input().split(" ")
def slist():
return list(input())
#
def join(s):
return ''.join(s)
#iterate macro
def piter(n,m):
return itertools.permutations(n,m)
def citer(n,m):
return itertools.combinations(n,m)
#modulo macro
def modc(a,b,m):
c = 1
for i in range(b):
c = c * (a - i) % m
c = c * modinv(i + 1,m) % m
return c
def gcd(a, b):
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return (lastx, lasty, a)
def modinv(a, m):
(inv, q, gcd_val) = gcd(a, m)
return inv % m
#bisect macro
def index(a, x):
#Locate the leftmost value exactly equal to x
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return i
return -1
#memoize macro
def memoize(f):
cache = {}
def helper(*args):
if args not in cache:
cache[(args)] = f(*args)
return cache[args]
return helper
@memoize
def nck(a,b,m):
b = min([a-b,b])
if (b>a or b<0 or a<0):
return 0
elif a == 0:
return 1
return (nck(a-1,b-1,m)+nck(a-1,b,m)) % m
nh=list(zip([1,0,-1,0],[0,1,0,-1]))
###########
n=i()
x=ii()
l=i()
q=i()
a,b=[0]*q,[0]*q
for j in range(q):
a[j],b[j]=ii()
left=[0]*n
right=[0]*n
for (j,hotel) in enumerate(x):
right[j]=bisect.bisect_right(x,hotel+l)-1
left[j]=bisect.bisect_left(x,hotel-l)
for j in range(q):
if a[j]<b[j]:
cur=a[j]-1
cnt=0
while cur<b[j]-1:
if x[cur]+l>=x[b[j]-1]:
cnt+=1
cur=b[j]-1
else:
cnt+=1
cur=right[cur]
print(cnt)
else:
cur=a[j]-1
cnt=0
while cur>b[j]-1:
if x[cur]-l<=x[b[j]-1]:
cnt+=1
cur=b[j]-1
else:
cnt+=1
cur=left[cur]
print(cnt)
| import bisect
import sys
import math
import itertools
sys.setrecursionlimit(10000)
INF = float('inf')
# input macro
def i():
return int(input())
def ii():
return list(map(int,input().split(" ")))
def s():
return input()
def ss():
return input().split(" ")
def slist():
return list(input())
def join(s):
return ''.join(s)
###########
n=i()
x=ii()
l=i()
q=i()
a,b=[0]*q,[0]*q
for j in range(q):
aa,bb=ii()
a[j],b[j]=min(aa,bb)-1,max(aa,bb)-1
table=[[0 for i in range(n)] for j in range(32)]
for k in range(n):
table[0][k]=bisect.bisect_right(x,x[k]+l)-1
for j in range(1,32):
for k in range(n):
table[j][k]=table[j-1][table[j-1][k]]
for j in range(q):
day=0
cur=a[j]
for k in reversed(list(range(32))):
if table[k][cur]<b[j]:
day+=2**k
cur=table[k][cur]
print(day+1)
| p04017 |
from bisect import bisect_left, bisect_right
import math
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
X = list(map(int, input().split()))
L = int(eval(input()))
ln = int(math.log(N, 2))
dpl = [[0] * N for _ in range(ln+1)]
dpr = [[0] * N for _ in range(ln+1)]
l = 0
r = 0
for i in range(N):
x = X[i]
while X[l] + L < x:
l += 1
while r < N-1 and x + L >= X[r+1]:
r += 1
dpl[0][i] = l
dpr[0][i] = r
for k in range(1, ln+1):
for i in range(N):
dpl[k][i] = dpl[k-1][dpl[k-1][i]]
dpr[k][i] = dpr[k-1][dpr[k-1][i]]
Q = int(eval(input()))
for _ in range(Q):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
ans = 0
if a < b:
for k in range(ln+1)[::-1]:
while dpr[k][a] <= b:
a = dpr[k][a]
ans += 2**k
if a < b:
ans += 1
else:
# a > b
for k in range(ln+1)[::-1]:
while dpl[k][a] >= b:
a = dpl[k][a]
ans += 2**k
if a > b:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| from bisect import bisect_left, bisect_right
import math
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
X = list(map(int, input().split()))
L = int(eval(input()))
ln = int(math.log(N, 2))
dpl = [[0] * N for _ in range(ln+1)]
dpr = [[0] * N for _ in range(ln+1)]
l = 0
r = 0
for i in range(N):
x = X[i]
while X[l] + L < x:
l += 1
while r < N-1 and x + L >= X[r+1]:
r += 1
dpl[0][i] = l
dpr[0][i] = r
for k in range(1, ln+1):
for i in range(N):
dpl[k][i] = dpl[k-1][dpl[k-1][i]]
dpr[k][i] = dpr[k-1][dpr[k-1][i]]
Q = int(eval(input()))
for _ in range(Q):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
ans = 0
if a < b:
for k in range(ln+1)[::-1]:
if dpr[k][a] < b:
a = dpr[k][a]
ans += 2**k
if a < b:
ans += 1
else:
# a > b
for k in range(ln+1)[::-1]:
if dpl[k][a] > b:
a = dpl[k][a]
ans += 2**k
if a > b:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| p04017 |
from bisect import bisect, bisect_left
n = int(eval(input()))
x = list(map(int, input().split()))
l = int(eval(input()))
def search_1(start):
return bisect(x, x[start] + l) - 1
route = [[] for _ in range(n)]
i = 0 # 親の位置
for i in range(n - 1):
if route[i] == []:
j = search_1(i) # カーソルの位置
num = 1 # 何日目の場所か
route[i].append(j)
if route[j] == []:
route[j] = (i, num)
else: # 既に他の親が通っている
route[i] += route[route[j][0]][route[j][1]:]
continue
while j < n - 1:
j = search_1(j)
num += 1
route[i].append(j)
if route[j] == []:
route[j] = (i, num)
else: # 既に他の親が通っている
route[i] += route[route[j][0]][route[j][1]:]
break
else:
continue
# print(route)
def search_2(start, goal):
if type(route[start]) == type([]):
return bisect_left(route[start], goal) + 1
else:
return bisect_left(route[route[start][0]][route[start][1]:], goal) + 1
q = int(eval(input()))
for _ in range(q):
a, b = list(map(int, input().split()))
if a > b:
a, b = b, a
print((search_2(a - 1, b - 1)))
| from bisect import bisect
n = int(eval(input()))
x = list(map(int, input().split()))
l = int(eval(input()))
q = int(eval(input()))
#r[i][j]: jから(2**i)日で行ける右端
r = [[i for i in range(n)] for _ in range(18)]
for j in range(n):
r[0][j] = bisect(x, x[j]+l) - 1
for i in range(1, 18):
for j in range(n):
r[i][j] = r[i-1][r[i-1][j]]
def search(x, y):
res = 0
cur = x
while True:
for i in range(18):
if r[i][cur] >= y:
if i == 0:
return res+1
cur = r[i-1][cur]
res += 1 << (i-1)
break
for _ in range(q):
a, b = list(map(int, input().split()))
print((search(min(a, b)-1, max(a, b)-1))) | p04017 |
from bisect import bisect, bisect_left
import sys
n = int(eval(input()))
x = list(map(int, input().split()))
l = int(eval(input()))
def search_1(start):
return bisect(x, x[start] + l) - 1
route = [[] for _ in range(n)]
i = 0 # 親の位置
for i in range(n - 1):
if route[i] == []:
j = search_1(i) # カーソルの位置
num = 1 # 何日目の場所か
route[i].append(j)
if route[j] == []:
route[j] = (i, num)
else: # 既に他の親が通っている
route[i] += route[route[j][0]][route[j][1]:]
continue
while j < n - 1:
j = search_1(j)
num += 1
route[i].append(j)
if route[j] == []:
route[j] = (i, num)
else: # 既に他の親が通っている
route[i] += route[route[j][0]][route[j][1]:]
break
else:
continue
# print(route)
def search_2(start, goal):
if type(route[start]) == type([]):
return bisect_left(route[start], goal) + 1
else:
return bisect_left(route[route[start][0]][route[start][1]:], goal) + 1
q = int(eval(input()))
for _ in range(q):
a, b = list(map(int, sys.stdin.readline().strip().split()))
if a > b:
a, b = b, a
print((search_2(a - 1, b - 1))) | from bisect import bisect
import sys
n = int(eval(input()))
x = list(map(int, input().split()))
l = int(eval(input()))
q = int(eval(input()))
#r[i][j]: jから(2**i)日で行ける右端
r = [[i for i in range(n)] for _ in range(18)]
for j in range(n):
r[0][j] = bisect(x, x[j]+l) - 1
for i in range(1, 18):
for j in range(n):
r[i][j] = r[i-1][r[i-1][j]]
def search(x, y):
res = 0
cur = x
i = 17
while True:
if i == 0 and r[i][cur] >= y:
return res+1
if r[i][cur] < y:
cur = r[i][cur]
res += 1 << i
continue
i -= 1
for _ in range(q):
a, b = list(map(int, sys.stdin.readline().strip().split()))
print((search(min(a, b)-1, max(a, b)-1))) | p04017 |
# seishin.py
N = int(input())
*X, = map(int, input().split())
L = int(input())
K = 318
D = {}
j = N-1
for i in range(N-1, -1, -1):
while j > 0 and X[j] - X[i] > L:
j -= 1
D[i, 0] = j
for k in range(K):
for i in range(N):
if (i, k) in D and (D[i, k], k) in D:
D[i, k+1] = D[D[i, k], k]
def solve(a, b):
if not a < b:
a, b = b, a
res = 1
for k in range(K, -1, -1):
if D.get((a, k), N) < b:
a = D[a, k]
res += 2**k
return res
Q = int(input())
ans = []
for i in range(Q):
a, b = map(int, input().split())
ans.append(solve(a-1, b-1))
print(*ans, sep='\n')
| # seishin.py
N = int(input())
*X, = map(int, input().split())
L = int(input())
K = 20
D = [[N]*(K+1) for i in range(N)]
j = N-1
for i in range(N-1, -1, -1):
while j > 0 and X[j] - X[i] > L:
j -= 1
D[i][0] = j
for k in range(K):
for i in range(N):
if D[i][k] != N:
D[i][k+1] = D[D[i][k]][k]
def solve(a, b):
if not a < b:
a, b = b, a
res = 1
for k in range(K, -1, -1):
if D[a][k] < b:
a = D[a][k]
res += 2**k
return res
Q = int(input())
ans = []
for i in range(Q):
a, b = map(int, input().split())
ans.append(solve(a-1, b-1))
print(*ans, sep='\n')
| p04017 |
# -*- coding: utf-8 -*-
from functools import lru_cache
import sys
buff_readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
class Bisect:
def __init__(self, func):
self.__func = func
def bisect_left(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if self.__func(mid) < x:
lo = mid+1
else:
hi = mid
return lo
def bisect_right(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if x < self.__func(mid):
hi = mid
else:
lo = mid+1
return lo
def slv(N, X, L, Q, AB):
r = [0]
for x in X:
t = -1
for j in range(r[-1], len(X)):
if X[j] - x <= L:
t = j
else:
break
r.append(t)
r.pop(0)
@lru_cache(maxsize=None)
def apply(i, n):
if n == 1:
return r[i]
else:
return apply(apply(i, n//2), n//2)
@lru_cache(maxsize=None)
def f(i, n):
j = i
for k in range(0, n.bit_length()):
m = 1 << k
if n & m:
j = apply(j, m)
return j
ans = []
for a, b in AB:
if a > b:
a, b = b, a
a -= 1
b -= 1
bisect = Bisect(lambda x: f(a, x))
i = bisect.bisect_left(b, 0, len(X)+1)
ans.append(i)
return ans
def main():
N = read_int()
X = read_int_n()
L = read_int()
Q = read_int()
AB = [read_int_n() for _ in range(Q)]
print(*slv(N, X, L, Q, AB), sep='\n')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
from functools import lru_cache
import sys
buff_readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
class Bisect:
def __init__(self, func):
self.__func = func
def bisect_left(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if self.__func(mid) < x:
lo = mid+1
else:
hi = mid
return lo
def bisect_right(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if x < self.__func(mid):
hi = mid
else:
lo = mid+1
return lo
class Doubling():
def __init__(self, N, a0):
self.N = N
self.nt = [[None] * N for i in range(N.bit_length())]
for i, a in enumerate(a0):
self.nt[0][i] = a
for i in range(1, len(self.nt)):
for j in range(N):
if self.nt[i-1][j] is None:
self.nt[i][j] = None
else:
self.nt[i][j] = self.nt[i-1][self.nt[i-1][j]]
def apply(self, i, n):
j = i
for k in range(n.bit_length()):
m = 1 << k
if m & n:
j = self.nt[k][j]
if j is None:
break
return j
def slv(N, X, L, Q, AB):
r = [0]
for x in X:
t = -1
for j in range(r[-1], len(X)):
if X[j] - x <= L:
t = j
else:
break
r.append(t)
r.pop(0)
d = Doubling(N, r)
ans = []
for a, b in AB:
if a > b:
a, b = b, a
a -= 1
b -= 1
bisect = Bisect(lambda x: d.apply(a, x))
i = bisect.bisect_left(b, 0, len(X)+1)
ans.append(i)
return ans
def main():
N = read_int()
X = read_int_n()
L = read_int()
Q = read_int()
AB = [read_int_n() for _ in range(Q)]
print(*slv(N, X, L, Q, AB), sep='\n')
if __name__ == '__main__':
main()
| p04017 |
# -*- coding: utf-8 -*-
from functools import lru_cache
import sys
buff_readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
class Bisect:
def __init__(self, func):
self.__func = func
def bisect_left(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if self.__func(mid) < x:
lo = mid+1
else:
hi = mid
return lo
def bisect_right(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if x < self.__func(mid):
hi = mid
else:
lo = mid+1
return lo
class Doubling():
def __init__(self, N, a0):
self.N = N
self.nt = [[None] * N for i in range(N.bit_length())]
for i, a in enumerate(a0):
self.nt[0][i] = a
for i in range(1, len(self.nt)):
for j in range(N):
if self.nt[i-1][j] is None:
self.nt[i][j] = None
else:
self.nt[i][j] = self.nt[i-1][self.nt[i-1][j]]
def apply(self, i, n):
j = i
for k in range(n.bit_length()):
m = 1 << k
if m & n:
j = self.nt[k][j]
if j is None:
break
return j
def slv(N, X, L, Q, AB):
r = [0]
for x in X:
t = -1
for j in range(r[-1], len(X)):
if X[j] - x <= L:
t = j
else:
break
r.append(t)
r.pop(0)
d = Doubling(N, r)
ans = []
for a, b in AB:
if a > b:
a, b = b, a
a -= 1
b -= 1
bisect = Bisect(lambda x: d.apply(a, x))
i = bisect.bisect_left(b, 0, len(X)+1)
ans.append(i)
return ans
def main():
N = read_int()
X = read_int_n()
L = read_int()
Q = read_int()
AB = [read_int_n() for _ in range(Q)]
print(*slv(N, X, L, Q, AB), sep='\n')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
buff_readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
class Bisect:
def __init__(self, func):
self.__func = func
def bisect_left(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if self.__func(mid) < x:
lo = mid+1
else:
hi = mid
return lo
def bisect_right(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if x < self.__func(mid):
hi = mid
else:
lo = mid+1
return lo
class Doubling():
def __init__(self, N, a0):
self.N = N
self.nt = [[None] * N for i in range(N.bit_length())]
for i, a in enumerate(a0):
self.nt[0][i] = a
for i in range(1, len(self.nt)):
for j in range(N):
if self.nt[i-1][j] is None:
self.nt[i][j] = None
else:
self.nt[i][j] = self.nt[i-1][self.nt[i-1][j]]
def apply(self, i, n):
j = i
for k in range(n.bit_length()):
m = 1 << k
if m & n:
j = self.nt[k][j]
if j is None:
break
return j
def slv(N, X, L, Q, AB):
r = [0]
for x in X:
t = -1
for j in range(r[-1], len(X)):
if X[j] - x <= L:
t = j
else:
break
r.append(t)
r.pop(0)
d = Doubling(N, r)
ans = []
for a, b in AB:
if a > b:
a, b = b, a
a -= 1
b -= 1
bisect = Bisect(lambda x: d.apply(a, x))
i = bisect.bisect_left(b, 0, len(X)+1)
ans.append(i)
return ans
def main():
N = read_int()
X = read_int_n()
L = read_int()
Q = read_int()
AB = [read_int_n() for _ in range(Q)]
print(*slv(N, X, L, Q, AB), sep='\n')
if __name__ == '__main__':
main()
| p04017 |
import sys,bisect
input=sys.stdin.readline
N=int(eval(input()))
x=list(map(int,input().split()))
L=int(eval(input()))
doubling=[[-1 for i in range(N)] for j in range(20)]
backdoubling=[[-1 for i in range(N)] for j in range(20)]
for i in range(N):
npos=x[i]+L
index=bisect.bisect_right(x,npos)
doubling[0][i]=index-1
for i in range(1,20):
for j in range(N):
doubling[i][j]=doubling[i-1][doubling[i-1][j]]
for i in range(N):
npos=x[i]-L
index=bisect.bisect_left(x,npos)
backdoubling[0][i]=index
for i in range(1,20):
for j in range(N):
backdoubling[i][j]=backdoubling[i-1][backdoubling[i-1][j]]
def forward(num,start):
for i in range(20):
if num>>i &1==1:
start=doubling[i][start]
return start
def back(num,start):
for i in range(20):
if num>>i &1==1:
start=backdoubling[i][start]
return start
for _ in range(int(eval(input()))):
a,b=list(map(int,input().split()))
a-=1;b-=1
if b>=a:
s=0
e=N
while e-s>1:
test=(e+s)//2
if forward(test,a)>=b:
e=test
else:
s=test
if forward(s,a)>=b:
print(s)
else:
print(e)
else:
s=0
e=N
while e-s>1:
test=(e+s)//2
if b>=back(test,a):
e=test
else:
s=test
if b>=back(s,a):
print(s)
else:
print(e) | import sys,bisect
input=sys.stdin.readline
N=int(eval(input()))
x=list(map(int,input().split()))
L=int(eval(input()))
doubling=[[-1 for i in range(N)] for j in range(20)]
for i in range(N):
npos=x[i]+L
index=bisect.bisect_right(x,npos)
doubling[0][i]=index-1
for i in range(1,20):
for j in range(N):
doubling[i][j]=doubling[i-1][doubling[i-1][j]]
forward=[[-1 for i in range(N)] for j in range(20)]
for i in range(N):
forward[0][i]=i
for i in range(1,20):
for j in range(N):
forward[i][j]=doubling[i-1][forward[i-1][j]]
for _ in range(int(eval(input()))):
a,b=list(map(int,input().split()))
a-=1;b-=1
if a>b:
a,b=b,a
res=0
for i in range(19,-1,-1):
if b>forward[i][a]:
a=doubling[i][a]
res+=2**i
print(res) | p04017 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import bisect
n = int(readline())
x = list(map(int,readline().split()))
l = int(readline())
q = int(readline())
ab = list(map(int,read().split()))
dbl_l = [[] for _ in range(n)]
dbl_r = [[] for _ in range(n)]
for dbl,xx in zip([dbl_l,dbl_r],[x,x[::-1]]):
j = 0
for i in range(n):
while(j < n-1):
if(abs(xx[j+1] - xx[i]) > l):
break
j += 1
dbl[i].append(j)
for i in range(30):
if(dbl[0][-1] == n-1):
break
for j in range(n):
dbl[j].append(dbl[ dbl[j][i] ][i])
def calc(a,b,dbl):
if(dbl[a][0] >= b):
return 1
ind = bisect.bisect_left(dbl[a],b) - 1
return 2**ind + calc(dbl[a][ind],b,dbl)
ans = []
it = iter(ab)
for a,b in zip(it,it):
a -= 1
b -= 1
if(a<b):
ans.append(calc(a,b,dbl_l))
else:
a,b = n-1-a,n-1-b
ans.append(calc(a,b,dbl_r))
print(('\n'.join(map(str,ans)))) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import bisect
n = int(readline())
x = list(map(int,readline().split()))
l = int(readline())
q = int(readline())
ab = list(map(int,read().split()))
dbl = [[] for _ in range(n)]
j = 0
for i in range(n):
while(j < n-1):
if(abs(x[j+1] - x[i]) > l):
break
j += 1
dbl[i].append(j)
for i in range(30):
if(dbl[0][-1] == n-1):
break
for j in range(n):
dbl[j].append(dbl[ dbl[j][i] ][i])
def calc(a,b):
if(dbl[a][0] >= b):
return 1
ind = bisect.bisect_left(dbl[a],b) - 1
return 2**ind + calc(dbl[a][ind],b)
ans = []
it = iter(ab)
for a,b in zip(it,it):
a -= 1
b -= 1
a,b = min(a,b),max(a,b)
ans.append(calc(a,b))
print(('\n'.join(map(str,ans)))) | p04017 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
def A():
return
#B
def B():
return
#C
def C():
n = I()
x = LI()
l = I()
k = int(math.log(n,2))
f = [[i for j in range(k+1)] for i in range(n)]
for i in range(n-1):
j = bisect.bisect_left(x,x[i]+l)
if j < n:
if x[j] > x[i]+l:
f[i][0] = j-1
else:
f[i][0] = j
else:
f[i][0] = j-1
po2 = [1]*(k+1)
for i in range(k):
po2[i+1] = po2[i]*2
for j in range(k):
for i in range(n):
f[i][j+1] = f[f[i][j]][j]
q = I()
for i in range(q):
a,b = LI()
a,b = [min(a,b)-1, max(a,b)-1]
ans = 0
while a < b:
i = bisect.bisect_left(f[a],b)
ans += po2[max(0,i-1)]
a = f[a][max(0,i-1)]
print(ans)
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
C()
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
x = LI()
L = I()
q = I()
p = [[] for i in range(n)]
for i in range(n):
xi = x[i]
l = i
r = n
while r-l > 1:
m = (l+r) >> 1
xm = x[m]
if xm-xi <= L:
l = m
else:
r = m
p[i].append(l)
N = 20
for j in range(N):
for i in range(n):
p[i].append(p[p[i][-1]][-1])
for i in range(q):
a,b = LI()
a -= 1
b -= 1
a,b = min(a,b),max(a,b)
ans = 1
for j in range(N)[::-1]:
if p[a][j] < b:
a = p[a][j]
ans += 1<<j
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| p04017 |
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
x = LI()
L = I()
q = I()
p = [[] for i in range(n)]
for i in range(n):
xi = x[i]
l = i
r = n
while r-l > 1:
m = (l+r) >> 1
xm = x[m]
if xm-xi <= L:
l = m
else:
r = m
p[i].append(l)
N = 20
for j in range(N):
for i in range(n):
p[i].append(p[p[i][-1]][-1])
for i in range(q):
a,b = LI()
a -= 1
b -= 1
a,b = min(a,b),max(a,b)
ans = 1
for j in range(N)[::-1]:
if p[a][j] < b:
a = p[a][j]
ans += 1<<j
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
x = LI()
f = [[] for i in range(n)]
l = I()
for i in range(n):
xi = x[i]
j = bisect.bisect_right(x,l+xi)-1
f[i].append(j)
h = int(math.log(n,2))+1
for j in range(h-1):
for i in range(n):
f[i].append(f[f[i][j]][j])
q = I()
for _ in range(q):
a,b = LI()
a -= 1
b -= 1
if b < a:
a,b = b,a
ans = 0
for i in range(h)[::-1]:
if f[a][i] < b:
a = f[a][i]
ans += 1<<i
print((ans+1))
return
#Solve
if __name__ == "__main__":
solve()
| p04017 |
from bisect import*
r=range
n,*t=list(map(int,open(0).read().split()))
m=2**16
x=t[:n]
d=[[bisect(x,y+t[n])-1for y in x]]+[[0]*n for _ in r(m)]
for i in r(m):
for j in r(n):
d[i+1][j]=d[i][d[i][j]]
for a in zip(t[n+2::2],t[n+3::2]):
a,b=sorted(i-1for i in a)
c=1
for i in r(m,-1,-1):
if d[i][a]<b:
a=d[i][a]
c+=2**i
print(c) | from math import*
from bisect import*
r=range
n,*t=list(map(int,open(0).read().split()))
m=int(log(n,2)+1)
x=t[:n]
d=[[bisect(x,y+t[n])-1for y in x]]+[[0]*n for _ in r(m)]
for i in r(m):
for j in r(n):
d[i+1][j]=d[i][d[i][j]]
for a in zip(t[n+2::2],t[n+3::2]):
a,b=sorted(i-1for i in a)
c=1
for i in r(m,-1,-1):
if d[i][a]<b:
a=d[i][a]
c+=2**i
print(c) | p04017 |
import sys
input = sys.stdin.readline
import bisect
n = int(eval(input()))
X = list(map(int, input().split()))
l = int(eval(input()))
U = 17
dp = [[0]*n for _ in range(U+1)]
for i, x in enumerate(X):
t = bisect.bisect_left(X, x+l)
dp[0][i] = bisect.bisect_right(X, x+l) - 1
for k in range(U):
for i in range(n):
dp[k+1][i] = dp[k][dp[k][i]]
def test(x, a, b):
for i in range(U, -1, -1):
if x >> i & 1:
a = dp[i][a]
return a >= b
def solve(a, b):
if a > b:
a, b = b, a
ng = 0
ok = n-1
while ok - ng > 1:
mid = (ng + ok) // 2
if test(mid, a, b):
ok = mid
else:
ng = mid
print(ok)
q = int(eval(input()))
for _ in range(q):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
solve(a, b) | import sys
input = sys.stdin.readline
import bisect
n = int(eval(input()))
X = list(map(int, input().split()))
l = int(eval(input()))
U = 17
dp = [[0]*n for _ in range(U+1)]
for i, x in enumerate(X):
t = bisect.bisect_left(X, x+l)
dp[0][i] = bisect.bisect_right(X, x+l) - 1
for k in range(U):
for i in range(n):
dp[k+1][i] = dp[k][dp[k][i]]
q = int(eval(input()))
for _ in range(q):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
if a > b:
a, b = b, a
res = 1
for k in range(U, -1, -1):
if dp[k][a] < b:
a = dp[k][a]
res += (1<<k)
if a == b:
break
print(res) | p04017 |
from collections import defaultdict
from bisect import bisect
inpl = lambda: list(map(int, input().split()))
N = int(input())
X = inpl()
L = int(input())
Q = int(input())
R = {}
for i in range(N):
R[(0, i)] = bisect(X, X[i]+L) - 1
for k in range(16):
for i in range(N):
R[(k+1, i)] = R[(k, R[(k, i)])]
def reach(a, d):
O = format(d, "b").zfill(17)[::-1]
for k in range(16, -1, -1):
if O[k] == "1":
a = R[(k, a)]
return a
def bisearch(a, b):
a, b = a-1, b-1
if b < a:
a, b = b, a
OK = b-a
NG = 0
while abs(OK - NG) > 1:
mid = (OK+NG)//2
if reach(a, mid) >= b:
OK = mid
else:
NG = mid
return OK
print(*[bisearch(*inpl()) for _ in range(Q)], sep="\n")
| from bisect import bisect
inpl = lambda: list(map(int, input().split()))
N = int(input())
X = inpl()
L = int(input())
Q = int(input())
R = [[0]*(N) for k in range(17)]
for i in range(N):
R[0][i] = bisect(X, X[i]+L) - 1
for k in range(16):
for i in range(N):
R[k+1][i] = R[k][R[k][i]]
def reach(a, d):
O = format(d, "b").zfill(17)[::-1]
for k in range(16, -1, -1):
if O[k] == "1":
a = R[k][a]
return a
def bisearch(a, b):
a, b = a-1, b-1
if b < a:
a, b = b, a
OK = b-a
NG = 0
while abs(OK - NG) > 1:
mid = (OK+NG)//2
if reach(a, mid) >= b:
OK = mid
else:
NG = mid
return OK
print(*[bisearch(*inpl()) for _ in range(Q)], sep="\n")
| p04017 |
import heapq
N, L, T = list(map(int, input().split()))
X = [0 for i in range(N)]
ant = [[] for i in range(2)]
E = [0 for i in range(N)]
for i in range(N):
X[i], w = list(map(int, input().split()))
ant[w-1].append(i)
if w == 1:
end = X[i] + T
end = end % L
if w == 2:
end = X[i]-T
end = end % L
if end < 0:
end += L
E[i] = end
len0 = len(ant[0])
len1 = len(ant[1])
TA = []
for m in range(len0):
for n in range(len1):
Y0 = ant[0][m]
Y1 = ant[1][n]
sa = X[Y1] - X[Y0]
if sa < 0:
sa += L
gikan = sa / 2.0
while gikan < T:
heapq.heappush(TA,(gikan, Y0, Y1))
gikan += L / 2.0
lastant = [i for i in range(N)]
for i in range(len(TA)):
time, Y0, Y1 = heapq.heappop(TA)
a = lastant[Y0]
b = lastant[Y1]
lastant[Y0] = b
lastant[Y1] = a
result = [0 for i in range(N)]
for i in range(N):
result[lastant[i]] = E[i]
for i in range(N):
print((result[i]))
| N, L, T = list(map(int, input().split()))
X = [0 for i in range(N)]
W = [0 for i in range(N)]
E = [0 for i in range(N)]
count = 0
for i in range(N):
X[i], W[i] = list(map(int, input().split()))
if W[i] == 1:
end = X[i] + T
end = end % L
if W[i] == 2:
end = X[i]-T
end = end % L
if end < 0:
end += L
E[i] = end
shu = L / 2.0
if i > 0 and W[i] == 2 and W[0] == 1:
sa = X[i] -X[0]
if sa < 0:
sa += L
gikan = sa / 2.0
count += (T - gikan ) // shu + 1
if (T - gikan) % shu == 0:
count -= 1
if i > 0 and W[i] == 1 and W[0] == 2:
sa = X[0] -X[i]
if sa < 0:
sa += L
gikan = sa / 2.0
count -= (T - gikan ) // shu + 1
#print(E)
count = count % N
if count < 0:
count += N
count = int(count)
#print(count)
basho = E[0]
E.sort()
ind = E.index(basho)
result = [0 for i in range(N)]
for i in range(N):
newind = ind + i
if newind >= N :
newind -= N
result[count] = E[newind]
count += 1
if count >= N:
count -= N
for i in range(N):
print((result[i]))
| p03747 |
n, l, t = list(map(int, input().split()))
ants = [tuple(map(int, input().split())) for _ in range(n)]
place = []
clock = []
anticlock = []
for i, (x, w) in enumerate(ants):
if w == 1:
place.append((x + t) % l)
clock.append((i, x))
else:
place.append((x - t) % l)
anticlock.append((i, x))
def dist(x, y):
if x < y: return y - x
else: return y - x + l
swap = []
for i, x in clock:
for j, y in anticlock:
tmp = t * 2
d = dist(x, y)
if tmp > d:
tmp -= d
swap.append((d, i, j))
for c in range(1, tmp // l):
swap.append((d + c * l, i, j))
swap.sort(reverse=True)
for d, i, j in swap:
place[i], place[j] = place[j], place[i]
for p in place:
print(p) | n, l, t = list(map(int, input().split()))
ants = [tuple(map(int, input().split())) for _ in range(n)]
def dist(x, y, sign_0):
if sign_0 == -1:
x, y = y, x
if x < y: return y - x
else: return y - x + l
place = []
for i, (x, w) in enumerate(ants):
sign = 1 if w == 1 else -1
place.append((x + t * sign) % l)
if i == 0:
num = 0
x_0 = x
sign_0 = sign
elif sign_0 * sign == -1:
length = 2 * t
d = dist(x_0, x, sign_0)
if length > d or (length == d and sign_0 == -1):
num = (num + sign_0) % n
length -= d
num = (num + (length // l) * sign_0) % n
if length % l == 0 and sign_0 == 1:
num = (num - 1) % n
else: continue
place.sort()
i_0 = (place.index((x_0 + t * sign_0) % l) - num) % n
place.count((x_0 + t * sign_0) % l)
for i in range(i_0, n + i_0):
i = i % n
print((place[i])) | p03747 |
n,l,T = list(map(int,input().split()))
s = [0 for i in range(n)]
for i in range(n):
s[i] = list(map(int, input().split()))
def f(w):
if w == 1:
return 1
elif w == 2:
return -1
d=[0 for i in range(n)]
for i in range(n-1):
d[i] = s[i+1][0] - s[i][0]
d[n-1] = s[0][0] + l - s[n-1][0]
t = 0
dt = 0.5
while t < T:
t+= dt
s[0][0] = s[0][0] + f(s[0][1])*dt
if s[0][0] >= l:
s[0][0] -= l
elif s[0][0] < 0:
s[0][0] += l
for i in range(n):
if i < n-1:
d[i] = d[i] + f(s[i+1][1])*dt - f(s[i][1])*dt
s[i+1][0] = s[i][0] + d[i]
if s[i+1][0] >= l:
s[i+1][0] -= l
else:
d[n-1] = d[n-1] + f(s[0][1])*dt - f(s[n-1][1])*dt
for i in range(n):
if d[i] == 0 and i < n-1:
s[i+1][1], s[i][1] = s[i][1], s[i+1][1]
elif i == n-1 and d[i] == 0 :
s[0][1], s[n-1][1] = s[n-1][1], s[0][1]
import math
for i in range(n):
print((math.floor(s[i][0])))
| from math import floor
n,l,t = list(map(int,input().split()))
ants = []
touch = 0
for i in range(n):
x, w = list(map(int,input().split()))
if w == 1:
touch += (x + t) // l
x1 = (x + t) % l
else:
touch += (x - t) // l
x1 = (x - t) % l
ants.append(x1)
touch = touch % n
ants.sort()
ants = ants[touch:]+ants[:touch]
for i in range(n):
print((ants[i]))
| p03747 |
from collections import deque
n, l, t = list(map(int, input().split()))
ants = [list(map(int, input().split())) for i in range(n)]
# print(ants)
ants_t = []
count = 0
for ant in ants:
ant_t = ant
if ant[1] == 1:
c, ant_t[0] = divmod(t + ant[0], l)
# count += c
else:
c, ant_t[0] = divmod(-t + ant[0], l)
# count -= c
ants_t.append(ant_t)
count += c
# print(ants_t, count)
ants_d = deque(sorted(ants_t))
# print(ants_d)
# if ants_d[0][1] == 1:
# ants_d.rotate(count)
# else:
# ants_d.rotate(-count)
ants_d.rotate(-count)
# print(ants_d)
for ant in ants_d:
print(( (ant[0]) % l ))
| from collections import deque
n, l, t = list(map(int, input().split()))
ants = [list(map(int, input().split())) for i in range(n)]
ants_t = [0]*n
count = 0
for i in range(n):
ant = ants[i]
if ant[1] == 1:
c, ant_t = divmod(t + ant[0], l)
else:
c, ant_t = divmod(-t + ant[0], l)
ants_t[i] = ant_t
count += c
# print(ants_t, count)
ants_d = deque(sorted(ants_t))
# print(ants_d)
ants_d.rotate(-count)
# print(ants_d)
for ant in ants_d:
print(( (ant) % l ))
| p03747 |
#AGC 013 C - Ants on a Circle
N,L,T = list(map(int, input().split()))
X = [0]*N
W = [0]*N
for n in range(N):
X[n],W[n] = list(map(int, input().split()))
for t in range(T):
#print('now is ',t)
for n in range(N):
if n == N-1:
if X[N-1]%L == X[0] and W[N-1] == 1 and W[0] == 2:
W[N-1] = 2
W[0] =1
X[0] +=1
else:
X[N-1] += (-1)**(W[N-1]+1)
X[N-1] %= L
if X[N-1] == X[0]:
W[N-1] = 2
W[0] = 1
else:
if X[n] == X[n+1]:
W[n] = 2
W[n+1] = 1
X[n] += (-1)**(W[n]+1)
X[n] %= L
elif (X[n]+1)%L == X[n+1] and W[n] == 1 and W[n+1] == 2:
W[n] = 2
W[n+1] =1
X[n+1] -=1
else:
X[n] += (-1)**(W[n]+1)
X[n] %= L
#for n in range(N):
#print(X[n],' ',W[n])
for n in range(N):
print((X[n])) | N,L,T = list(map(int, input().split()))
X = [0]*N
W = [0]*N
for n in range(N):
X[n],W[n] = list(map(int, input().split()))
index = 0
#after T
for n in range(N):
X[n] += ((-1)**(W[n]+1))*T
index += X[n]//L
X[n] %= L
index %= N
X.sort()
X = X[index:] + X[:index] #No.1 wo hajimeni mottekuru.
for n in range(N):
print((X[n])) | p03747 |
N, L, T = list(map(int, input().split()))
L *= 2
T *= 2
X = [0] * N
W = [0] * N
for i in range(N):
X[i], W[i] = list(map(int, input().split()))
X[i] *= 2
if W[i] == 2:
W[i] = -1
# print(X, W)
for t in range(T):
for i in range(N):
X[i] = (X[i] + W[i]) % L
for i in range(N):
if X[i-1] == X[i]:
W[i-1] *= -1
W[i] *= -1
# print(X, W)
for x in X:
print((x // 2))
| N, L, T = list(map(int, input().split()))
s = 0
X = [0] * N
for i in range(N):
x, w = list(map(int, input().split()))
if w == 1:
x += T
else:
x -= T
# xが0点を通る回数を足す
s += x // L
X[i] = x % L
X.sort()
for i in range(N):
print((X[(i+s) % N]))
| p03747 |
N, L, T = [int(i) for i in input().split()]
ants = list([[x[0] * 2, x[1]] for x in [[int(i) for i in input().split()] for j in range(N)]])
for i in range(T * 2):
for j in range(N):
if ants[j][1] == 1:
if ants[j][0] == 2 * L - 1:
ants[j][0] = 0
else:
ants[j][0] += 1
if j == N - 1:
if ants[0][0] == ants[j][0]:
ants[0][1] = 1
ants[j][1] = 2
else:
if ants[j][0] == 0:
ants[j][0] = 2 * L - 1
else:
ants[j][0] -= 1
if j != 0:
if ants[j - 1][0] == ants[j][0]:
ants[j - 1][1] = 2
ants[j][1] = 1
for i in range(N):
print((ants[i][0] // 2)) | N, L, T = list(map(int, input().split()))
X = []
W = []
for _ in range(N):
x, w = list(map(int, input().split()))
X.append(x)
if w == 2:
w = -1
W.append(w)
C = 0
for i in range(1, N):
if W[i] != W[0]:
C += T // (L / 2)
if W[0] == 1:
D = X[i] - X[0]
else:
D = X[0] + L - X[i]
if T % (L / 2) * 2 >= D:
C += 1
for i in range(N):
X[i] = (X[i] + T * W[i]) % L
x = X[0]
X.sort()
ng = -1
ok = N
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if X[mid] >= x:
ok = mid
else:
ng = mid
if W[0] == 1 and ok < N-1:
if X[ok] == X[ok+1]:
ok += 1
start = int((ok - C * W[0]) % N)
for i in X[start:]:
print(i)
for i in X[:start]:
print(i) | p03747 |
M,D = list(map(int,input().split()))
ans = 0
for i in range(1, M+1):
for j in range(1, D+1):
if j < 22:
continue
else:
j = str(j)
d1 = int(j[0])
d2 = int(j[1])
if d1>=2 and d2>=2 and i == d1*d2:
ans += 1
print(ans) | M,D = list(map(int,input().split()))
ans = 0
for i in range(1, M+1):
for j in range(1, D+1):
if j//10 >=2 and j%10 >=2 and i == (j//10)*(j%10):
ans += 1
print(ans) | p02927 |
# jsc2019-qualA - Takahashi Calendar
# exhaustive search
def main():
M, D = tuple(map(int, input().split()))
ans = 0
for m in range(1, M + 1):
for d in range(1, D + 1):
if len(str(d)) != 1:
d1, d10 = int(str(d)[1]), int(str(d)[0])
if d1 >= 2 and d10 >= 2:
ans += 1 if d1 * d10 == m else 0
print(ans)
if __name__ == "__main__":
main() | # jsc2019-qualA - Takahashi Calendar
def main():
M, D = tuple(map(int, input().split()))
ans = 0
for d in range(22, D + 1):
d1, d10 = d % 10, d // 10
ans += 1 if d1 >= 2 and d1 * d10 <= M else 0
print(ans)
if __name__ == "__main__":
main() | p02927 |
#import pysnooper
#import numpy
#import os,re,sys,operator
#from collections import Counter,deque
#from operator import itemgetter,mul
#from itertools import accumulate,combinations,groupby,combinations_with_replacement,permutations
from sys import stdin,setrecursionlimit
#from bisect import bisect_left,bisect_right
#from copy import deepcopy
#import heapq
#import math
#import string
#from time import time
#from functools import lru_cache,reduce
#from math import factorial,hypot
#import sys
#from fractions import gcd
setrecursionlimit(10**6)
input=stdin.readline
m,d=list(map(int,input().split()))
ans=0
for i in range(1,m+1):
for j in range(1,d+1):
s=str(j)
if len(s)>=2:
o,t=int(s[0]),int(s[1])
if o>=2 and t>=2 and o*t==i:
#print(i,j)
ans+=1
print(ans) | m,d=list(map(int,input().split()))
ans=0
for month in range(1,m+1):
for day in range(1,d+1):
day=str(day)
if len(day)!=2:
continue
if int(day[0])*int(day[1])!=month:
continue
if int(day[0])<2 or int(day[1])<2:
continue
#print(month,day)
ans+=1
print(ans) | p02927 |
M, D = list(map(int, input().split()))
count = 0
for m in range(1, M + 1):
for d in range(1, D + 1):
d1 = int(str(d).zfill(2)[1])
d10 = int(str(d).zfill(2)[0])
if d1 >= 2 and d10 >= 2 and d1 * d10 == m:
count += 1
print(count)
| M, D = list(map(int, input().split()))
count = 0
for m in range(1, M + 1):
for d in range(1, D + 1):
d10, d1 = divmod(d, 10)
if d1 >= 2 and d10 >= 2 and d1 * d10 == m:
count += 1
print(count)
| p02927 |
M,D = list(map(int, input().split()))
D = int(D)
ans = 0
for i in range(1,M+1):
for j in range(1,D+1):
j = str(j)
if len(j) == 2:
j1 = int(j[0])
j2 = int(j[1])
if j1 >= 2 and j2 >= 2 and j1 * j2 == i:
ans += 1
print(ans)
| M,D = list(map(int, input().split()))
ans = 0
for i in range(1,M+1):
for j in range(1,D+1):
j1 = j // 10
j2 = j % 10
if j1 >= 2 and j2 >= 2 and j1 * j2 == i:
ans += 1
print(ans) | p02927 |
M, D = list(map(int, input().split()))
ans = 0
for m in range(1, M+1):
for d in range(22, D+1):
d1 = d % 10
if d1 < 2: continue
d10 = d // 10
if d10 < 2: continue
if d1 * d10 == m:
ans += 1
print(ans)
| M, D = list(map(int, input().split()))
ans = 0
for d in range(22, D+1):
d1 = d % 10
if d1 < 2: continue
d10 = d // 10
if d10 < 2: continue
if d1 * d10 <= M:
ans += 1
print(ans) | p02927 |
tmp = [int(i) for i in input().split()]
M, D = tmp[0], tmp[1]
if D < 22 or M < 4:
print((0))
else:
days = [(str(i)[0], str(i)[1]) for i in range(22, D+1) if int(str(i)[0])>1 and int(str(i)[1])>1]
n = 0
for m in range(4, M+1):
for d in days:
if m == int(d[0])*int(d[1]):
n +=1
print(n) | tmp = [int(i) for i in input().split()]
M, D = tmp[0], tmp[1]
if D < 22 or M < 4:
print((0))
else:
days = [(str(i)[0], str(i)[1]) for i in range(22, D+1) if int(str(i)[0])>1 and int(str(i)[1])>1]
n = 0
print((sum([1 for m in range(4, M+1) for d in days if m == int(d[0])*int(d[1])]))) | p02927 |
M,D = list(map(int,input().split()))
cnt = 0
for i in range(22,D+1):
d = str(i)
if int(d[1])>=2 and int(d[1])*int(d[0])<=M:
cnt += 1
print(cnt) | M,D = list(map(int,input().split()))
cnt = 0
for m in range(4,M+1):
for d in range(1,D+1):
if d>=20:
d = str(d)
if int(d[1])>=2:
if m==int(d[0])*int(d[1]):
cnt += 1
print(cnt) | p02927 |
M, D = list(map(int, input().split()))
ans = 0
for i in range(1, M+1):
for j in range(1, D+1):
if len(str(j)) == 1:
continue
# 日付が二桁以上であることが確定
d1 = int(str(j)[0])
d2 = int(str(j)[1])
if d1 >= 2 and d2 >= 2:
if i == (d1*d2):
ans += 1
print(ans)
| M, D = list(map(int, input().split()))
ans = 0
for i in range(1, M+1): # 月
for j in range(10, D+1): # 日付
d1 = int(str(j)[0])
d2 = int(str(j)[1])
if d1 > 1 and d2 > 1:
if i == (d1 * d2):
ans += 1
print(ans)
| p02927 |
M, D = list(map(int, input().split()))
ans = 0
for m in range(1, M+1):
for d in range(20, D + 1):
a, b = list(map(int, str(d)))
if b < 2:
continue
elif m == a*b:
ans += 1
print(ans)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
M, D = list(map(int, input().split()))
ans = 0
for d in range(20, D + 1):
for m in range(1, M+1):
a, b = d//10, d % 10
if m == a*b and b >= 2:
ans += 1
print(ans)
| p02927 |
M,D=list(map(int, input().split()))
seki=0
for m in range(1,M+1):
for d in range(1,D+1):
str_d = str(d)
if len(str_d)==2:
d10 = int(str_d[0])
d1 = int(str_d[1])
if d10 >= 2 and d1 >= 2 and d10*d1 == m:
seki+=1
print(seki) | M, D = list(map(int, input().split()))
seki = 0
for m in range(1, M + 1):
for d in range(1, D + 1):
d10, d1 = divmod(d, 10)
if d10 >= 2 and d1 >= 2 and d10 * d1 == m:
seki += 1
print(seki) | p02927 |
n = int(eval(input()))
d = [int(eval(input())) for i in range(n)]
pos = 0
ans = "yes"
for i in range(n):
if pos>=i*10:
pos = max(pos,i*10+d[i])
else:
ans = "no"
break
if pos >= (n-1)*10:
break
pos = 0
for i in range(n):
if pos>=i*10:
pos = max(pos,i*10+d[n-1-i])
else:
ans = "no"
break
if pos >= (n-1)*10:
break
print(ans)
| n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
ok = True
rg = list(range(n))
l = 0
for i,d in zip(rg,a):
if i*10 > l:
ok = False
break
if l >= (n-1)*10:
break
if i*10+d > l:
l = i*10+d
a.reverse()
l = 0
for i,d in zip(rg,a):
if i*10 > l:
ok = False
break
if l >= (n-1)*10:
break
if i*10+d > l:
l = i*10+d
if ok:
print('yes')
else:
print('no')
| p00357 |
import collections
def solve():
R = int(eval(input()))
if R < 1200:
print("ABC")
elif R < 2800:
print("ARC")
else:
print("AGC")
if __name__ == "__main__":
solve()
| R = int(eval(input()))
if R < 1200:
print("ABC")
elif R < 2800:
print("ARC")
else:
print("AGC")
| p03288 |
a = int(eval(input()))
print(("ABC" if a<1200 else "ARC" if a<2800 else "AGC")) | C = ["ABC", "ARC" , "AGC"]
A = int(eval(input()))
print((C[(A>1199)+(A>2799)])) | p03288 |
r=int(eval(input()))
print(("ABC" if r<1200 else "ARC" if r<2800 else "AGC")) | print((["ABC","ARC","AGC"][(int(eval(input()))+400)//1600])) | p03288 |
r=int(eval(input()))
data1=1200
dara2=2800
name=('ABC', 'ARC', 'AGC')
if r<data1:
print((name[0]))
elif data1<=r<2800:
print((name[1]))
else:
print((name[2]))
| r=int(eval(input()))
data1=1200
data2=2800
name=('ABC', 'ARC', 'AGC')
if r<data1:
print((name[0]))
elif data1<=r<data2:
print((name[1]))
else:
print((name[2])) | p03288 |
r=int(eval(input()))
data1=1200
data2=2800
name=('ABC', 'ARC', 'AGC')
if r<data1:
print((name[0]))
elif data1<=r<data2:
print((name[1]))
else:
print((name[2])) | r=int(eval(input()))
data=(1200,2800)
name=('ABC', 'ARC', 'AGC')
if r<data[0]:
print((name[0]))
elif data[0]<=r<data[1]:
print((name[1]))
else:
print((name[2]))
| p03288 |
r=int(input())
data=(1200,2800)
name=('ABC', 'ARC', 'AGC')
[print(name[0]) for i in range(1) if r < 1200]
[print(name[1]) for i in range(1) if 1200 <= r < 2800 ]
[print(name[2]) for i in range(1) if 2800 <=r ]
| r=int(eval(input()))
data=(1200,2800)
name=('ABC', 'ARC', 'AGC')
z=[name[0] if r < 1200 else name[1] if 1200 <= r < 2800 else name[2] if 2800 <= r else i for i in range(1)]
print((z[0])) | p03288 |
R = int(eval(input()))
if R < 1200:
print("ABC")
elif R < 2800:
print("ARC")
else:
print("AGC") | R = int(eval(input()))
print(("ABC" if R <1200 else "ARC" if R < 2800 else "AGC")) | p03288 |
R = int(eval(input()))
if R < 1200:
print('ABC')
elif 1200 <= R < 2800:
print('ARC')
else:
print('AGC') | R = int(eval(input()))
print(('ABC' if R < 1200 else 'ARC' if 1200 <= R < 2800 else 'AGC'))
| p03288 |
R = int(eval(input()))
if R<1200:
print("ABC")
elif R<2800:
print("ARC")
else:
print("AGC") | print(("A"+"BRG"[(int(eval(input()))+400)//1600]+"C")) | p03288 |
import sys
ri = lambda: int(sys.stdin.readline())
a = ri()
if a < 1200:
print('ABC')
elif a < 2800:
print('ARC')
else:
print('AGC') | import sys
ri = lambda: int(sys.stdin.readline())
a = ri()
if a < 1200:
print('ABC')
else:
print(('ARC' if a < 2800 else 'AGC')) | p03288 |
print(("A"+"BRG"[(int(eval(input()))+400)//1600]+"C"))
| print(("A"+"BRG"[int(eval(input()))//50+8>>5]+"C")) | p03288 |
rating = int(eval(input()))
if rating < 1200:
print('ABC')
elif 1200 <= rating < 2800:
print('ARC')
elif rating >= 2800:
print('AGC')
| r = int(eval(input()))
if r < 1200:
print('ABC')
elif r < 2800:
print('ARC')
else:
print('AGC')
| p03288 |
# -*- coding: utf-8 -*-
R = int(eval(input()))
if R >=2800:
print("AGC")
elif R >= 1200 and 2800 > R:
print("ARC")
else:
print("ABC") | R = int(eval(input()))
if R < 1200:
ans = "ABC"
elif R <2800:
ans = "ARC"
else:
ans = "AGC"
print(ans) | p03288 |
n, s = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = None
for window in range(0, n):
sum_a = None
for i in range(n-window):
if sum_a == None:
sum_a = sum(a[i:window+1])
else:
sum_a += a[i+window] - a[i-1]
if sum_a >= s:
ans = window+1
break
if ans != None: break
if ans == None: ans = 0
print(ans)
| n, s = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = None
init_tmp = 0
for window in range(n):
init_tmp += a[window]
sum_a = init_tmp
for i in range(n-window):
if i != 0:
sum_a += a[i+window] - a[i-1]
if sum_a >= s:
ans = window+1
break
if ans != None: break
if ans == None: ans = 0
print(ans)
| p02354 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
m = 10**19
idx = 0
for i in range(n):
d = t - h[i]*0.006
if abs(a-d) < m:
m = abs(a-d)
idx = i+1
print(idx)
| n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
m = 10**19
# 地点の番号(=1)
idx = 0
for i in range(n):
# 平均気温
d = t - h[i]*0.006
# A度に最も近い地点
if abs(a-d) < m:
m = abs(a-d)
idx = i+1
print(idx)
| p03220 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
diff_list = [abs(t-h_i*0.006-a) for h_i in map(int, input().split())]
print((diff_list.index(min(diff_list))+1)) | n = int(eval(input()))
t,a = list(map(int, input().split()))
tmp_diff_list = [abs(t-i*0.006-a) for i in list(map(int, input().split()))]
print((tmp_diff_list.index(min(tmp_diff_list))+1)) | p03220 |
N = int(eval(input()))
T,A = list(map(int,input().split()))
H = list(map(int,input().split()))
num = abs(A - T + H[0]*0.006)
ans = 1
for i in range(1,N):
if num > abs(A-T+H[i]*0.006):
num = abs(A-T+H[i]*0.006)
ans = i+1
print(ans) | N = int(eval(input()))
T,A = list(map(int,input().split()))
H = list(map(int,input().split()))
a_list = []
for i in range(N):
a_list.append(abs(A-(T-H[i]*0.006)))
print((a_list.index(min(a_list))+1)) | p03220 |
# 入力
N = int(eval(input()))
[T,A] = list(map(int, input().split()))
H = list(map(int, input().split()))
# 処理
ans_idx = -1 # 答えとなる地点のインデックス
ans_t = -1 # 答えとなる地点の気温
for i in range(N):
t = T - H[i]*0.006 # i番目の地点の気温
if ans_idx < 0 or abs(t-A) < abs(ans_t-A):
ans_idx = i
ans_t = t
# 答え
print((ans_idx+1)) | def calc_temp(i):
return T - 0.006*H[i]
N = int(eval(input()))
[T,A] = list(map(int,input().split()))
H = list(map(int,input().split()))
ans = 0
for i in range(N):
if abs(A-calc_temp(i)) < abs(A-calc_temp(ans)):
ans = i
print((ans+1))
| p03220 |
n = int(eval(input()))
t,a = list(map(int,input().split()))
h = list(map(int,input().split()))
ans = 1
min_dif = abs(t-h[0]*0.006-a)
for i in range(1,n):
dif = abs(t-h[i]*0.006-a)
if min_dif > dif: min_dif,ans = dif,i+1
print(ans) | n = int(eval(input()))
t,a = list(map(int,input().split()))
h = list(map(int,input().split()))
dif = 10**10
ans = 0
for i in range(n):
z = t-h[i]*0.006
if dif>abs(a-z):
dif = abs(a-z)
ans = i+1
print(ans) | p03220 |
import sys
n = int(eval(input()))
t,a = list(map(int,input().split()))
h = list(map(int,input().split()))
c = t - h[0] * 0.006
k = 1
for i in range(n):
if abs(a-c) > abs(a-(t - h[i] * 0.006)):
c = t - h[i] * 0.006
k = i + 1
print(k) | n = int(eval(input()))
t,a = list(map(int,input().split()))
h = list(map(int,input().split()))
mi = 1000000000
for i in range(n):
if mi > abs(a-(t-h[i]*0.006)):
mi = abs(a-(t-h[i]*0.006))
ans = i+1
print(ans)
| p03220 |
N = int(eval(input()))
T, A = list(map(int,input().split()))
H = list(map(int,input().split()))
for i in range(N):
H[i] = T - H[i]*0.006
h = 100000
a = 0
for i in range(N):
if abs(H[i]-A) < h:
h = abs(H[i]-A)
a = i+1
print(a) | N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
bestH = (T - A) / 0.006
d = float('inf')
ans = 0
for i in range(N):
if d > abs(H[i] - bestH):
d = abs(H[i] - bestH)
ans = i + 1
print(ans)
| p03220 |
n = int(eval(input()))
t, a = [int(x) for x in input().split()]
locations =[int(x) for x in input().split()]
print((min([(i+1,abs(a - (t - x * 6e-3))) for i, x in enumerate(locations)],key=(lambda j:j[1]))[0]))
|
n = int(eval(input()))
t, a = [int(x) for x in input().split()]
locations =[int(x) for x in input().split()]
# print(min([(i+1,abs(a - (t - x * 6e-3))) for i, x in enumerate(locations)],key=(lambda j:j[1]))[0])
diff = [abs(a - (t - x * 6e-3)) for x in locations]
print((diff.index(min(diff))+1))
| p03220 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
H = [abs(t-a-x * 6e-3) for x in h]
print((1 + H.index(min(H)))) | n = int(eval(input()))
t, a = list(map(int, input().split()))
lst = [ abs((t - i * 0.006)-a) for i in list(map(int, input().split()))]
print((lst.index(min(lst)) + 1))
| p03220 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.