input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
def kukan(n, a):
dp = [[0] * n for _ in range(n)]
for i in range(n):
dp[i][i] = a[i]
for i in range(n - 2, -1, -1):
for j in range(i + 1, n):
L = a[i] - dp[i + 1][j]
R = a[j] - dp[i][j - 1]
dp[i][j] = L if L > R else R
return dp[0][n - 1]
n = int(eval(input()))
a = list(map(int, input().split()))
print((kukan(n, a)))
| def kukan(n, a):
dp = [[0] * n for _ in range(n)]
for i in range(n):
dp[i][i] = a[i]
for i in range(n - 2, -1, -1):
g0 = dp[i]
g1 = dp[i + 1]
for j in range(i + 1, n):
L = a[i] - g1[j]
R = a[j] - g0[j - 1]
dp[i][j] = L if L > R else R
return dp[0][n - 1]
n = int(eval(input()))
a = list(map(int, input().split()))
print((kukan(n, a)))
| p03171 |
#!/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 LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
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 = 1e10
"""
URL: https://atcoder.jp/contests/dp/tasks/dp_l
L - Deque /
実行時間制限: 2 sec / メモリ制限: 1024 MB
配点 :
100 点
問題文
太郎君と次郎君が次のゲームで勝負します。
最初に、数列 a=(a1,a2,…,aN) が与えられます。
a が空になるまで、二人は次の操作を交互に行います。
先手は太郎君です。a の先頭要素または末尾要素を取り除く。
取り除いた要素を x とすると、操作を行った人は x 点を得る。
ゲーム終了時の太郎君の総得点を X、次郎君の総得点を Y とします。
太郎君は X−Y を最大化しようとし、次郎君は X−Y を最小化しようとします。
二人が最適に行動すると仮定したとき、X−Y を求めてください。
解説:
ただの区間DP
しかし、Pythonはカスなので工夫が必要
知見
====================================================================
|dp[i][j]に-dp[i][j-1] or -dp[i+1][j]の加算結果を与えれば |
| 右辺の式はすべて符号反転するので－側の最小を目指すというのと |
| ＋の最大を目指すというのを満たすのでその区間における |
| プレイヤーの最善スコアが出る |
====================================================================|
"""
#solve
def solve():
n = II()
a = LI()
dp = defaultdict(int)
for i in range(n):
dp[(i,i)] = a[i]
for i in range(n - 2, -1, -1):
for j in range(i+1, n):
dp[(i,j)] = max(a[i]-dp[(i+1,j)], a[j]-dp[(i,j-1)])
print((dp[(0, n - 1)]))
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 LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
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 = 1e10
"""
URL: https://atcoder.jp/contests/dp/tasks/dp_l
L - Deque /
実行時間制限: 2 sec / メモリ制限: 1024 MB
配点 :
100 点
問題文
太郎君と次郎君が次のゲームで勝負します。
最初に、数列 a=(a1,a2,…,aN) が与えられます。
a が空になるまで、二人は次の操作を交互に行います。
先手は太郎君です。a の先頭要素または末尾要素を取り除く。
取り除いた要素を x とすると、操作を行った人は x 点を得る。
ゲーム終了時の太郎君の総得点を X、次郎君の総得点を Y とします。
太郎君は X−Y を最大化しようとし、次郎君は X−Y を最小化しようとします。
二人が最適に行動すると仮定したとき、X−Y を求めてください。
解説:
ただの区間DP
しかし、Pythonはカスなので工夫が必要
知見
====================================================================
|dp[i][j]に-dp[i][j-1] or -dp[i+1][j]の加算結果を与えれば |
| 右辺の式はすべて符号反転するので－側の最小を目指すというのと |
| ＋の最大を目指すというのを満たすのでその区間における |
| プレイヤーの最善スコアが出る |
====================================================================|
"""
#solve
def solve():
n = II()
a = LI()
dp = [[0]*n for i in range(n)]
for i in range(n):
dp[i][i] = a[i]
for i in range(n - 2, -1, -1):
dpi = dp[i]
dpi1 = dp[i + 1]
ai = a[i]
for j in range(i + 1, n):
dpi[j] = max(ai-dpi1[j], a[j]-dpi[j-1])
print((dp[0][n - 1]))
return
#main
if __name__ == '__main__':
solve()
| p03171 |
import sys
sys.setrecursionlimit(10**9)
def recursive(i,j):
if i>j:
return 0
elif dp.get((i,j)):
return dp[(i,j)]
dp[(i,j)]=max(nums[i]-recursive(i+1,j),nums[j]-recursive(i,j-1))
return dp[(i,j)]
dp={}
n=int(eval(input()))
nums=list(map(int,input().split()))
#print(dp)
print((recursive(0,n-1)))
| dp={}
n=int(eval(input()))
nums=list(map(int,input().split()))
#print(dp)
#print(recursive(0,n-1))
dp=[[0]*(n+1) for _ in range(n+1)]
for i in range(n-1,-1,-1):
for j in range(i,n,1):
dp[i][j]=max(nums[i]-dp[i+1][j],nums[j]-dp[i][j-1])
print((dp[0][n-1]))
| p03171 |
import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
from functools import lru_cache
def resolve():
n = int(eval(input()))
A = list(map(int, input().split()))
@lru_cache(None)
def dfs(l, r):
# base case
if l == r:
return 0
turn = (n - (r - l)) & 1
if turn & 1 == 0: # first
return max(A[l] + dfs(l + 1, r), A[r - 1] + dfs(l, r - 1))
else: # second
return min(-A[l] + dfs(l + 1, r), -A[r - 1] + dfs(l, r - 1))
print((dfs(0, n)))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
from functools import lru_cache
def resolve():
n = int(eval(input()))
A = list(map(int, input().split()))
dp = [[None] * (n + 1) for _ in range(n + 1)]
for i in range(n + 1):
dp[i][i] = 0
for width in range(1, n + 1):
for l in range(n):
r = l + width
if r > n:
break
turn = (n - (r - l)) & 1
if turn & 1 == 0:
dp[l][r] = max(A[l] + dp[l + 1][r], A[r - 1] + dp[l][r - 1])
else:
dp[l][r] = min(-A[l] + dp[l + 1][r], -A[r - 1] + dp[l][r - 1])
print((dp[0][n]))
resolve() | p03171 |
# input
N = int(eval(input()))
As = list(map(int, input().split()))
# Nの偶奇。区間幅がNの偶奇と一致すれば太郎君目線
oe = N % 2
# def print_list(lis):
# for l in lis:
# print(l)
# score[i][j][p] : Asのi番目を左端、j番目を右端とした時の最終スコア
# p = 0 が太郎君目線、p = 1 が次郎くん目線
score = [[[None for _ in range(2)] for _ in range(N)] for _ in range(N)]
for i in range(N):
# 初期化
# 区間長さ0であれば1通りしかない
score[i][i][0] = As[i]
score[i][i][1] = -As[i]
# print_list(score)
for k in range(1, N):
# 配列の幅を広げながら計算を進める
for i in range(0, N-k):
# if k == 0:
# continue
j = i + k
if i == N - 1:
if (k + 1) % 2 == oe:
score[i][j][0] = score[i][j-1][1] + As[j]
else:
score[i][j][1] = score[i][j-1][0] - As[j]
else:
# print(i,j)
if (k + 1) % 2 == oe:
score[i][j][0] = max(score[i+1][j][1] + As[i], score[i][j-1][1] + As[j])
else:
score[i][j][1] = min(score[i+1][j][0] - As[i], score[i][j-1][0] - As[j])
# print_list(score)
print((score[0][N-1][0]))
| # input
N = int(eval(input()))
As = list(map(int, input().split()))
# Nの偶奇。区間幅がNの偶奇と一致すれば太郎君目線
oe = N % 2
# def print_list(lis):
# for l in lis:
# print(l)
# score[i][j][p] : Asのi番目を左端、j番目を右端とした時の最終スコア
# p = 0 が太郎君目線、p = 1 が次郎くん目線
score = [[None for _ in range(N)] for _ in range(N)]
for i in range(N):
# 初期化
# 区間長さ1であれば1通りしかない
if oe == 1:
score[i][i] = As[i]
else:
score[i][i] = -As[i]
# print_list(score)
for k in range(1, N):
# 配列の幅を広げながら計算を進める
for i in range(0, N-k):
# if k == 0:
# continue
j = i + k
if i == N - 1:
if (k + 1) % 2 == oe:
score[i][j] = score[i][j-1] + As[j]
else:
score[i][j] = score[i][j-1] - As[j]
else:
# print(i,j)
if (k + 1) % 2 == oe:
score[i][j] = max(score[i+1][j] + As[i], score[i][j-1] + As[j])
else:
score[i][j] = min(score[i+1][j] - As[i], score[i][j-1] - As[j])
# print_list(score)
print((score[0][N-1]))
| p03171 |
# input
N = int(eval(input()))
As = list(map(int, input().split()))
# Nの偶奇。区間幅がNの偶奇と一致すれば太郎君目線
oe = N % 2
# def print_list(lis):
# for l in lis:
# print(l)
# score[i][j][p] : Asのi番目を左端、j番目を右端とした時の最終スコア
# p = 0 が太郎君目線、p = 1 が次郎くん目線
score = [[None for _ in range(N)] for _ in range(N)]
for i in range(N):
# 初期化
# 区間長さ1であれば1通りしかない
if oe == 1:
score[i][i] = As[i]
else:
score[i][i] = -As[i]
# print_list(score)
for k in range(1, N):
# 配列の幅を広げながら計算を進める
for i in range(0, N-k):
# if k == 0:
# continue
j = i + k
if i == N - 1:
if (k + 1) % 2 == oe:
score[i][j] = score[i][j-1] + As[j]
else:
score[i][j] = score[i][j-1] - As[j]
else:
# print(i,j)
if (k + 1) % 2 == oe:
score[i][j] = max(score[i+1][j] + As[i], score[i][j-1] + As[j])
else:
score[i][j] = min(score[i+1][j] - As[i], score[i][j-1] - As[j])
# print_list(score)
print((score[0][N-1]))
| # input
N = int(eval(input()))
As = list(map(int, input().split()))
# Nの偶奇。区間幅がNの偶奇と一致すれば太郎君目線
oe = N % 2
# def print_list(lis):
# for l in lis:
# print(l)
# score[i][j][p] : Asのi番目を左端、j番目を右端とした時の最終スコア
# p = 0 が太郎君目線、p = 1 が次郎くん目線
score = [[0 for _ in range(N)] for _ in range(N)]
for i in range(N):
# 初期化
# 区間長さ1であれば1通りしかない
if oe == 1:
score[i][i] = As[i]
else:
score[i][i] = -As[i]
# print_list(score)
for k in range(1, N):
# 配列の幅を広げながら計算を進める
for i in range(0, N-k):
# if k == 0:
# continue
j = i + k
if i == N - 1:
if (k + 1) % 2 == oe:
score[i][j] = score[i][j-1] + As[j]
else:
score[i][j] = score[i][j-1] - As[j]
else:
# print(i,j)
if (k + 1) % 2 == oe:
score[i][j] = max(score[i+1][j] + As[i], score[i][j-1] + As[j])
else:
score[i][j] = min(score[i+1][j] - As[i], score[i][j-1] - As[j])
# print_list(score)
print((score[0][N-1]))
| p03171 |
#L
import sys
sys.setrecursionlimit(10**5)
N=int(eval(input()))
a=list(map(int,input().split()))
S=[0]*(N+1)
for i in range(N):
S[i+1]=S[i]+a[i]
dp=[[0]*(N+1) for _ in range(N+1)]#[l,r)の範囲が残っているときに取れる最大値
def rep(l,r):
if l==r:
return 0
if dp[l][r]!=0:
return dp[l][r]
else:
x=a[l]+(S[r]-S[l+1] - rep(l+1,r))
y=a[r-1]+(S[r-1]-S[l] - rep(l,r-1))
dp[l][r]=max(x,y)
return dp[l][r]
rep(0,N)
print((2*dp[0][N] - S[-1] ))
| #L
N=int(eval(input()))
a=list(map(int,input().split()))
S=[0]*(N+1)
for i in range(N):
S[i+1]=S[i]+a[i]
dp=[[0]*(N+1) for _ in range(N+1)]#[l,r)の範囲が残っているときに取れる最大値
for i in range(1,N+1):#r-lの値
for j in range(N):#lの値
r=j+i
if r>N:
break
l=j
x=a[l]+(S[r]-S[l+1]) - dp[l+1][r]
y=a[r-1]+(S[r-1]-S[l]) - dp[l][r-1]
dp[l][r]=max(x,y)
print((2*dp[0][N] - S[-1] )) | p03171 |
def solve():
n = int(eval(input()))
a = list(int(x) for x in input().split())
memo = [[None] * n for _ in range(n)]
for i, aa in enumerate(a):
memo[i][i] = aa
for l in range(n - 2, -1, -1):
for r in range(l + 1, n):
memo[l][r] = max(a[r] - memo[l][r - 1], a[l] - memo[l + 1][r])
print((memo[0][n - 1]))
if __name__ == '__main__':
solve()
# [l,r]を
# l:=配列aの右端から左にシフト
# r:=lと一致する位置からn-1まで右にシフト
# と考えると、l==rは既にメモ化済みなので、l=n-2以前、r=l+1以降を調べればよい
# 漸化式で使う値は、
# lがより右にいるときの計算結果（前のループで計算済み）と
# rがより左にいるときの計算結果（一番左でもl==rなので計算済み）
# なので、参照する値がNoneになることはなく、Noneのチェックは不要になる
# listにした
| def solve():
n = int(eval(input()))
a = tuple(int(x) for x in input().split())
memo = tuple([None] * n for _ in range(n))
for i in range(n):
memo[i][i] = a[i]
for l in range(n - 2, -1, -1):
for r in range(l + 1, n):
memo[l][r] = max(a[r] - memo[l][r - 1], a[l] - memo[l + 1][r])
print((memo[0][n - 1]))
if __name__ == '__main__':
solve()
# [l,r]を
# l:=配列aの右端から左にシフト
# r:=lと一致する位置からn-1まで右にシフト
# と考えると、l==rは既にメモ化済みなので、l=n-2以前、r=l+1以降を調べればよい
# 漸化式で使う値は、
# lがより右にいるときの計算結果（前のループで計算済み）と
# rがより左にいるときの計算結果（一番左でもl==rなので計算済み）
# なので、参照する値がNoneになることはなく、Noneのチェックは不要になる
# enumerateを辞めた
| p03171 |
def solve():
n = int(eval(input()))
a = tuple(int(x) for x in input().split())
memo = tuple([None] * n for _ in range(n))
for i in range(n):
memo[i][i] = a[i]
for l in range(n - 2, -1, -1):
for r in range(l + 1, n):
memo[l][r] = max(a[r] - memo[l][r - 1], a[l] - memo[l + 1][r])
print((memo[0][n - 1]))
if __name__ == '__main__':
solve()
# [l,r]を
# l:=配列aの右端から左にシフト
# r:=lと一致する位置からn-1まで右にシフト
# と考えると、l==rは既にメモ化済みなので、l=n-2以前、r=l+1以降を調べればよい
# 漸化式で使う値は、
# lがより右にいるときの計算結果（前のループで計算済み）と
# rがより左にいるときの計算結果（一番左でもl==rなので計算済み）
# なので、参照する値がNoneになることはなく、Noneのチェックは不要になる
# enumerateを辞めた
| n = int(eval(input()))
a = list(map(int, input().split()))
dp = [[0] * n for _ in range(n)]
for i in range(n):
dp[i][i] = a[i]
for i in range(n - 2, -1, -1):
for j in range(i + 1, n):
dp[i][j] = max(a[i] - dp[i + 1][j], a[j] - dp[i][j - 1])
print((dp[0][n - 1]))
# 下記提出と全く同じ内容で提出します
# https://atcoder.jp/contests/dp/submissions/6590284
# これまでの連投で参考にしていたコード
# ほぼ同じ内容で提出しているつもりなのに、速度差が一向に縮まらない
# maxの引数の順番が自分と違うのが速度差の原因？
| p03171 |
n = int(eval(input()))
a = tuple(int(x) for x in input().split())
memo = tuple([None] * n for _ in range(n))
for i in range(n):
memo[i][i] = a[i]
for l in range(n - 2, -1, -1):
for r in range(l + 1, n):
memo[l][r] = max(a[l] - memo[l + 1][r], a[r] - memo[l][r - 1])
print((memo[0][n - 1]))
# [l,r]を
# l:=配列aの右端から左にシフト
# r:=lと一致する位置からn-1まで右にシフト
# と考えると、l==rは既にメモ化済みなので、l=n-2以前、r=l+1以降を調べればよい
# 漸化式で使う値は、
# lがより右にいるときの計算結果（前のループで計算済み）と
# rがより左にいるときの計算結果（一番左でもl==rなので計算済み）
# なので、参照する値がNoneになることはなく、Noneのチェックは不要になる
# if __name__ == '__main__':を辞めた
| def main():
n = int(eval(input()))
a = tuple(int(x) for x in input().split())
memo = tuple([None] * n for _ in range(n))
for i in range(n):
memo[i][i] = a[i]
for l in range(n - 2, -1, -1):
for r in range(l + 1, n):
memo[l][r] = max(a[l] - memo[l + 1][r], a[r] - memo[l][r - 1])
print((memo[0][n - 1]))
if __name__ == '__main__':
main()
# [l,r]を
# l:=配列aの右端から左にシフト
# r:=lと一致する位置からn-1まで右にシフト
# と考えると、l==rは既にメモ化済みなので、l=n-2以前、r=l+1以降を調べればよい
# 漸化式で使う値は、
# lがより右にいるときの計算結果（前のループで計算済み）と
# rがより左にいるときの計算結果（一番左でもl==rなので計算済み）
# なので、参照する値がNoneになることはなく、Noneのチェックは不要になる
# 関数名は関係あるのか？
| p03171 |
#!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
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,k = LI()
a = LI()
dp = [0 for i in range(k+1)]
f = [0 for i in range(k+1)]
for i in range(k+1):
if not f[i]:
for j in a:
if i-j >= 0:
dp[i] = 1-dp[i-j]
if dp[i] == 0:
break
else:
dp[i] = 1
print((["First","Second"][dp[k]]))
#B
def B():
def dfs(d,m):
if dp[m] != None:
return dp[m]
l = []
for i in range(n+1):
if p[i]&m:
l.append(i)
for j in range(i,n+1):
if not p[j]&m:
l.append(j-1)
break
else:
l.append(n)
break
if not d%2:
res = -float("inf")
for i in l:
res = max(res,a[i]+dfs(d+1,m^p[i]))
dp[m] = res
return dp[m]
else:
res = float("inf")
for i in l:
res = min(res,-a[i]+dfs(d+1,m^p[i]))
dp[m] = res
return dp[m]
n = I()
a = LI()
b = deque()
p = [1 for i in range(n+1)]
for i in range(n):
p[i+1] = p[i]*2
for i in range(1,n+1):
b += [(p[i]-1) << j for j in range(n+1-i)]
dp = [None for i in range(b[-1]+1)]
dp[0] = 0
print((dfs(0,b[-1])))
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
B()
| #!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
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,k = LI()
a = LI()
dp = [0 for i in range(k+1)]
f = [0 for i in range(k+1)]
for i in range(k+1):
if not f[i]:
for j in a:
if i-j >= 0:
dp[i] = 1-dp[i-j]
if dp[i] == 0:
break
else:
dp[i] = 1
print((["First","Second"][dp[k]]))
#B
def B():
def dfs(d,m):
if dp[m] != None:
return dp[m]
l = [0,0]
for i in range(n+1):
if p[i]&m:
l[0] = i
l[1] = i+n-1-d
break
if not d%2:
res = -float("inf")
for i in l:
res = max(res,a[i]+dfs(d+1,m^p[i]))
dp[m] = res
return dp[m]
else:
res = float("inf")
for i in l:
res = min(res,-a[i]+dfs(d+1,m^p[i]))
dp[m] = res
return dp[m]
n = I()
a = LI()
b = deque()
p = [1 for i in range(n+1)]
for i in range(n):
p[i+1] = p[i]*2
for i in range(1,n+1):
b += [(p[i]-1) << j for j in range(n+1-i)]
dp = [None for i in range(b[-1]+1)]
dp[0] = 0
print((dfs(0,b[-1])))
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
B()
| p03171 |
#!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
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,k = LI()
a = LI()
dp = [0 for i in range(k+1)]
f = [0 for i in range(k+1)]
for i in range(k+1):
if not f[i]:
for j in a:
if i-j >= 0:
dp[i] = 1-dp[i-j]
if dp[i] == 0:
break
else:
dp[i] = 1
print((["First","Second"][dp[k]]))
#B
def B():
def dfs(d,m,k):
if dp[m] != None:
return dp[m]
l = [k,k+n-1-d]
if not d%2:
res = -float("inf")
res = max(res,a[l[0]]+dfs(d+1,m^p[l[0]],k+1))
res = max(res,a[l[1]]+dfs(d+1,m^p[l[1]],k))
dp[m] = res
return dp[m]
else:
res = float("inf")
for i in l:
res = min(res,-a[l[0]]+dfs(d+1,m^p[l[0]],k+1))
res = min(res,-a[l[1]]+dfs(d+1,m^p[l[1]],k))
dp[m] = res
return dp[m]
n = I()
a = LI()
b = deque()
p = [1 for i in range(n+1)]
for i in range(n):
p[i+1] = p[i]*2
for i in range(1,n+1):
b += [(p[i]-1) << j for j in range(n+1-i)]
dp = [None for i in range(b[-1]+1)]
dp[0] = 0
print((dfs(0,b[-1],0)))
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
B()
| #!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
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,k = LI()
a = LI()
dp = [0 for i in range(k+1)]
f = [0 for i in range(k+1)]
for i in range(k+1):
if not f[i]:
for j in a:
if i-j >= 0:
dp[i] = 1-dp[i-j]
if dp[i] == 0:
break
else:
dp[i] = 1
print((["First","Second"][dp[k]]))
#B
def B():
def dfs(d,m,k):
if dp[m] != None:
return dp[m]
l = [k,k+n-1-d]
if not d%2:
res = -float("inf")
res = max(res,a[l[0]]+dfs(d+1,m^p[l[0]],k+1))
res = max(res,a[l[1]]+dfs(d+1,m^p[l[1]],k))
dp[m] = res
return dp[m]
else:
res = float("inf")
for i in l:
res = min(res,-a[l[0]]+dfs(d+1,m^p[l[0]],k+1))
res = min(res,-a[l[1]]+dfs(d+1,m^p[l[1]],k))
dp[m] = res
return dp[m]
n = I()
a = LI()
p = [1 for i in range(n+1)]
for i in range(n):
p[i+1] = p[i]*2
dp = [None for i in range(p[-1])]
dp[0] = 0
print((dfs(0,p[-1]-1,0)))
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
B()
| p03171 |
#!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
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,k = LI()
a = LI()
dp = [0 for i in range(k+1)]
f = [0 for i in range(k+1)]
for i in range(k+1):
if not f[i]:
for j in a:
if i-j >= 0:
dp[i] = 1-dp[i-j]
if dp[i] == 0:
break
else:
dp[i] = 1
print((["First","Second"][dp[k]]))
#B
def B():
n = I()
a = LI()
ma = n*(n+1)//2
s = [1 for i in range(n+1)]
for i in range(1,n):
s[i+1] = s[i]+n-i+1
d = [None for i in range(ma+1)]
d[0] = 0
k = 1
for i in range(1,n+1):
for j in range(n+1-i):
d[k+j] = i
k += n+1-i
k = n%2
dp = [0.0 for i in range(ma+1)]
dp[0] = 0
for i in range(n+1,ma+1):
if (d[i]+k)%2:
dp[i] = float("inf")
else:
dp[i] = -float("inf")
if k:
for i in range(n):
dp[i+1] = a[n-1-i]
else:
for i in range(n):
dp[i+1] = -a[n-1-i]
for i in range(1,ma):
r = n-1-(i-s[d[i]])
l = r+1-d[i]
j = i+(n-d[i])
j2 = j+1
if (d[i]+k)%2:
if r < n-1:
if a[r+1]+dp[i] > dp[j]:
dp[j] = a[r+1]+dp[i]
if l > 0:
if a[l-1]+dp[i] > dp[j2]:
dp[j2] = a[l-1]+dp[i]
else:
if r < n-1:
if -a[r+1]+dp[i] < dp[j]:
dp[j] = -a[r+1]+dp[i]
if l > 0:
if -a[l-1]+dp[i] < dp[j2]:
dp[j2] = -a[l-1]+dp[i]
print((dp[ma]))
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
B()
| #!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
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,k = LI()
a = LI()
dp = [0 for i in range(k+1)]
f = [0 for i in range(k+1)]
for i in range(k+1):
if not f[i]:
for j in a:
if i-j >= 0:
dp[i] = 1-dp[i-j]
if dp[i] == 0:
break
else:
dp[i] = 1
print((["First","Second"][dp[k]]))
#B
def B():
n = I()
a = LI()
ma = n*(n+1)//2
su = sum(a)
s = [1 for i in range(n+1)]
for i in range(1,n):
s[i+1] = s[i]+n-i+1
d = [None for i in range(ma+1)]
d[0] = 0
k = 1
for i in range(1,n+1):
for j in range(n+1-i):
d[k+j] = i
k += n+1-i
k = n%2
dp = [su if (d[i]+k)%2 else -su for i in range(ma+1)]
dp[0] = 0
if k:
for i in range(n):
dp[i+1] = a[n-1-i]
else:
for i in range(n):
dp[i+1] = -a[n-1-i]
for i in range(1,ma):
r = n-1-(i-s[d[i]])
l = r+1-d[i]
j = i+(n-d[i])
j2 = j+1
if (d[i]+k)%2:
if r < n-1:
if a[r+1]+dp[i] > dp[j]:
dp[j] = a[r+1]+dp[i]
if l > 0:
if a[l-1]+dp[i] > dp[j2]:
dp[j2] = a[l-1]+dp[i]
else:
if r < n-1:
if -a[r+1]+dp[i] < dp[j]:
dp[j] = -a[r+1]+dp[i]
if l > 0:
if -a[l-1]+dp[i] < dp[j2]:
dp[j2] = -a[l-1]+dp[i]
print((dp[ma]))
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
B()
| p03171 |
def fun(i,j):
# print(i,j)
if i>j or i>=n or j<0:
return 0
elif i==j:
dp[i][j]=arr[i]
return dp[i][j]
else:
if dp[i][j]==0:
dp[i][j]=max(arr[i]+min(fun(i+1,j-1),fun(i+2,j)),arr[j]+min(fun(i+1,j-1),fun(i,j-2)))
return dp[i][j]
n=int(eval(input()))
dp=[0]*n
for i in range(n):
dp[i]=[0]*n
arr=list(map(int,input().split()))
print((2*fun(0,n-1)-sum(arr))) | def fun(i,j):
# print(i,j)
if i>j or i>=n or j<0:
return 0
elif i==j:
dp[i][j]=arr[i]
return dp[i][j]
else:
if dp[i][j]==0:
dp[i][j]=max(arr[i]+min(fun(i+1,j-1),fun(i+2,j)),arr[j]+min(fun(i+1,j-1),fun(i,j-2)))
return dp[i][j]
n=int(eval(input()))
dp=[0]*n
for i in range(n):
dp[i]=[0]*n
arr=list(map(int,input().split()))
for i in range(n-1,-1,-1):
for j in range(i,n,1):
if i==j:
dp[i][j]=arr[i]
else:
dp[i][j]=max(arr[i]-dp[i+1][j],arr[j]-dp[i][j-1])
# print(dp[i])
print((dp[0][n-1]))
# print(2*fun(0,n-1)-sum(arr)) | p03171 |
# -*- 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 = float('inf')
MOD = 10 ** 9 + 7
N = INT()
aN = LIST()
# メモ[左端位置][右端位置] = この局面からの結果
memo = [[None] * (N+1) for i in range(N+1)]
def dfs(l, r):
# 全部取り切ったので終了
if l > r:
return 0
# 既に見た局面ならメモの内容を返す
if memo[l][r] is not None:
return memo[l][r]
turn = 0 if N % 2 != (r-l) % 2 else 1
# 先手番
if turn == 0:
mx = -INF
mx = max(mx, dfs(l+1, r) + aN[l])
mx = max(mx, dfs(l, r-1) + aN[r])
# ここより深い所を探し終わったので結果をメモする
memo[l][r] = mx
return mx
# 後手番
else:
mn = INF
mn = min(mn, dfs(l+1, r) - aN[l])
mn = min(mn, dfs(l, r-1) - aN[r])
memo[l][r] = mn
return mn
print((dfs(0, N-1)))
| # -*- 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()
# dp[i][j] := 左からi個、右からj個取った状態での最大(最小)得点
dp = list2d(N+1, N+1, 0)
# 初期化：どちらの手番で使う場所かに合わせて-INFかINFにする
for i in range(N):
turn = i & 1
for j in range(i+1):
k = i - j
if turn == 0:
dp[j][k] = -INF
else:
dp[j][k] = INF
# 最初の遷移の開始地点(ゲーム終了の状態)は0に
for i in range(N+1):
dp[i][N-i] = 0
# 終了から順番に戻って見ていく
for i in range(N-1, -1, -1):
turn = i & 1
for j in range(i+1):
k = i - j
l = j
r = N - 1 - k
if turn == 0:
# 先手番の遷移
dp[j][k] = max(dp[j][k], dp[j+1][k] + A[l])
dp[j][k] = max(dp[j][k], dp[j][k+1] + A[r])
else:
# 後手番の遷移
dp[j][k] = min(dp[j][k], dp[j+1][k] - A[l])
dp[j][k] = min(dp[j][k], dp[j][k+1] - A[r])
ans = dp[0][0]
print(ans)
| p03171 |
def deque(a):
n = len(a)
cur = [(x, 0) for x in a]
nxt = [(0, 0)] * n
for l in range(2, n + 1):
for i in range(n - l + 1):
j = i + l - 1
x, y = cur[i]
z, t = cur[i + 1]
if a[i] + t - z > a[j] + y - x:
nxt[i] = (a[i] + t, z)
else:
nxt[i] = (a[j] + y, x)
cur, nxt = nxt, cur
return cur[0][0] - cur[0][1]
def main():
eval(input()) # n
a = [int(x) for x in input().split()]
return deque(a)
print((main()))
| def deque(a):
n = len(a)
cur = a[:]
nxt = [0] * (n - 1)
for l in range(2, n + 1):
for i in range(n - l + 1):
j = i + l - 1
nxt[i] = max(a[i] - cur[i + 1], a[j] - cur[i])
cur, nxt = nxt, cur
return cur[0]
def main():
eval(input()) # n
a = [int(x) for x in input().split()]
return deque(a)
print((main()))
| p03171 |
import sys
sys.setrecursionlimit(1000000)
N=eval(input())
A=list(map(int, sys.stdin.readline().split()))
dp=[ [ 0 for i in range(N) ] for j in range(N) ]
def func(x,y,cnt):
if dp[x][y]>0: return dp[x][y]
ret=0
if x==y:
if cnt%2==0:
ret=A[x]
dp[x][y]=ret
return ret
else:
ret=-1*A[x]
dp[x][y]=ret
return ret
if cnt%2==0:
cnt+=1
ret=max( func(x,y-1,cnt)+A[y] , func(x+1,y,cnt)+A[x] )
else:
cnt+=1
ret=min( func(x,y-1,cnt)-A[y] ,func(x+1,y ,cnt)-A[x] )
dp[x][y]=ret
return ret
func(0,N-1,0)
print(dp[0][N-1])
| # -*- coding: utf-8 -*-
import sys
N=eval(input())
A=list(map(int, sys.stdin.readline().split()))
dp=[ [ None for i in range(N) ] for j in range(N) ]
for i in range(N-1,-1,-1):
if N%2==0:
dp[i][i]=A[i]*-1
else:
dp[i][i]=A[i]
for i in range(N-2,-1,-1):
for j in range(i+1,N):
t=N-(j-i+1) #残りの要素数
if t%2==0:
if dp[i][j] is None : dp[i][j]=float("-inf")
dp[i][j]=max(dp[i][j] , dp[i][j-1]+A[j])
dp[i][j]=max(dp[i][j] , dp[i+1][j]+A[i])
else:
if dp[i][j] is None : dp[i][j]=float("inf")
dp[i][j]=min(dp[i][j] , dp[i][j-1]-A[j])
dp[i][j]=min(dp[i][j] , dp[i+1][j]-A[i])
print(dp[0][N-1])
| p03171 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
n = I()
a = LI()
t = [[0]*n for _ in range(n)]
for i in range(n):
t[i][i] = a[i]
for s in range(1,n):
for i in range(n-s):
j = i + s
r = a[j] - t[i][j-1]
u = a[i] - t[i+1][j]
if r < u:
r = u
t[i][j] = r
return t[0][-1]
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
n = I()
a = LI()
t = [[0]*n for _ in range(n)]
for i in range(n):
t[i][i] = a[i]
for i in range(n-2,-1,-1):
z = t[i]
y = t[i+1]
for j in range(i+1,n):
r = a[j] - z[j-1]
u = a[i] - y[j]
if r < u:
r = u
z[j] = r
return t[0][-1]
print(main())
| p03171 |
import sys
sys.setrecursionlimit(10**7)
n = int(eval(input()))
a = list(map(int, input().split()))
dp = [[None] * len(a) for _ in a]
def solve(i, j):
if dp[i][j]:
return dp[i][j]
if i == j:
dp[i][j] = a[i]
return dp[i][j]
dp[i][j] = max(a[j] - solve(i, j-1), a[i] - solve(i+1, j))
return dp[i][j]
print((solve(0, len(a) - 1)))
| n = int(eval(input()))
a = list(map(int, input().split()))
dp = [[None] * len(a) for _ in a]
for i in range(len(a)-1, -1, -1):
for j in range(i, len(a)):
if i == j:
dp[i][j] = a[i]
continue
dp[i][j] = max(a[j] - dp[i][j-1], a[i] - dp[i+1][j])
print((dp[0][len(a) - 1])) | p03171 |
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 9)
def main():
N = int(eval(input()))
a = list(map(int,input().split()))
memo = [[-1 for _ in range(N)] for _ in range(N)]
for i in range(N):
memo[i][i] = a[i]
def point(x,y):
if memo[x][y] != -1:
return memo[x][y]
else:
ret = max(a[x]-point(x+1,y),a[y]-point(x,y-1))
memo[x][y] = ret
return ret
point(0,N-1)
print((memo[0][N-1]))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline
def main():
N = int(eval(input()))
a = list(map(int,input().split()))
dp = [[-1 for _ in range(N)] for _ in range(N)]
for i in range(N):
dp[i][i] = a[i]
for i in range(N-1,-1,-1):
for j in range(i,N):
if dp[i][j] != -1:
continue
dp[i][j] = max(a[i]-dp[i+1][j],a[j]-dp[i][j-1])
print((dp[0][-1]))
if __name__ == "__main__":
main()
| p03171 |
import sys
sys.setrecursionlimit(10**8)
n,*a=list(map(int,open(0).read().split()))
dp=[[0]*(n+1) for _ in range(n+1)]
def dfs(l,r):
if l+r==n:return 0
if dp[l][r]:return dp[l][r]
dp[l][r]=max(a[l]-dfs(l+1,r),a[n-1-r]-dfs(l,r+1))
return dp[l][r]
print((dfs(0,0))) | n,*a=list(map(int,open(0).read().split()))
dp=[[0]*(n+1) for _ in range(n+1)]
for l in range(n)[::-1]:
for r in range(n)[::-1]:
if l+r<=n-1:
dp[l][r]=max(a[l]-dp[l+1][r],a[n-1-r]-dp[l][r+1])
print((dp[0][0])) | p03171 |
import sys
sys.setrecursionlimit(10**8)
def calc(N,i,j):
if dp[i][j]<float('inf'):
return dp[i][j]
if (N-(j-i+1))%2==0:
if i==j:
dp[i][j] = A[i]
else:
dp[i][j] = max(calc(N,i,j-1)+A[j],calc(N,i+1,j)+A[i])
else:
if i==j:
dp[i][j] = -A[i]
else:
dp[i][j] = min(calc(N,i,j-1)-A[j],calc(N,i+1,j)-A[i])
return dp[i][j]
N = int(eval(input()))
A = list(map(int, input().split()))
dp = [[float('inf')]*N for _ in range(N)]
ans = calc(N,0,N-1)
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
dp = [[float('inf')]*N for _ in range(N)]
for i in range(N):
if (N-1)%2==0:
dp[i][i] = A[i]
else:
dp[i][i] = -A[i]
for k in range(1,N):
for i in range(N):
j = i+k
if j>N-1:
break
if (N-(k+1))%2==0:
dp[i][j] = max(dp[i][j-1]+A[j],dp[i+1][j]+A[i])
else:
dp[i][j] = min(dp[i][j-1]-A[j],dp[i+1][j]-A[i])
ans = dp[0][N-1]
print(ans) | p03171 |
import sys
input = sys.stdin.readline
N=int(eval(input()))
A=list(map(int,input().split()))
SCORE=[[None for i in range(N+1)] for j in range(N+1)]
def score(i,j,k,l):#A[i:j)が残っているときのscore,1:Xの手番,-1:Yの手番
#print(i,j,k,l)
if SCORE[i][j]!=None:
return SCORE[i][j]+k
if i==j:
SCORE[i][j]=0
return k
if l==1:
SCORE[i][j]=max(score(i+1,j,k+A[i],-l),score(i,j-1,k+A[j-1],-l))-k
return SCORE[i][j]+k
if l==-1:
SCORE[i][j]=min(score(i+1,j,k-A[i],-l),score(i,j-1,k-A[j-1],-l))-k
return SCORE[i][j]+k
hand=N%2
for i in range(N+1):
for j in range(N-i+1):
score(j,j+i,0,(-1)**(j+j+i+hand))
print((SCORE[0][N])) | import sys
input = sys.stdin.readline
N=int(eval(input()))
A=list(map(int,input().split()))
SCORE=[[None for i in range(N+1)] for j in range(N+1)]
def score(i,j,k,l):#A[i:j)が残っているときのscore,1:Xの手番,-1:Yの手番
if i==j:
SCORE[i][j]=0
return
if SCORE[i][j]!=None:
return SCORE[i][j]+k
if l==1:
SCORE[i][j]=max(SCORE[i+1][j]+A[i],SCORE[i][j-1]+A[j-1])-k
else:
SCORE[i][j]=min(SCORE[i+1][j]-A[i],SCORE[i][j-1]-A[j-1])-k
hand=N%2
for i in range(N+1):
for j in range(N-i+1):
score(j,j+i,0,(-1)**(j+j+i+hand))
print((SCORE[0][N])) | p03171 |
import sys
sys.setrecursionlimit(10**7)
n=int(eval(input()))
a=list(map(int,input().split()))
d={}
def k(a):
return ','.join(map(str,a))
def dp(a):
ka=k(a)
if ka in d:
return [d[ka][0],d[ka][1]]
if len(a)==1:
d[ka]=[a[0],[]]
return a[0],[]
elif len(a)==2:
d[ka]=[max(a),[min(a)]]
return max(a),[min(a)]
else:
if a[0]-dp(a[1:])[0]>a[-1]-dp(a[:-1])[0]:
d[ka]=[a[0],a[1:]]
return a[0],a[1:]
else:
d[ka]=[a[-1],a[:-1]]
return a[-1],a[:-1]
x,y=0,0
while a!=[]:
x_,a=dp(a)
x+=x_
if a==[]:
break
y_,a=dp(a)
y+=y_
print((x-y))
| n=int(eval(input()))
a=list(map(int,input().split()))
dp=[[0]*n for _ in range(n)]
# dp[i][j]:i<=j,i番目からj番目までの数列(j-i+1個)を前にした時、ゲーム終了までに自分が取れる最大得点。i,j=0,..,n-1
sa=[0]
s=0
for ai in a:
s+=ai
sa.append(s)
for len in range(1,n+1):
for l in range(n-len+1):
r=l+len-1
s=sa[r+1]-sa[l]
dp[l][r]=max(s-dp[l][r-1],s-dp[l+1][r] if l+1<n else 0)
print((2*dp[0][-1]-sa[-1]))
| p03171 |
from sys import stdin, setrecursionlimit
input = stdin.readline
setrecursionlimit(200000)
N = int(eval(input()))
a = list(map(int, input().split()))
INF = -(10**13)
dp = [[INF] * (N + 1) for _ in range(N + 1)]
def play(start: 'int',
end: 'int') -> 'int': # return the maximum X for range[start,end)
# if start + 1 == end:
# return start
if dp[start][end] != INF:
return dp[start][end]
length = end - start
if (N - length) & 1 == 0: # taro plays
if length == 1:
dp[start][end] = a[start]
return a[start]
else:
dp[start][end] = max(a[start] + play(start + 1, end),
a[end - 1] + play(start, end - 1))
return dp[start][end]
else: # jiro plays
if length == 1:
dp[start][end] = 0
return 0
else:
dp[start][end] = min(play(start + 1, end), play(start, end - 1))
return dp[start][end]
print((2 * play(0, N) - sum(a)))
| from sys import stdin
input = stdin.readline
N = int(eval(input()))
a = list(map(int, input().split()))
dp = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(N):
dp[i][i + 1] = a[i] if N & 1 == 1 else -a[i]
for j in range(2, N + 1):
for i in range(0, N + 1 - j):
# j is the length of the interval + 1
if (N - j) & 1 == 0:
dp[i][i + j] = max(a[i] + dp[i + 1][i + j],
a[i + j - 1] + dp[i][i + j - 1])
else:
dp[i][i + j] = min(dp[i + 1][i + j] - a[i],
dp[i][i + j - 1] - a[i + j - 1])
print((dp[0][N]))
| p03171 |
import sys
def solve():
a = read()
result = think(a)
write(result)
def read():
n = read_int(1)[0]
return read_int(n)
def read_int(n):
return list([int(x) for x in read_line().split(' ')])[:n]
def read_float(n):
return list([float(x) for x in read_line().split(' ')])[:n]
def read_line(n=0):
if n == 0:
return input().rstrip()
else:
return input().rstrip()[:n]
def think(a):
n = len(a)
dp = [[None for x in range(n)] for y in range(n)]
recursive_call(dp, a, len(a), 0, n - 1)
return dp[0][n - 1]
def recursive_call(dp, a, n, l, r):
if dp[l][r] is not None:
return dp[l][r]
if l == r:
dp[l][r] = a[l]
return dp[l][r]
dp[l][r] = max(a[l] - recursive_call(dp, a, n, l + 1, r), a[r] - recursive_call(dp, a, n, l, r - 1))
return dp[l][r]
def write(result):
print(result)
if __name__ == '__main__':
sys.setrecursionlimit(10000)
solve() | def solve():
a = read()
result = think(a)
write(result)
def read():
n = read_int(1)[0]
return read_int(n)
def read_int(n):
return list(map(int, read_line().split(' ')))[:n]
def read_float(n):
return list(map(float, read_line().split(' ')))[:n]
def read_line(n=0):
if n == 0:
return input().rstrip()
else:
return input().rstrip()[:n]
def think(a):
n = len(a)
dp = [[None for x in range(n)] for y in range(n)]
for i in range(len(dp)):
dp[i][i] = a[i]
for l in range(n - 2, -1, -1):
for r in range(l + 1, n):
dp[l][r] = max(a[l] - dp[l + 1][r], a[r] - dp[l][r - 1])
return dp[0][n - 1]
def write(result):
print(result)
if __name__ == '__main__':
solve() | p03171 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from itertools import accumulate
n = int(eval(input()))
A = list(map(int, input().split()))
L = [0] + list(accumulate(A))
dp = [[-1]*(n+1) for i in range(n+1)]
def dfs(i, j):
if dp[i][j] != -1:
return dp[i][j]
if i == j:
dp[i][j] = 0
return 0
res = max(A[i] + L[j] - L[i+1] - dfs(i+1, j), A[j-1] + L[j-1] - L[i] - dfs(i, j-1))
dp[i][j] = res
return res
dfs(0, n)
ans = 2*dp[0][n] - L[n]
print(ans) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from itertools import accumulate
n = int(eval(input()))
A = list(map(int, input().split()))
L = [0] + list(accumulate(A))
dp = [[0]*(n+1) for i in range(n+1)]
for d in range(1, n+1):
for i in range(n+1-d):
dp[i][i+d] = max(A[i] + L[i+d] - L[i+1] - dp[i+1][i+d], A[i+d-1] + L[i+d-1] - L[i] - dp[i][i+d-1])
ans = 2*dp[0][n] - L[n]
print(ans) | p03171 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**9)
#import
#import math
#import numpy as np
N = int(eval(input()))
A = list(map(int, input().split()))
dp = [[-1] * (N + 1) for _ in range(N + 1)]
# 半開区間A[r,l)における最大スコア
def calc(r, l):
if dp[r][l] != -1:
return dp[r][l]
if l - r == 1:
dp[r][l] = A[r]
return dp[r][l]
elif l - r == 2:
dp[r][l] = max(A[r], A[r + 1]) - min(A[r], A[r + 1])
return dp[r][l]
res = max(A[r] - calc(r + 1, l), A[l - 1] - calc(r, l - 1))
dp[r][l] = res
return res
ans = calc(0, N)
print(ans) | #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**9)
#import
#import math
#import numpy as np
N = int(eval(input()))
A = list(map(int, input().split()))
dp = [[0] * (N + 1) for _ in range(N + 1)]
for w in range(1, N + 1):
for l in range(N - w + 1):
r = w + l
dp[l][r] = A[l] - dp[l + 1][r]
if r > 0:
dp[l][r] = max(dp[l][r], A[r - 1] - dp[l][r - 1])
print((dp[0][N]))
| p03171 |
N = int(eval(input()))
a = list(map(int, input().split()))
# dp[x][y][Person]:= 左端がx 番目,右端がy 番目の時の,この時動かすのがPersonの時の X - Y の値(0<=x<=Y<N)
dp = [[[0, 0] for j in range(N)] for i in range(N)]
for i in range(N):
dp[i][i][0] = a[i]
dp[i][i][1] = -a[i]
for i in range(1, N+1):
# y-x = i thus y = x+i 0<=x<N and 0<=x+i<N thus 0<=x <N-i
for x in range(N-i):
dp[x][x+i][0] = max(a[x]+dp[x+1][x+i][1], a[x+i]+dp[x][x+i-1][1])
dp[x][x+i][1] = min(dp[x+1][x+i][0]-a[x], dp[x][x+i-1][0]-a[x+i])
ans = dp[0][N-1][0]
print(ans) | N = int(eval(input()))
a = list(map(int, input().split()))
dp = [[0]*(2*N) for i in range(N)]
for i in range(N):
dp[i][i] = a[i]
dp[i][i+N] = -a[i]
for i in range(1, N+1):
for x in range(N-i):
dp[x][x+i] = max(a[x]+dp[x+1][x+i+N], a[x+i]+dp[x][x+i-1+N])
dp[x][x+i+N] = min(dp[x+1][x+i]-a[x], dp[x][x+i-1]-a[x+i])
ans = dp[0][N-1]
print(ans) | p03171 |
import sys
sys.setrecursionlimit(5000)
def max(a,b):
if a >= b:
return a
return b
def min(a,b):
if a <= b:
return a
return b
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
dp = [[-1]*(n+1) for i in range(n)]
def rec(i=0, j=n):
if i == j:
return 0
if dp[i][j] != -1:
return dp[i][j]
# 太郎
if (n - (j-i))%2==0:
dp[i][j] = max(a[i] + rec(i+1,j), a[j-1] +rec(i,j-1))
else:
dp[i][j] = min(-a[i] + rec(i+1,j), -a[j-1] +rec(i,j-1))
return dp[i][j]
print((rec()))
main() | n = int(eval(input()))
a = list(map(int, input().split()))
dp = [[0]*(n+1) for i in range(n+1)]
for l in range(1,n+1):
for i in range(n+1-l):
j = i+l
if (n-l)%2 == 0:
dp[i][j] = max(dp[i+1][j]+a[i], dp[i][j-1]+a[j-1])
else:
dp[i][j] = min(dp[i+1][j]-a[i], dp[i][j-1]-a[j-1])
print((dp[0][-1])) | p03171 |
#EDPC L
import sys
sys.setrecursionlimit(10**5)
def main():
N=int(eval(input()))
a=list(map(int,input().split()))
#dp[l][r]:=区間[l,r]が残っている時の(直後の人の最終的な得点-そうじゃない方の最終的な得点）
dp=[[-1]*N for _ in range(N)]
def rec(l,r):
if dp[l][r]!=-1:
return dp[l][r]
if l==r:
dp[l][r]=a[l]
return dp[l][r]
dp[l][r]=max(a[l]-rec(l+1,r),a[r]-rec(l,r-1))
return dp[l][r]
print((rec(0,N-1)))
main() | #EDPC L メモ化再帰じゃTLEで通らないのでやり直し
N=int(eval(input()))
a=list(map(int,input().split()))
#dp[l][r]:=区間[l,r]が残っている時の(直後の人の最終的な得点-そうじゃない方の最終的な得点）
dp=[[-1]*N for _ in range(N)]
for k in range(N):
dp[k][k]=a[k]
for r in range(1,N):
for l in reversed(list(range(r))):
dp[l][r]=max(a[l]-dp[l+1][r],a[r]-dp[l][r-1])
print((dp[0][N-1])) | p03171 |
n = int(eval(input()))
arr = list(map(int, input().split()))
dp = [[0] * (n+1) for _ in range(n+1)]
for length in range(1, n + 1):
for i in range(n - length + 1):
j = i + length
if ((n - length) % 2 == 0):
dp[i][j] = max(dp[i+1][j] + arr[i], dp[i][j-1] + arr[j-1])
else:
dp[i][j] = min(dp[i+1][j] - arr[i], dp[i][j-1] - arr[j-1])
print((dp[0][n]))
| def kukan(n, a):
dp = [[0] * n for _ in range(n)]
for i in range(n):
dp[i][i] = a[i]
for i in range(n - 2, -1, -1):
g0 = dp[i]
g1 = dp[i + 1]
for j in range(i + 1, n):
L = a[i] - g1[j]
R = a[j] - g0[j - 1]
dp[i][j] = L if L > R else R
return dp[0][n - 1]
n = int(eval(input()))
a = list(map(int, input().split()))
print((kukan(n, a))) | p03171 |
import sys
sys.setrecursionlimit(10 ** 6)
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
c = [[None] * N for _ in range(N)]
for r in reversed(list(range(N))):
c[r][r] = A[r]
for l in range(r + 1, N):
c[r][l] = max(-c[r + 1][l] + A[r], -c[r][l - 1] + A[l])
print((c[0][N - 1]))
main()
| def main():
N = int(eval(input()))
A = list(map(int, input().split()))
c = [0] * N
for r in reversed(list(range(N))):
ar = A[r]
c[r] = t = ar
for l in range(r + 1, N):
c[l] = t = max(ar - c[l], A[l] - t)
print((c[-1]))
main()
| p03171 |
N = int(eval(input()))
a = [int(c) for c in input().split()]
dp = [[-1] * N for _ in range(N)]
for i in range(N):
for L in range(N):
for R in range(L, N):
if L == R:
dp[L][R] = a[L]
else:
dp[L][R] = max(a[L] - dp[L+1][R], a[R] - dp[L][R-1])
print((dp[0][N-1]))
| N = int(eval(input()))
a = [int(c) for c in input().split()]
dp = [[-1] * N for _ in range(N)]
for L in range(N, -1, -1):
for R in range(L, N):
if L == R:
dp[L][R] = a[L]
else:
dp[L][R] = max(a[L] - dp[L+1][R], a[R] - dp[L][R-1])
print((dp[0][N-1]))
| p03171 |
import sys
input = sys.stdin.readline
def func():
N = int(eval(input()))
A = [int(i) for i in input().split()]
dp = [[0] * (N+1) for i in range(N+1)]
if (N - 1) % 2 == 0:
fl = 1
else:
fl = -1
for i in range(N):
dp[i][i+1] = fl * A[i]
for s in range(2, N+1):
for l in range(N-s+1):
r = l + s
if (N - s) % 2 == 0:
dp[l][r] = max(dp[l+1][r]+A[l], dp[l][r-1]+A[r-1])
continue
dp[l][r] = min(dp[l+1][r]-A[l], dp[l][r-1]-A[r-1])
return dp[0][N]
print((func())) | import sys
input = sys.stdin.readline
def func():
N = int(eval(input()))
A = [int(i) for i in input().split()]
dp = [[0] * (N+1) for i in range(N+1)]
for i in range(N):
dp[i][i+1] = A[i]
for s in range(2, N+1):
for l in range(N-s+1):
r = l + s
dp[l][r] = max(A[l]-dp[l+1][r], A[r-1]-dp[l][r-1])
return dp[0][N]
print((func())) | p03171 |
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(1000000000)
N = int(eval(input()))
a = list(map(int, input().split()))
dp_memo = [[float("inf")]*(N+1) for _ in range(N+1)]
for i in range(N+1):
dp_memo[i][i] = 0
def dp(i,j):
if dp_memo[i][j] < float("inf"):
return dp_memo[i][j]
elif (j-i)%2 == N%2: # 先手番
tmp = max(a[i] + dp(i+1, j), a[j-1] + dp(i,j-1))
dp_memo[i][j] = tmp
return tmp
else: # 後手番
tmp = min(-a[i] + dp(i+1, j), -a[j-1] + dp(i,j-1))
dp_memo[i][j] = tmp
return tmp
print((dp(0, N))) | import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(1000000000)
N = int(eval(input()))
a = list(map(int, input().split()))
dp = [[float("inf")]*(N+1) for _ in range(N+1)]
for shift_i in range(N+1):
for i in range(N+1):
if i+shift_i >= N+1:
continue
if shift_i == 0:
dp[i][i] = 0
elif ((i+shift_i)-i)%2 == N%2: # 先手番
dp[i][(i+shift_i)] = max(a[i] + dp[i+1][(i+shift_i)], a[(i+shift_i)-1] + dp[i][(i+shift_i)-1])
else:
dp[i][(i+shift_i)] = min(-a[i] + dp[i+1][(i+shift_i)], -a[(i+shift_i)-1] + dp[i][(i+shift_i)-1])
print((dp[0][N])) | p03171 |
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(1000000000)
N = int(eval(input()))
a = list(map(int, input().split()))
dp = [[float("inf")]*(N+1) for _ in range(N+1)]
for shift_i in range(N+1):
for i in range(N+1):
if i+shift_i >= N+1:
continue
if shift_i == 0:
dp[i][i] = 0
elif ((i+shift_i)-i)%2 == N%2: # 先手番
dp[i][(i+shift_i)] = max(a[i] + dp[i+1][(i+shift_i)], a[(i+shift_i)-1] + dp[i][(i+shift_i)-1])
else:
dp[i][(i+shift_i)] = min(-a[i] + dp[i+1][(i+shift_i)], -a[(i+shift_i)-1] + dp[i][(i+shift_i)-1])
print((dp[0][N])) | import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
a = list(map(int, input().split()))
# dp[i][j] 区間a[i,j)だけ残った時点で互いの点数を一旦0とし、ゲームを最後まで続けた場合のX-Yの値
dp = [[0]*(N+1) for _ in range(N+1)]
# こちらもメモ化再帰ではpypy3でも間に合わない
# j==i+1, i+2, ...とループしてdpテーブルの上三角部分を対角線と平行に埋めていく。jをshift_iと書き換えてループ
for shift_i in range(1, N+1):
for i in range(N+1):
if i+shift_i >= N+1:
continue
elif ((i+shift_i)-i)%2 == N%2: # 先手番
dp[i][(i+shift_i)] = max(a[i] + dp[i+1][(i+shift_i)], a[(i+shift_i)-1] + dp[i][(i+shift_i)-1])
else:
dp[i][(i+shift_i)] = min(-a[i] + dp[i+1][(i+shift_i)], -a[(i+shift_i)-1] + dp[i][(i+shift_i)-1])
print((dp[0][N])) | p03171 |
import sys
readline = sys.stdin.readline
N = int(readline())
A = list(map(int,readline().split()))
dp = [[0] * (N + 1) for i in range(N + 1)]
# [i,j)
for l in range(1, N + 1):
for i in range(N - l + 1):
j = i + l
if (N - l) % 2 == 0: # 先手
dp[i][j] = max(dp[i + 1][j] + A[i], dp[i][j - 1] + A[j - 1])
else:
dp[i][j] = min(dp[i + 1][j] - A[i], dp[i][j - 1] - A[j - 1])
print((dp[0][N])) | import sys
readline = sys.stdin.readline
N = int(readline())
A = list(map(int,readline().split()))
# dp[l][r] = [l:r)の区間から起こり得るX - Yの最大値
# [N - 区間の長さ] = 偶数のとき、次に取るのは先手
dp = [[0] * (N + 1) for i in range(N + 1)]
for k in range(1, N + 1): # 区間の長さ
for i in range(N + 1 - k):
if (N - k) % 2 == 0: # 先手番
dp[i][i + k] = max(dp[i + 1][i + k] + A[i], dp[i][i + k - 1] + A[i + k - 1])
else: # 後手番
dp[i][i + k] = min(dp[i + 1][i + k] - A[i], dp[i][i + k - 1] - A[i + k - 1])
print((dp[0][N])) | p03171 |
import sys
read = sys.stdin.read
sys.setrecursionlimit(10 ** 7)
def solve():
N, *a = list(map(int, read().split()))
a = tuple(a)
INF = float('inf')
memo = [[INF] * N for _ in range(N)]
def f(i, j):
if memo[i][j] != INF:
return memo[i][j]
n = j - i + 1
n %= 2
if i == j:
if n == r:
s = a[i]
else:
s = -a[i]
memo[i][j] = s
return s
if n == r:
s = max(f(i, j - 1) + a[j], f(i + 1, j) + a[i])
else:
s = min(f(i, j - 1) - a[j], f(i + 1, j) - a[i])
memo[i][j] = s
return s
r = N % 2
f(0, N - 1)
return memo[0][N - 1]
print((solve()))
| import sys
read = sys.stdin.read
sys.setrecursionlimit(10 ** 7)
def solve():
n, *a = list(map(int, read().split()))
a = tuple(a)
dp = [[0] * n for _ in range(n)]
for i in range(n):
dp[i][i] = a[i]
for i in range(n - 2, -1, -1):
for j in range(i + 1, n):
L = a[i] - dp[i + 1][j]
R = a[j] - dp[i][j - 1]
if L > R:
dp[i][j] = L
else:
dp[i][j] = R
return dp[0][n - 1]
print((solve()))
| p03171 |
import sys
sys.setrecursionlimit(10000)
n = int(eval(input()))
*A, = list(map(int, input().split()))
DP = [[None for j in range(n+1)] for i in range(n)]
def dp(i, j):
if i == j:
return 0
if DP[i][j] != None:
return DP[i][j]
DP[i][j] = max(A[i]-dp(i+1, j), A[j-1]-dp(i, j-1))
return DP[i][j]
print((dp(0, n)))
| n = int(eval(input()))
*A, = list(map(int, input().split()))
DP = [[0 for j in range(n+1)] for i in range(n+1)]
for l in range(1, n+1):
for i in range(n-l+1):
j = i+l
DP[i][j] = max(A[i]-DP[i+1][j], A[j-1]-DP[i][j-1])
print((DP[0][n]))
| p03171 |
import math
from fractions import Fraction
mod = 998244353
n = int(eval(input()))
p = [list(map(int, input().split())) for i in range(n)]
pow2 = [2**i % mod for i in range(n + 1)]
used = [[False] * n for i in range(n)]
ret = (pow2[n] - 1 - n - n * (n - 1) / 2) % mod
for i in range(n):
for j in range(i):
if used[i][j]:
continue
inline = [i, j]
for k in range(n):
if k == i or k == j:
continue
if (p[i][1] - p[k][1]) * (p[j][0] - p[k][0]) == (p[j][1] - p[k][1]) * (p[i][0] - p[k][0]):
inline.append(k)
for k in range(len(inline)):
for l in range(len(inline)):
used[inline[k]][inline[l]] = True
v = len(inline)
ret = (ret + mod - pow2[v] + 1 + v + v * (v - 1) // 2) % mod
print((int(ret)))
| import math
mod = 998244353
n = int(eval(input()))
p = [list(map(int, input().split())) for i in range(n)]
pow2 = [1]
for i in range(n):
pow2.append(pow2[-1] * 2 % mod)
used = [[False] * n for i in range(n)]
ret = (pow2[n] - 1 - n - n * (n - 1) / 2) % mod
for i in range(n):
for j in range(i):
if used[i][j]:
continue
inline = [i, j]
for k in range(n):
if k == i or k == j:
continue
if (p[i][1] - p[k][1]) * (p[j][0] - p[k][0]) == (p[j][1] - p[k][1]) * (p[i][0] - p[k][0]):
inline.append(k)
for k in range(len(inline)):
for l in range(len(inline)):
used[inline[k]][inline[l]] = True
v = len(inline)
ret = (ret + mod - pow2[v] + 1 + v + v * (v - 1) // 2) % mod
print((int(ret)))
| p03615 |
A, B = list(map(int, input().split()))
c = 0
tmp = 1
while tmp < B:
c += 1
tmp = (A - 1) * (c - 1) + A
print(c)
| def main():
A, B = list(map(int, input().split()))
if B == 1:
print((0))
exit()
cnt = A
tap = 1
while True:
if cnt >= B:
print(tap)
exit()
cnt += (A - 1)
tap += 1
if __name__ == "__main__":
main() | p02922 |
n,m = list(map(int,input().split()))
# n = int(input())
# s = input()
# t = input()
ans = 0
while m > 1:
m -= n - 1
ans += 1
print(ans) | a, b = list(map(int, input().split()))
print(((b - 1) // (a - 1) + min(1, (b - 1) % (a - 1)))) | p02922 |
import sys
from pprint import pprint
def solve(a, b):
ans = 0
emp = 1
while emp < b:
emp += a - 1
ans += 1
print(ans)
if __name__ == '__main__':
a, b = list(map(int, sys.stdin.readline().strip().split(" ")))
solve(a, b)
| import sys
A, B = list(map(int, sys.stdin.readline().split()))
print(((B - A - 1) // (A-1) + 2)) | p02922 |
A, B = list(map(int, input().split()))
k = 1
while k < B:
k += A - 1
if A == 2 :
print((k-1))
else:
print((k//(A - 1))) | A, B = list(map(int, input().split()))
k = 1
s = 0
while k < B:
k += A - 1
s += 1
print(s) | p02922 |
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 1 20:21:49 2019
@author: Yamazaki Kenichi
"""
A, B = list(map(int,input().split()))
ans = (B-A-1)//(A-1) + 1 + 1
print(ans)
| A, B = list(map(int,input().split()))
ans = (B-1-1)//(A-1)+1
print(ans) | p02922 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
A,B = MI()
print(((B+A-3)//(A-1)))
| import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
A,B = MI()
print(((B+A-3)//(A-1)))
| p02922 |
import math
A, B = list(map(int, input().split()))
if B == 1:
print((0))
elif A >= B:
print((1))
else:
print((math.ceil((B - 1) / (A - 1))))
| import math
A, B = list(map(int, input().split()))
if B == 1:
print((0))
elif A >= B:
print((1))
else:
print((math.ceil((B - A) / (A - 1)) + 1))
| p02922 |
a, b = list(map(int,input().split()))
for i in range(b):
if 1 + (a-1)*i >= b:
print(i)
break | a, b = list(map(int,input().split()))
i = 0
while True:
if 1 + (a-1)*i >= b:
print(i)
break
i += 1 | p02922 |
a,b=list(map(int,input().split()))
import math
socket=0;ans=0
if b==1:
ans=0
else:
while (True):
if socket+a >= b:
ans+=1
break
socket+=a-1
ans+=1
print(ans) | a,b=list(map(int,input().split()))
import math
socket=1;ans=0
while (True):
if socket >= b:
break
socket-=1
socket+=a
ans+=1
print(ans) | p02922 |
a,b = list(map(int,input().split()))
ans = 0
c = 1
while c < b:
ans += 1
c = c-1+a
print(ans)
| a,b=list(map(int,input().split()))
print(((b-1+a-1-1)//(a-1))) | p02922 |
# ABC 139: B – Power Socket
from math import ceil
a, b = [int(s) for s in input().split()]
print((ceil((b - 1) / (a - 1)))) | # ABC 139: B – Power Socket
A, B = [int(s) for s in input().split()]
taps = 0
while (A - 1) * taps + 1 < B:
taps += 1
print(taps) | p02922 |
a,b = list(map(int,input().split()))
ans = 1
count = 0
while ans < b:
ans = (ans-1)+a
count += 1
print(count) | a,b = list(map(int,input().split()))
ans = 1
count = 0
while ans<b:
ans += (a-1)
count += 1
print(count) | p02922 |
a,b = list(map(int, input().split()))
from math import ceil
print((ceil( (b-1) / (a-1) ) ))
| def resolve():
a,b = list(map(int, input().split()))
tmp = 1
cnt = 0
while tmp < b:
tmp -= 1
cnt += 1
tmp += a
print(cnt)
if __name__ == '__main__':
resolve()
| p02922 |
A,B = list(map(int,input().split()))
ans=1
cnt=0
while B > ans:
ans+=A-1
cnt+=1
print(cnt) | import math
A,B = list(map(int,input().split()))
print((math.ceil((B - A) / (A - 1)) + 1)) | p02922 |
import math
(a,b) = list(map(int, input().split()))
print((math.ceil(((b-a)/(a-1) + 1)))) | A, B = [int(A) for A in input().split()]
socket = 0
count = 0
if B==1 :
count=0
elif B != 0 :
while socket < B :
if socket + A < B :
socket = socket + A - 1
count += 1
elif socket+A >= B :
socket = socket + A
count += 1
print(count)
| p02922 |
import math
a,b=list(map(int,input().split()))
print((math.ceil((b-1)/(a-1))))
| a,b=list(map(int,input().split()))
ans,num=0,1
while num<b:
num-=1
num+=a
ans+=1
print(ans) | p02922 |
from sys import stdin
import queue
import sys
import math
a,b=list(map(int,input().split()))
print((math.ceil((b-1)/(a-1))))
| import math
a,b=list(map(int,input().split()))
print((math.ceil((b-1)/(a-1)))) | p02922 |
import sys
input = sys.stdin.readline
a,b = list(map(int, input().split()))
cnt = 1
while True:
if b<= 1:
cnt = 0
elif b <= (a-1)*cnt+1:
break
cnt += 1
print(cnt) | import sys
input = sys.stdin.readline
a,b = list(map(int, input().split()))
cnt = 1
while True:
if b<= 1:
cnt = 0
break
elif b <= (a-1)*cnt+1:
break
cnt += 1
print(cnt) | p02922 |
a, b = list(map(int, input().split()))
now = 1
ans = 0
while now < b:
ans += 1
now += a-1
print(ans)
| a, b = list(map(int, input().split()))
tmp = (b-1)/(a-1)
if tmp - int(tmp) == 0:
print((int(tmp)))
else:
print((int(tmp)+1)) | p02922 |
a, b = list(map(int, input().split()))
print((-(-(b-a)//(a-1)) + 1))
| # 2:50
a, b = list(map(int, input().split()))
if b == 1:
print((0))
exit()
if a >= b:
print((1))
else:
b -= a
cnt = 1
while (b > 0):
b -= (a - 1)
cnt += 1
print(cnt)
| p02922 |
import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**8)
def geta(fn=lambda s: s.decode()):
return list(map(fn, readline().split()))
def gete(fn=lambda s: s.decode()):
return fn(readline().rstrip())
def main():
a, b = geta(int)
if b == 1:
print((0))
exit()
n = 1
while a * n - n + 1 < b:
n += 1
print(n)
if __name__ == "__main__":
main() | import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**8)
def geta(fn=lambda s: s.decode()):
return list(map(fn, readline().split()))
def gete(fn=lambda s: s.decode()):
return fn(readline().rstrip())
def main():
a, b = geta(int)
tot = 1
ans = 0
while tot < b:
ans += 1
tot += a - 1
print(ans)
if __name__ == "__main__":
main() | p02922 |
from copy import deepcopy
from math import ceil
if __name__ == "__main__":
a = list(map(int, input().split()))
n = deepcopy(a[0])
i = 1
if a[0] == a[1]: print(i)
elif a[1] == 1: print((0))
elif a[0] >= a[1]: print(i)
else:
while True:
i += 1
n += a[0] - 1
if n >= a[1]:
print(i)
break | #n = input()
a = list(map(int, input().split()))
#b = list(map(int, input().split()))
#c = list(map(int, input().split()))
r = 1
c = 0
if a[1] == 1:
print((0))
elif a[0] == a[1]:
print((1))
else:
while r < a[1]:
c += 1
r -= 1
r += a[0]
print(c) | p02922 |
#!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
#A
def A():
s = S()
t = S()
ans = 0
for i in range(len(s)):
if s[i] == t[i]:
ans += 1
print(ans)
return
#B
def B():
a,b = LI()
for i in range(10000):
if 1+i*a-i >= b:
print(i)
return
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#Solve
if __name__ == "__main__":
B()
| import math
a,b = [int(x) for x in input().split()]
print((math.ceil((b-1)/(a-1))))
| p02922 |
import math
a,b=list(map(int,input().split()))
print((math.ceil((b-1)/(a-1)))) | a,b=list(map(int,input().split()))
print((-(-(b-1)//(a-1)))) | p02922 |
# -*- coding: utf-8 -*-
a,b = list(map(int, input().split()))
res = 0
cnt = 1
while cnt<b:
cnt += a-1
res += 1
print(res)
| a,b = list(map(int, input().split()))
s = 1
cnt = 0
while s<b:
s += a-1
cnt += 1
print(cnt) | p02922 |
a, b = list(map(int, input().split()))
print((0 if b == 1 else ((b - 1) + (a - 2)) // (a - 1)))
| a, b = list(map(int, input().split()))
print((((b - 1) + (a - 2)) // (a - 1)))
| p02922 |
import math
a, b = list(map(int, input().split()))
print((math.ceil((b-1)/(a-1)))) | a, b = list(map(int, input().split()))
n = 0
while a*n-(n-1) < b:
n += 1
print(n)
| p02922 |
import sys
A, B = list(map(int, input().split()))
if B == 1:
print((0))
sys.exit()
ans = 1
taps = A
while True:
if B <= taps:
break
ans += 1
taps += A - 1
print(ans) | A, B = list(map(int, input().split()))
ans = 0
taps = 1
while taps < B:
taps += A - 1
ans += 1
print(ans) | p02922 |
a, b = list(map(int, input().split()))
b -= 1
a = (b + (a - 2)) // (a - 1)
print(a) | a, b = list(map(int, input().split()))
# b -= a
# counter = 1
# while b > 0:
# b -= a - 1
# counter += 1
# print(counter)
sum_tap = 1
for i in range(100):
if sum_tap >= b:
print(i)
break
sum_tap += a - 1
| p02922 |
A, B = list(map(int,input().split()))
for i in range(21):
if ((A - 1) * (i - 1)) + A >= B:
print(i)
exit() | A, B = list(map(int, input().split()))
for i in range(0, 21):
ans = i * ( A - 1 ) + 1
if ans >= B:
print(i)
exit()
| p02922 |
def slove():
import sys
input = sys.stdin.readline
a, b = list(map(int, input().rstrip('\n').split()))
t = 1
cnt = 0
while True:
if t >= b:
print(cnt)
exit()
else:
t += a
t -= 1
cnt += 1
if __name__ == '__main__':
slove()
| def slove():
import sys
input = sys.stdin.readline
a, b = list(map(int, input().rstrip('\n').split()))
d = a - 1
print(((b - 1 + d - 1) // d))
if __name__ == '__main__':
slove()
| p02922 |
A, B = list(map(int,input().split()))
puragu = 1
if B == 1:
print((0))
exit()
if A >= B:
print((1))
exit()
result = 0
while puragu < B:
puragu += A-1
result += 1
print(result)
| A, B = list(map(int, input().split()))
tap = 1
count = 0
while tap < B:
tap += A - 1
count += 1
print(count) | p02922 |
a, b = [int(i) for i in input().split()]
b-=1
c=0
while b>0:
b-=a-1
c+=1
print(c) | a, b = list(map(int, input().split()))
ans = 0
tmp = 0
if b == 1:
print((0))
exit()
for i in range(10 ** 9):
ans += 1
tmp += a
if b <= tmp:
break
else:
tmp -= 1
print(ans)
| p02922 |
AB = input().split()
A,B = int(AB[0]),int(AB[1])
count = 0
unused = 1
while unused < B:
unused += A - 1
count += 1
print(count) | a,b=list(map(int,input().split()))
t=1
ans=0
while t<b:
t += a-1
ans += 1
print(ans) | p02922 |
a,b = list(map(int,input().split()))
res = 0
c = 1
while c < b:
c += a - 1
res += 1
print(res) | a,b = list(map(int,input().split()))
ans = 0
tap = 1
while tap < b:
ans += 1
tap += a - 1
print(ans)
| p02922 |
import math
a, b = list(map(int, input().split(' ')))
print((math.ceil((b - 1) / (a - 1))))
| a, b = list(map(int, input().split(' ')))
print((-(-(b-1) // (a-1))))
| p02922 |
import math
a, b = list(map(int, input().split()))
i = 0
s = 1
while b > s:
s += a-1
i += 1
print(i) | import math
a, b = list(map(int, input().split()))
print((math.ceil((b-1)*1.0/(a-1)))) | p02922 |
A, B = list(map(int, input().split()))
ans = 0
k = 1
while k < B:
ans += 1
k += A - 1
print(ans) | a,b=list(map(int, input().split()))
k=1
for i in range(1000):
if k>=b:
print(i)
break
k = k - 1 + a
| p02922 |
a,b=list(map(int,input().split()))
sum=1
tap=0
while sum<b:
sum+=a-1
tap+=1
print(tap) | a,b=list(map(int,input().split()))
con=1
ans=0
while con<b:
con+=a-1
ans+=1
print(ans) | p02922 |
A, B = list(map(int, input().split()))
if (B-1)%(A-1) == 0:
print((int((B-1)/(A-1))))
else:
print((int((B-1)//(A-1) +1))) | A, B = list(map(int, input().split()))
if (B-1)%(A-1) == 0:
print((int((B-1)/(A-1))))
else:
print(((B-1)//(A-1) +1)) | p02922 |
a,b = list(map(int,input().split()))
sumA = a
count =1
ans = 0
while count < b:
count -=1
count +=a
ans +=1
print(ans) | a,b = list(map(int,input().split()))
count =1
ans = 0
while count < b:
count -=1
count +=a
ans +=1
print(ans)
| p02922 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
a,b=LI()
c=1
ans=0
while True:
if c>=b:
return ans
ans+=1
c-=1
c+=a
# main()
print((main()))
| # 入力
a,b=list(map(int,input().split()))
# 初期状態（1口）
n=1
# タップの数
ans=0
# タップを1つずつ差していく
# 差すことでa口増えるが、差した口も1つ減る
while True:
# b口以上になったら終了
if n>=b:
print(ans)
exit()
n+=a
n-=1
ans+=1
| p02922 |
A,B=list(map(int,input().split()))
x=0
while (A-1)*x+1<B:
x+=1
print(x) | a, b = list(map(int, input().split()))
print((-(-(b-1)//(a-1))))
| p02922 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,M = list(map(int,input().split()))
LRA = [[int(x) for x in row.split()] for row in sys.stdin.readlines()]
R_to_LA = [[] for _ in range(N+1)]
for L,R,A in LRA:
R_to_LA[R].append((L,A))
INF = 10 ** 18
size = 1<<18
data = [0] * (2*size)
lazy = [0] * (2*size)
left_end = [None] * (2*size)
right_end = [None] * (2*size)
q = [1]
left_end[1] = 0
right_end[1] = size
for n in range(1,size):
L,R = left_end[n],right_end[n]
M = (L+R)//2
left_end[2*n] = L
right_end[2*n] = M
left_end[2*n+1] = M
right_end[2*n+1] = R
def get_max(R):
q = [1]
ret = -INF
while q:
qq = []
for i in q:
iL = left_end[i]
iR = right_end[i]
if iR <= R:
# 完全に含まれている
x = data[i] + lazy[i]
if ret < x:
ret = x
elif R<=iL:
# 完全に無関係
pass
else:
# 部分的に交わっている
j = i<<1; k = j+1
lazy[j] += lazy[i]; lazy[k] += lazy[i]
lazy[i] = 0
qq.append(2*i); qq.append(2*i+1)
q = qq
return ret
def add(L,R,x):
q = [1]
q1 = []
while q:
qq = []
for i in q:
iL = left_end[i]
iR = right_end[i]
if L <= iL and iR <= R:
# 完全に含まれている
lazy[i] += x
elif iR<=L or R<=iL:
pass
else:
# 部分的に交わっている
q1.append(i)
j = i<<1; k = j+1
lazy[j] += lazy[i]; lazy[k] += lazy[i]
lazy[i] = 0
qq.append(j)
qq.append(k)
q = qq
for i in reversed(q1):
j = i<<1; k = j+1
data[i] = max(data[j]+lazy[j],data[k]+lazy[k])
for R in range(1,N+1):
x = get_max(R)
add(R,R+1,x)
for L,A in R_to_LA[R]:
add(L,R+1,A)
for n in range(size):
lazy[2*n] += lazy[n]
lazy[2*n+1] += lazy[n]
answer = max(lazy[size:])
print(answer) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,M = list(map(int,input().split()))
LRA = [[int(x) for x in row.split()] for row in sys.stdin.readlines()]
R_to_LA = [[] for _ in range(N+1)]
for L,R,A in LRA:
R_to_LA[R].append((L,A))
INF = 10 ** 18
size = 1<<18
data = [0] * (2*size)
lazy = [0] * (2*size)
left_end = [None] * (2*size)
right_end = [None] * (2*size)
left_end[1] = 0
right_end[1] = size
for n in range(1,size):
L,R = left_end[n],right_end[n]
M = (L+R)//2
left_end[2*n] = L
right_end[2*n] = M
left_end[2*n+1] = M
right_end[2*n+1] = R
def add(L,R,x):
q = [1]
q1 = []
while q:
qq = []
for i in q:
iL = left_end[i]
iR = right_end[i]
if L <= iL and iR <= R:
# 完全に含まれている
lazy[i] += x
elif iR<=L or R<=iL:
pass
else:
# 部分的に交わっている
q1.append(i)
j = i<<1; k = j+1
lazy[j] += lazy[i]; lazy[k] += lazy[i]
lazy[i] = 0
qq.append(j)
qq.append(k)
q = qq
for i in reversed(q1):
j = i<<1; k = j+1
data[i] = max(data[j]+lazy[j],data[k]+lazy[k])
for R in range(1,N+1):
x = data[1] + lazy[1]
add(R,R+1,x)
for L,A in R_to_LA[R]:
add(L,R+1,A)
for n in range(size):
lazy[2*n] += lazy[n]
lazy[2*n+1] += lazy[n]
answer = max(lazy[size:])
print(answer) | p03182 |
import sys
readline = sys.stdin.readline
N, M = list(map(int, readline().split()))
L = [[] for i in range(N+1)]
R = [[] for i in range(N+1)]
for i in range(M):
l, r, a = list(map(int, readline().split()))
L[l-1].append((r, a))
INF = 2**31-1
LV = (N).bit_length()
N0 = 2**LV
data = [0]*(2*N0)
lazy = [0]*(2*N0)
I = []; K = []
for x in range(N0+1):
y = N0 + x
z = (y // (y & -y)) >> 1
K.append(z)
r = []
while z:
r.append(z)
z >>= 1
r.reverse()
I.append(r)
I.append([])
J = []
for x in range(N0+1):
y = N0 + x + 1
z = (y // (y & -y)) - 1
J.append(z-1 if z else 0)
def propagates(ids):
for i in ids:
v = lazy[i-1]
if not v:
continue
lazy[2*i-1] += v; lazy[2*i] += v
data[2*i-1] += v; data[2*i] += v
lazy[i-1] = 0
# update [0, r)
def update(r, x):
propagates(I[r])
i = r
while i:
v = J[i-1]
lazy[v] += x; data[v] += x
i -= (i & -i)
k = K[r]
while k:
data[k-1] = max(data[2*k-1], data[2*k])
k >>= 1
# update[k, k+1)
def update1(k, x):
propagates(I[k])
k += N0
data[k-1] += x
while k:
k >>= 1
data[k-1] = max(data[2*k-1], data[2*k])
# query [0, r)
def query(r):
return max(list(map(data.__getitem__, qquery(r))))
def qquery(r):
propagates(I[r])
while r:
yield J[r-1]
r -= (r & -r)
# query [k, k+1)
def query1(k, x):
propagates(I[k])
return data[k + N0 - 1]
for i in range(N):
for r, a in L[i]:
update(i+1, a)
R[r].append((i, a))
for l, a in R[i]:
update(l+1, -a)
v = query(i+1)
update1(i+1, v)
for l, a in R[N]:
update(l+1, -a)
sys.stdout.write("%d\n" % query(N+1)) | import sys
readline = sys.stdin.readline
N, M = list(map(int, readline().split()))
L = [[] for i in range(N+1)]
R = [[] for i in range(N+1)]
for i in range(M):
l, r, a = list(map(int, readline().split()))
L[l-1].append((r, a))
INF = 2**31-1
LV = (N).bit_length()
N0 = 2**LV
data = [0]*(2*N0)
lazy = [0]*(2*N0)
I = []; J = []
for x in range(N0+1):
y = N0 + x
z = (y // (y & -y)) >> 1
J.append(2*z-1 if z else 0)
r = []
while z:
r.append(z)
z >>= 1
r.reverse()
I.append(r)
I.append([])
def propagates(ids):
for i in ids:
v = lazy[i-1]
if not v:
continue
lazy[2*i-1] += v; lazy[2*i] += v
data[2*i-1] += v; data[2*i] += v
lazy[i-1] = 0
# update [0, r)
def update(r, x):
#propagates(I[r])
i = r
while i:
v = J[i]
lazy[v] += x; data[v] += x
i -= (i & -i)
k = (J[r] + 1) >> 1
while k:
data[k-1] = max(data[2*k-1], data[2*k]) + lazy[k-1]
k >>= 1
# update[k, k+1)
def update1(k, x):
#propagates(I[k])
k += N0
data[k-1] += x
while k:
k >>= 1
data[k-1] = max(data[2*k-1], data[2*k]) + lazy[k-1]
# query [0, r)
def query(r):
return max(list(map(data.__getitem__, qquery(r))))
def qquery(r):
propagates(I[r])
while r:
yield J[r]
r -= (r & -r)
# query [k, k+1)
def query1(k, x):
propagates(I[k])
return data[k + N0 - 1]
for i in range(N):
for r, a in L[i]:
update(i+1, a)
R[r].append((i, a))
for l, a in R[i]:
update(l+1, -a)
v = query(i+1)
update1(i+1, v)
for l, a in R[N]:
update(l+1, -a)
sys.stdout.write("%d\n" % query(N+1)) | p03182 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
class SegmentTree(object):
def __init__(self,A,dot,e,comp,id,act):
"""
A: array of monoid (M,dot,e)
comp: composite function of Hom(M), comp(f,g)=gf
id: identity map of M
act: action on (Hom(M),M), act(f,a)=f(a)
"""
n=2**((len(A)-1).bit_length())
self.__n=n
self.__dot=dot
self.__e=e
self.__comp=comp
self.__id=id
self.__act=act
self.__node=[e]*(2*n)
self.__lazy=[id]*(2*n)
for i in range(len(A)):
self.__node[i+n]=A[i]
for i in range(n-1,0,-1):
self.__node[i]=self.__dot(self.__node[2*i],self.__node[2*i+1])
def __propagate(self,i):
if(self.__lazy[i]==self.__id): return
node=self.__node
lazy=self.__lazy
if(i<self.__n): # propagate to children
lazy[2*i]=self.__comp(lazy[2*i],lazy[i])
lazy[2*i+1]=self.__comp(lazy[2*i+1],lazy[i])
node[i]=self.__act(lazy[i],node[i]) # action
lazy[i]=self.__id
def __ancestors_propagate(self,i):
if(i==1): return
i//=2
self.__ancestors_propagate(i)
self.__propagate(i)
def __update_ancestors(self,i):
while(i!=1):
self.__propagate(i+1-2*(i%2)) # propagate the sibling of i
i//=2
self.__node[i]=self.__dot(self.__node[2*i],self.__node[2*i+1])
def update(self,i,c):
i+=self.__n
self.__ancestors_propagate(i)
self.__propagate(i)
self.__node[i]=c
self.__update_ancestors(i)
def add(self,l,r,f):
range,low=[],[0]*2
l+=self.__n; r+=self.__n
while(l<r):
if(l%2==1):
if(low[0]==0): low[0]=l
range.append(l)
l+=1
l//=2
if(r%2==1):
r-=1
range.append(r)
if(low[1]==0): low[1]=r
r//=2
for i in low:
if(i): self.__ancestors_propagate(i)
for i in range: self.__lazy[i]=self.__comp(self.__lazy[i],f)
for i in low:
if(i):
self.__propagate(i)
self.__update_ancestors(i)
def sum(self,l,r):
low=[0]*2
vl,vr=self.__e,self.__e
l+=self.__n; r+=self.__n
while(l<r):
if(l%2==1):
if(low[0]==0):
self.__ancestors_propagate(l)
low[0]=1
self.__propagate(l)
vl=self.__dot(vl,self.__node[l])
l+=1
l//=2
if(r%2==1):
r-=1
if(low[1]==0):
self.__ancestors_propagate(r)
low[1]=1
self.__propagate(r)
vr=self.__dot(self.__node[r],vr)
r//=2
return self.__dot(vl,vr)
def resolve():
n,m=list(map(int,input().split()))
R=[[] for _ in range(n)]
for _ in range(m):
l,r,a=list(map(int,input().split()))
l-=1; r-=1
R[r].append((l,a))
from operator import add
dp=SegmentTree([0]*n,max,0,add,0,add)
for r in range(n):
dp.update(r,dp.sum(0,r))
for l,a in R[r]:
dp.add(l,r+1,a)
print((dp.sum(0,n)))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
class LazySegmentTree(object):
def __init__(self, A, dot, unit, compose, identity, act):
"""
(M, dot, unit) : monoid
(S, compose, identitiy) : sub monoid of End(M)
A : array of M
compose : (f, g) -> fg (f, g in S)
act : (f, x) -> f(x) (f in S, x in M)
"""
logn = (len(A) - 1).bit_length()
n = 1 << logn
tree = [unit] * (2 * n)
for i, v in enumerate(A):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n = n
self._logn = logn
self._tree = tree
self._lazy = [identity] * (2 * n)
self._dot = dot
self._unit = unit
self._compose = compose
self._identity = identity
self._act = act
def _fix_ancestors(self, i):
tree, lazy, dot, act = self._tree, self._lazy, self._dot, self._act
while i > 1:
i >>= 1
tree[i] = act(lazy[i], dot(tree[i << 1], tree[i << 1 | 1]))
def _propagate(self, i):
tree, lazy, identity, compose, act = self._tree, self._lazy, self._identity, self._compose, self._act
for k in range(self._logn, 0, -1):
p = i >> k
f = lazy[p]
tree[p << 1], lazy[p << 1] = act(f, tree[p << 1]), compose(f, lazy[p << 1])
tree[p << 1 | 1], lazy[p << 1 | 1] = act(f, tree[p << 1 | 1]), compose(f, lazy[p << 1 | 1])
lazy[p] = identity
def range_act(self, l, r, f):
l += self._n
r += self._n
# propagation isn't needed if S is commutative
self._propagate(l)
self._propagate(r - 1)
l0, r0 = l, r
tree, lazy, act, compose = self._tree, self._lazy, self._act, self._compose
while l < r:
if l & 1:
tree[l], lazy[l] = act(f, tree[l]), compose(f, lazy[l])
l += 1
if r & 1:
r -= 1
tree[r], lazy[r] = act(f, tree[r]), compose(f, lazy[r])
l >>= 1
r >>= 1
self._fix_ancestors(l0)
self._fix_ancestors(r0 - 1)
def sum(self, l, r):
l += self._n
r += self._n
self._propagate(l)
self._propagate(r)
l_val = r_val = self._unit
tree, dot = self._tree, self._dot
while l < r:
if l & 1:
l_val = dot(l_val, tree[l])
l += 1
if r & 1:
r -= 1
r_val = dot(tree[r], r_val)
l >>= 1
r >>= 1
return dot(l_val, r_val)
def resolve():
n,m=list(map(int,input().split()))
R=[[] for _ in range(n)]
for _ in range(m):
l,r,a=list(map(int,input().split()))
l-=1; r-=1
R[r].append((l,a))
from operator import add
dp=LazySegmentTree([0]*n,max,0,add,0,add)
for r in range(n):
dp.range_act(r,r+1,dp.sum(0,r))
for l,a in R[r]:
dp.range_act(l,r+1,a)
print((dp.sum(0,n)))
resolve() | p03182 |
import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
class LazySegmentTree(object):
def __init__(self, A, dot, unit, compose, identity, act):
"""
(M, dot, unit) : monoid
(S, compose, identitiy) : sub monoid of End(M)
A : array of M
compose : (f, g) -> fg (f, g in S)
act : (f, x) -> f(x) (f in S, x in M)
"""
logn = (len(A) - 1).bit_length()
n = 1 << logn
tree = [unit] * (2 * n)
for i, v in enumerate(A):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n = n
self._logn = logn
self._tree = tree
self._lazy = [identity] * (2 * n)
self._dot = dot
self._unit = unit
self._compose = compose
self._identity = identity
self._act = act
def _fix_ancestors(self, i):
tree, lazy, dot, act = self._tree, self._lazy, self._dot, self._act
while i > 1:
i >>= 1
tree[i] = act(lazy[i], dot(tree[i << 1], tree[i << 1 | 1]))
def _propagate(self, i):
tree, lazy, identity, compose, act = self._tree, self._lazy, self._identity, self._compose, self._act
for k in range(self._logn, 0, -1):
p = i >> k
f = lazy[p]
tree[p << 1], lazy[p << 1] = act(f, tree[p << 1]), compose(f, lazy[p << 1])
tree[p << 1 | 1], lazy[p << 1 | 1] = act(f, tree[p << 1 | 1]), compose(f, lazy[p << 1 | 1])
lazy[p] = identity
def range_act(self, l, r, f):
"A[i] = f(A[i]) for all i in [l, r)"
l += self._n
r += self._n
# propagation isn't necessary if S is commutative
# self._propagate(l)
# self._propagate(r - 1)
l0, r0 = l, r
tree, lazy, act, compose = self._tree, self._lazy, self._act, self._compose
while l < r:
if l & 1:
tree[l], lazy[l] = act(f, tree[l]), compose(f, lazy[l])
l += 1
if r & 1:
r -= 1
tree[r], lazy[r] = act(f, tree[r]), compose(f, lazy[r])
l >>= 1
r >>= 1
self._fix_ancestors(l0)
self._fix_ancestors(r0 - 1)
def sum(self, l, r):
"calculate product of A[l:r]"
l += self._n
r += self._n
self._propagate(l)
self._propagate(r - 1)
l_val = r_val = self._unit
tree, dot = self._tree, self._dot
while l < r:
if l & 1:
l_val = dot(l_val, tree[l])
l += 1
if r & 1:
r -= 1
r_val = dot(tree[r], r_val)
l >>= 1
r >>= 1
return dot(l_val, r_val)
from operator import add
def resolve():
n, m = list(map(int, input().split()))
queries = [[] for _ in range(n)]
for _ in range(m):
l, r, a = list(map(int, input().split()))
queries[l - 1].append((r, a))
# range max, range add
tree = LazySegmentTree([0] * n, max, -INF, add, 0, add)
# dp[i][j] : i <= l の query を全て処理した後、j 番目に初めて 1 が現れるときの max score
for i in range(n - 1, -1, -1):
tree.range_act(i, i + 1, tree.sum(i, n)) # pointwise update
for r, a in queries[i]:
tree.range_act(i, r, a)
print((max(0, tree.sum(0, n))))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
class LazySegmentTree(object):
def __init__(self, A, dot, unit, compose, identity, act):
"""
(M, dot, unit) : monoid
(S, compose, identitiy) : sub monoid of End(M)
A : array of M
compose : (f, g) -> fg (f, g in S)
act : (f, x) -> f(x) (f in S, x in M)
"""
logn = (len(A) - 1).bit_length()
n = 1 << logn
tree = [unit] * (2 * n)
for i, v in enumerate(A):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n = n
self._logn = logn
self._tree = tree
self._lazy = [identity] * (2 * n)
self._dot = dot
self._unit = unit
self._compose = compose
self._identity = identity
self._act = act
def _fix_ancestors(self, i):
tree, lazy, dot, act = self._tree, self._lazy, self._dot, self._act
while i > 1:
i >>= 1
tree[i] = act(lazy[i], dot(tree[i << 1], tree[i << 1 | 1]))
def _propagate(self, i):
tree, lazy, identity, compose, act = self._tree, self._lazy, self._identity, self._compose, self._act
for k in range(self._logn, 0, -1):
p = i >> k
f = lazy[p]
tree[p << 1], lazy[p << 1] = act(f, tree[p << 1]), compose(f, lazy[p << 1])
tree[p << 1 | 1], lazy[p << 1 | 1] = act(f, tree[p << 1 | 1]), compose(f, lazy[p << 1 | 1])
lazy[p] = identity
def range_act(self, l, r, f):
"A[i] = f(A[i]) for all i in [l, r)"
l += self._n
r += self._n
# propagation isn't necessary if S is commutative
# self._propagate(l)
# self._propagate(r - 1)
l0, r0 = l, r
tree, lazy, act, compose = self._tree, self._lazy, self._act, self._compose
while l < r:
if l & 1:
tree[l], lazy[l] = act(f, tree[l]), compose(f, lazy[l])
l += 1
if r & 1:
r -= 1
tree[r], lazy[r] = act(f, tree[r]), compose(f, lazy[r])
l >>= 1
r >>= 1
self._fix_ancestors(l0)
self._fix_ancestors(r0 - 1)
def sum(self, l, r):
"calculate product of A[l:r]"
l += self._n
r += self._n
self._propagate(l)
self._propagate(r - 1)
l_val = r_val = self._unit
tree, dot = self._tree, self._dot
while l < r:
if l & 1:
l_val = dot(l_val, tree[l])
l += 1
if r & 1:
r -= 1
r_val = dot(tree[r], r_val)
l >>= 1
r >>= 1
return dot(l_val, r_val)
from operator import add
def resolve():
n, m = list(map(int, input().split()))
queries = [[] for _ in range(n)]
for _ in range(m):
l, r, a = list(map(int, input().split()))
queries[l - 1].append((r, a))
# range max, range add
tree = LazySegmentTree([0] * n, max, 0, add, 0, add)
# dp[i][j] : i <= l の query を全て処理した後、j 番目に初めて 1 が現れるときの max score
for i in range(n - 1, -1, -1):
tree.range_act(i, i + 1, tree.sum(i, n)) # pointwise update
for r, a in queries[i]:
tree.range_act(i, r, a)
print((max(0, tree.sum(0, n))))
resolve() | p03182 |
import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
class LazySegmentTree(object):
def __init__(self, A, dot, unit, compose, identity, act):
"""
(M, dot, unit) : monoid
(S, compose, identitiy) : sub monoid of End(M)
A : array of M
compose : (f, g) -> fg (f, g in S)
act : (f, x) -> f(x) (f in S, x in M)
"""
logn = (len(A) - 1).bit_length()
n = 1 << logn
tree = [unit] * (2 * n)
for i, v in enumerate(A):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n = n
self._logn = logn
self._tree = tree
self._lazy = [identity] * (2 * n)
self._dot = dot
self._unit = unit
self._compose = compose
self._identity = identity
self._act = act
def _fix_ancestors(self, i):
tree, lazy, dot, act = self._tree, self._lazy, self._dot, self._act
while i > 1:
i >>= 1
tree[i] = act(lazy[i], dot(tree[i << 1], tree[i << 1 | 1]))
def _propagate(self, i):
tree, lazy, identity, compose, act = self._tree, self._lazy, self._identity, self._compose, self._act
for k in range(self._logn, 0, -1):
p = i >> k
f = lazy[p]
tree[p << 1], lazy[p << 1] = act(f, tree[p << 1]), compose(f, lazy[p << 1])
tree[p << 1 | 1], lazy[p << 1 | 1] = act(f, tree[p << 1 | 1]), compose(f, lazy[p << 1 | 1])
lazy[p] = identity
def range_act(self, l, r, f):
"A[i] = f(A[i]) for all i in [l, r)"
l += self._n
r += self._n
# propagation isn't necessary if S is commutative
# self._propagate(l)
# self._propagate(r - 1)
l0, r0 = l, r
tree, lazy, act, compose = self._tree, self._lazy, self._act, self._compose
while l < r:
if l & 1:
tree[l], lazy[l] = act(f, tree[l]), compose(f, lazy[l])
l += 1
if r & 1:
r -= 1
tree[r], lazy[r] = act(f, tree[r]), compose(f, lazy[r])
l >>= 1
r >>= 1
self._fix_ancestors(l0)
self._fix_ancestors(r0 - 1)
def sum(self, l, r):
"calculate product of A[l:r]"
l += self._n
r += self._n
self._propagate(l)
self._propagate(r - 1)
l_val = r_val = self._unit
tree, dot = self._tree, self._dot
while l < r:
if l & 1:
l_val = dot(l_val, tree[l])
l += 1
if r & 1:
r -= 1
r_val = dot(tree[r], r_val)
l >>= 1
r >>= 1
return dot(l_val, r_val)
from operator import add
def resolve():
n, m = list(map(int, input().split()))
queries = [None] * m
for i in range(m):
l, r, a = list(map(int, input().split()))
queries[i] = (l - 1, r, a)
queries.sort()
# range max, range add
tree = LazySegmentTree([0] * n, max, 0, add, 0, add)
# dp[i][j] : i <= l の query を全て処理した後、j 番目に初めて 1 が現れるときの max score
for i in range(n - 1, -1, -1):
tree.range_act(i, i + 1, tree.sum(i, n)) # pointwise update
while queries and queries[-1][0] == i:
l, r, a = queries.pop()
tree.range_act(l, r, a)
print((max(0, tree.sum(0, n))))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
class LazySegmentTree(object):
def __init__(self, A, dot, unit, compose, identity, act):
"""
(M, dot, unit) : monoid
(S, compose, identitiy) : sub monoid of End(M)
A : array of M
compose : (f, g) -> fg (f, g in S)
act : (f, x) -> f(x) (f in S, x in M)
"""
logn = (len(A) - 1).bit_length()
n = 1 << logn
tree = [unit] * (2 * n)
for i, v in enumerate(A):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n = n
self._logn = logn
self._tree = tree
self._lazy = [identity] * (2 * n)
self._dot = dot
self._unit = unit
self._compose = compose
self._identity = identity
self._act = act
def _fix_ancestors(self, i):
tree, lazy, dot, act = self._tree, self._lazy, self._dot, self._act
while i > 1:
i >>= 1
tree[i] = act(lazy[i], dot(tree[i << 1], tree[i << 1 | 1]))
def _propagate(self, i):
tree, lazy, identity, compose, act = self._tree, self._lazy, self._identity, self._compose, self._act
for k in range(self._logn, 0, -1):
p = i >> k
f = lazy[p]
tree[p << 1], lazy[p << 1] = act(f, tree[p << 1]), compose(f, lazy[p << 1])
tree[p << 1 | 1], lazy[p << 1 | 1] = act(f, tree[p << 1 | 1]), compose(f, lazy[p << 1 | 1])
lazy[p] = identity
def range_act(self, l, r, f):
"A[i] = f(A[i]) for all i in [l, r)"
l += self._n
r += self._n
# propagation isn't necessary if S is commutative
self._propagate(l)
self._propagate(r - 1)
l0, r0 = l, r
tree, lazy, act, compose = self._tree, self._lazy, self._act, self._compose
while l < r:
if l & 1:
tree[l], lazy[l] = act(f, tree[l]), compose(f, lazy[l])
l += 1
if r & 1:
r -= 1
tree[r], lazy[r] = act(f, tree[r]), compose(f, lazy[r])
l >>= 1
r >>= 1
self._fix_ancestors(l0)
self._fix_ancestors(r0 - 1)
def sum(self, l, r):
"calculate product of A[l:r]"
l += self._n
r += self._n
self._propagate(l)
self._propagate(r - 1)
l_val = r_val = self._unit
tree, dot = self._tree, self._dot
while l < r:
if l & 1:
l_val = dot(l_val, tree[l])
l += 1
if r & 1:
r -= 1
r_val = dot(tree[r], r_val)
l >>= 1
r >>= 1
return dot(l_val, r_val)
from operator import add
def resolve():
n, m = list(map(int, input().split()))
queries = [[] for _ in range(n)]
for _ in range(m):
l, r, a = list(map(int, input().split()))
queries[l - 1].append((r, a))
# range max, range add
tree = LazySegmentTree([0] * n, max, 0, add, 0, add)
# dp[i][j] : i <= l の query を全て処理した後、j 番目に初めて 1 が現れるときの max score
for i in range(n - 1, -1, -1):
tree.range_act(i, i + 1, tree.sum(i, n)) # pointwise update
for r, a in queries[i]:
tree.range_act(i, r, a)
print((max(0, tree.sum(0, n))))
resolve() | p03182 |
#!/usr/bin/env pypy3
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N,M=MI()
class Lazysegtree:
#RAQ
def __init__(self, A, intv, initialize = True, segf = min):
#区間は 1-indexed で管理
self.N = len(A)
self.N0 = 2**(self.N-1).bit_length()
self.intv = intv
self.segf = segf
self.lazy = [0]*(2*self.N0)
if initialize:
self.data = [intv]*self.N0 + A + [intv]*(self.N0 - self.N)
for i in range(self.N0-1, 0, -1):
self.data[i] = self.segf(self.data[2*i], self.data[2*i+1])
else:
self.data = [intv]*(2*self.N0)
def _ascend(self, k):
k = k >> 1
c = k.bit_length()
for j in range(c):
idx = k >> j
self.data[idx] = self.segf(self.data[2*idx], self.data[2*idx+1]) \
+ self.lazy[idx]
def _descend(self, k):
k = k >> 1
idx = 1
c = k.bit_length()
for j in range(1, c+1):
idx = k >> (c - j)
ax = self.lazy[idx]
if not ax:
continue
self.lazy[idx] = 0
self.data[2*idx] += ax
self.data[2*idx+1] += ax
self.lazy[2*idx] += ax
self.lazy[2*idx+1] += ax
def update(self, k, x):
k = k + self.N0
self.data[k] = x
self._ascend(k)
def query(self, l, r):
L = l+self.N0
R = r+self.N0
Li = L//(L & -L)
Ri = R//(R & -R)
self._descend(Li)
self._descend(Ri - 1)
s = self.intv
while L < R:
if R & 1:
R -= 1
s = self.segf(s, self.data[R])
if L & 1:
s = self.segf(s, self.data[L])
L += 1
L >>= 1
R >>= 1
return s
def add(self, l, r, x):
L = l+self.N0
R = r+self.N0
Li = L//(L & -L)
Ri = R//(R & -R)
while L < R :
if R & 1:
R -= 1
self.data[R] += x
self.lazy[R] += x
if L & 1:
self.data[L] += x
self.lazy[L] += x
L += 1
L >>= 1
R >>= 1
self._ascend(Li)
self._ascend(Ri-1)
sst=Lazysegtree([0]*(N+1), 0, True, max)
la=[[]for _ in range(N+1)]
for i in range(M):
l,r,a=MI()
la[r].append([l,a])
#sst[i]はi桁目がビットの立っている最右である時のmax
#lrのクエリはrまで来た時に，範囲内に加算
for i in range(1,N+1):
temp=sst.query(0,i)
sst.add(i,i+1,temp)#とりあえず，[0,i)の最大値を入れておく
for l,a in la[i]:
sst.add(l,i+1,a)
print((sst.query(0,N+1)))
main()
| import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N,M=MI()
class Lazysegtree:
#RAQ
def __init__(self, A, intv, initialize = True, segf = min):
#区間は 1-indexed で管理
self.N = len(A)
self.N0 = 2**(self.N-1).bit_length()
self.intv = intv
self.segf = segf
self.lazy = [0]*(2*self.N0)
if initialize:
self.data = [intv]*self.N0 + A + [intv]*(self.N0 - self.N)
for i in range(self.N0-1, 0, -1):
self.data[i] = self.segf(self.data[2*i], self.data[2*i+1])
else:
self.data = [intv]*(2*self.N0)
def _ascend(self, k):
k = k >> 1
c = k.bit_length()
for j in range(c):
idx = k >> j
self.data[idx] = self.segf(self.data[2*idx], self.data[2*idx+1]) \
+ self.lazy[idx]
def _descend(self, k):
k = k >> 1
idx = 1
c = k.bit_length()
for j in range(1, c+1):
idx = k >> (c - j)
ax = self.lazy[idx]
if not ax:
continue
self.lazy[idx] = 0
self.data[2*idx] += ax
self.data[2*idx+1] += ax
self.lazy[2*idx] += ax
self.lazy[2*idx+1] += ax
def update(self, k, x):
k = k + self.N0
self.data[k] = x
self._ascend(k)
def query(self, l, r):
L = l+self.N0
R = r+self.N0
Li = L//(L & -L)
Ri = R//(R & -R)
self._descend(Li)
self._descend(Ri - 1)
s = self.intv
while L < R:
if R & 1:
R -= 1
s = self.segf(s, self.data[R])
if L & 1:
s = self.segf(s, self.data[L])
L += 1
L >>= 1
R >>= 1
return s
def add(self, l, r, x):
L = l+self.N0
R = r+self.N0
Li = L//(L & -L)
Ri = R//(R & -R)
while L < R :
if R & 1:
R -= 1
self.data[R] += x
self.lazy[R] += x
if L & 1:
self.data[L] += x
self.lazy[L] += x
L += 1
L >>= 1
R >>= 1
self._ascend(Li)
self._ascend(Ri-1)
sst=Lazysegtree([0]*(N+1), 0, True, max)
la=[[]for _ in range(N+1)]
for i in range(M):
l,r,a=MI()
la[r].append([l,a])
#sst[i]はi桁目がビットの立っている最右である時のmax
#lrのクエリはrまで来た時に，範囲内に加算
for i in range(1,N+1):
temp=sst.query(0,i)
sst.add(i,i+1,temp)#とりあえず，[0,i)の最大値を入れておく
for l,a in la[i]:
sst.add(l,i+1,a)
print((sst.query(0,N+1)))
main()
| p03182 |
import sys
input = sys.stdin.readline
N,M=list(map(int,input().split()))
end=[[] for i in range(N+2)]
for i in [0]*M:
l,r,a=list(map(int,input().split()))
end[r+1].append((l,a))
#Starry Sky tree
seg_el=1<<18#Segment treeの台の要素数
SEG=[0]*(2*seg_el-1)#Segment tree.色々考えると0で初期化してOKそう
ADD=[0]*(2*seg_el-1)#加算用Segment tree,SEG[k]+ADD[k]がkにおける本当の最大値
def updates(a,b,x,k,l,r):#区間[a,b)にxを加算
if a==l and r==b:
ADD[k]+=x#そのノードのADD値を更新
return
if a>=(r+l)//2:
updates(a,b,x,k*2+2,(l+r)//2,r)#左側の子のみを見る
elif b<=(r+l)//2:
updates(a,b,x,k*2+1,l,(l+r)//2)#右側の子のみを見る
else:
updates(a,(l+r)//2,x,k*2+1,l,(l+r)//2)#それ以外のときは,SEG[k*2+1]とSEG[k*2+2]で場合分け
updates((l+r)//2,b,x,k*2+2,(l+r)//2,r)
SEG[k]=max(SEG[k*2+1]+ADD[k*2+1],SEG[k*2+2]+ADD[k*2+2])
def update_solo(n,x,seg_el):#A[n]=xに更新（反映）
i=n+seg_el-1
SEG[i]=x
i=(i-1)//2
while i>=0:
SEG[i]=max(SEG[i*2+1]+ADD[i*2+1],SEG[i*2+2]+ADD[i*2+2])
i=(i-1)//2
for i in range(1,N+2):
for b,x in end[i]:
updates(b,i,x,0,0,seg_el)#点数がもらえる区間から出たときにその分を加算
update_solo(i,SEG[0],seg_el)#[0,i)の最大値はSEG[0](=SEG[0]+ADD[0])と一致するはず
print((SEG[0])) | import sys
input = sys.stdin.readline
N,M=list(map(int,input().split()))
end=[[] for i in range(N+2)]
for i in [0]*M:
l,r,a=list(map(int,input().split()))
end[r+1].append((l,a))
#Starry Sky tree
seg_el=1<<18#Segment treeの台の要素数
SEG=[0]*(2*seg_el-1)#Segment tree.色々考えると0で初期化してOKそう
ADD=[0]*(2*seg_el-1)#加算用Segment tree,SEG[k]+ADD[k]がkにおける本当の最大値
seg_el_list=[524286, 262142, 131070, 65534, 32766, 16382, 8190, 4094, 2046, 1022, 510, 254, 126, 62, 30, 14, 6, 2, 0]
def update(k):#SEGのkより上のノードを更新（反映）
while k>=0:
k=(k-1)//2
if SEG[k]==max(SEG[k*2+1]+ADD[k*2+1],SEG[k*2+2]+ADD[k*2+2]):
break
SEG[k]=max(SEG[k*2+1]+ADD[k*2+1],SEG[k*2+2]+ADD[k*2+2])
def to_seg(a):#aが終点となる区間をSegment treeの座標へ変換
b=(a&(-a)).bit_length()
return seg_el_list[b]+a//(1<<(b-1))
def add(a,b,x):#区間(a,b]にxを加算
#print(a,b,x)
while b!=0:
ADD[to_seg(b)]+=x
update(to_seg(b))
b-=(b&(-b))
while a!=0:
ADD[to_seg(a)]+=-x
update(to_seg(a))
a-=(a&(-a))
for i in range(N+2):
for b,k in end[i]:
add(b,i,k)#点数がもらえる区間から出たときにその分を加算
SEG[i+seg_el-1]=SEG[0]
update(i+seg_el-1)
print((SEG[0])) | p03182 |
class StarrySkyTree:
def __init__(self,param,default,func):
if isinstance(param,list):
num=len(param)
else:
num=param
leaf=1<<(num-1).bit_length()
self.leaf=leaf
self.d=default
if isinstance(param,list):
self.data=[default]*(leaf-1)+param+[default]*(leaf-num+1)
for i in range(self.leaf-2,-1,-1):
self.data[i]=func(self.data[i*2],self.data[i*2+1])
else:
self.data=[default]*leaf*2
self.lazy=[0]*leaf*2
self.f=func
def merge(self,a,b):
return self.f(a,b)
def indices(self,l,r):
L,R=l+self.leaf,r+self.leaf
lm=(L//(L&-L))>>1
rm=(R//(R&-R))>>1
while L<R:
if R<=rm:
yield R
if L<=lm:
yield L
L>>=1; R>>=1
while L:
yield L
L>>=1
def _propagates(self,*ids):
for i in reversed(ids):
v=self.lazy[i-1]
if v==0:
continue
self.lazy[2*i-1]+=v; self.lazy[2*i]+=v
self.data[2*i-1]+=v; self.data[2*i]+=v
self.lazy[i-1]=0
def add(self,l,r,x):
*ids,=self.indices(l,r)
self._propagates(*ids)
L,R=l+self.leaf,r+self.leaf
while L<R:
if L&1:
self.lazy[L-1]+=x; self.data[L-1]+=x
L+=1
if R&1:
R-=1
self.lazy[R-1]+=x; self.data[R-1]+=x
L>>=1; R>>=1
for i in ids:
self.data[i-1]=self.merge(self.data[2*i-1],self.data[2*i])
def query(self,l,r):
self._propagates(*self.indices(l,r))
L,R=l+self.leaf,r+self.leaf
ret=self.d
while L<R:
if L&1:
ret=self.merge(ret,self.data[L-1])
L+=1
if R&1:
R-=1
ret=self.merge(ret,self.data[R-1])
L>>=1; R>>=1
return ret
import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
def f(a,b):
return max(a,b)
sst=StarrySkyTree(n+1,0,f)
R=[[] for _ in range(n+1)]
for _ in range(m):
l,r,a=list(map(int,input().split()))
R[r].append((l,a))
for i in range(1,n+1):
v=sst.query(0,i)
sst.add(i,i+1,v)
for l,a in R[i]:
sst.add(l,i+1,a)
print((sst.query(0,n+1))) | class StarrySkyTree:
def __init__(self,num):
leaf=1<<(num-1).bit_length()
self.leaf=leaf
self.data=[0]*leaf*2
self.lazy=[0]*leaf*2
def indices(self,l,r):
L,R=l+self.leaf,r+self.leaf
lm=(L//(L&-L))>>1
rm=(R//(R&-R))>>1
while L<R:
if R<=rm:
yield R
if L<=lm:
yield L
L>>=1; R>>=1
while L:
yield L
L>>=1
def _propagates(self,*ids):
for i in reversed(ids):
v=self.lazy[i-1]
if v==0:
continue
self.lazy[2*i-1]+=v; self.lazy[2*i]+=v
self.data[2*i-1]+=v; self.data[2*i]+=v
self.lazy[i-1]=0
def add(self,l,r,x):
L,R=l+self.leaf,r+self.leaf
while L<R:
if L&1:
self.lazy[L-1]+=x; self.data[L-1]+=x
L+=1
if R&1:
R-=1
self.lazy[R-1]+=x; self.data[R-1]+=x
L>>=1; R>>=1
for i in self.indices(l,r):
self.data[i-1]=max(self.data[2*i-1],self.data[2*i])+self.lazy[i-1]
def query(self,l,r):
self._propagates(*self.indices(l,r))
L,R=l+self.leaf,r+self.leaf
ret=0
while L<R:
if L&1:
ret=max(ret,self.data[L-1])
L+=1
if R&1:
R-=1
ret=max(ret,self.data[R-1])
L>>=1; R>>=1
return ret
import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
sst=StarrySkyTree(n+1)
R=[[] for _ in range(n+1)]
for _ in range(m):
l,r,a=list(map(int,input().split()))
R[r].append((l,a))
for i in range(1,n+1):
v=sst.query(0,i)
sst.add(i,i+1,v)
for l,a in R[i]:
sst.add(l,i+1,a)
print((sst.query(0,n+1))) | p03182 |
class StarrySkyTree:
def __init__(self,num):
leaf=1<<(num-1).bit_length()
self.leaf=leaf
self.data=[0]*leaf*2
self.lazy=[0]*leaf*2
zero_indices=[]
for i in range(num+1):
tmp=[]
i+=self.leaf
limit=(i//(i&-i))>>1
while i:
if i<=limit:
tmp.append(i)
i>>=1
zero_indices.append(tmp)
self.zero_indices=zero_indices
def indices(self,l,r):
L,R=l+self.leaf,r+self.leaf
lm=(L//(L&-L))>>1
rm=(R//(R&-R))>>1
while L<R:
if R<=rm:
yield R
if L<=lm:
yield L
L>>=1; R>>=1
while L:
yield L
L>>=1
def zeroindices(self,k):
K=k+self.leaf
limit=(K//(K&-K))>>1
while K:
if K<=limit:
yield K
K>>=1
def _propagates(self,*ids):
for i in reversed(ids):
v=self.lazy[i-1]
if v==0:
continue
self.lazy[2*i-1]+=v; self.lazy[2*i]+=v
self.data[2*i-1]+=v; self.data[2*i]+=v
self.lazy[i-1]=0
def add(self,l,r,x):
L,R=l+self.leaf,r+self.leaf
while L<R:
if L&1:
self.lazy[L-1]+=x; self.data[L-1]+=x
L+=1
if R&1:
R-=1
self.lazy[R-1]+=x; self.data[R-1]+=x
L>>=1; R>>=1
for i in self.indices(l,r):
self.data[i-1]=max(self.data[2*i-1],self.data[2*i])+self.lazy[i-1]
def add1(self,k,x):
k+=self.leaf
self.data[k-1]+=x
while k:
k>>=1
self.data[k-1]=max(self.data[2*k-1],self.data[2*k])+self.lazy[k-1]
def query0(self,k):
self._propagates(*self.zeroindices(k))
L,R=self.leaf,k+self.leaf
ret=0
while L<R:
if L&1:
ret=max(ret,self.data[L-1])
L+=1
if R&1:
R-=1
ret=max(ret,self.data[R-1])
L>>=1; R>>=1
return ret
import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
sst=StarrySkyTree(n+1)
R=[[] for _ in range(n+1)]
for _ in range(m):
l,r,a=list(map(int,input().split()))
R[r].append((l,a))
for i in range(1,n+1):
v=sst.query0(i)
sst.add1(i,v)
for l,a in R[i]:
sst.add(l,i+1,a)
print((sst.query0(n+1))) | class StarrySkyTree:
def __init__(self,num):
leaf=1<<(num-1).bit_length()
self.leaf=leaf
self.data=[0]*leaf*2
self.lazy=[0]*leaf*2
def indices(self,l,r):
L,R=l+self.leaf,r+self.leaf
lm=(L//(L&-L))>>1
rm=(R//(R&-R))>>1
while L<R:
if R<=rm:
yield R
if L<=lm:
yield L
L>>=1; R>>=1
while L:
yield L
L>>=1
def zeroindices(self,k):
K=k+self.leaf
limit=(K//(K&-K))>>1
while K:
if K<=limit:
yield K
K>>=1
def _propagates(self,*ids):
for i in reversed(ids):
v=self.lazy[i-1]
if v==0:
continue
self.lazy[2*i-1]+=v; self.lazy[2*i]+=v
self.data[2*i-1]+=v; self.data[2*i]+=v
self.lazy[i-1]=0
def add(self,l,r,x):
L,R=l+self.leaf,r+self.leaf
while L<R:
if L&1:
self.lazy[L-1]+=x; self.data[L-1]+=x
L+=1
if R&1:
R-=1
self.lazy[R-1]+=x; self.data[R-1]+=x
L>>=1; R>>=1
for i in self.indices(l,r):
self.data[i-1]=max(self.data[2*i-1],self.data[2*i])+self.lazy[i-1]
def add1(self,k,x): #add[k,k+1)
k+=self.leaf
self.data[k-1]+=x
while k:
k>>=1
self.data[k-1]=max(self.data[2*k-1],self.data[2*k])+self.lazy[k-1]
def query(self,l,r): #[l,r)
self._propagates(*self.indices(l,r))
L,R=l+self.leaf,r+self.leaf
ret=0
while L<R:
if L&1:
ret=max(ret,self.data[L-1])
L+=1
if R&1:
R-=1
ret=max(ret,self.data[R-1])
L>>=1; R>>=1
return ret
def query0(self,k):
self._propagates(*self.zeroindices(k))
L,R=self.leaf,k+self.leaf
ret=0
while L<R:
if L&1:
ret=max(ret,self.data[L-1])
L+=1
if R&1:
R-=1
ret=max(ret,self.data[R-1])
L>>=1; R>>=1
return ret
import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
sst=StarrySkyTree(n+1)
R=[[] for _ in range(n+1)]
for _ in range(m):
l,r,a=list(map(int,input().split()))
R[r].append((l,a))
for i in range(1,n+1):
v=sst.query0(i)
sst.add1(i,v)
for l,a in R[i]:
sst.add(l,i+1,a)
print((sst.query0(n+1))) | p03182 |
class StarrySkyTree:
def __init__(self,num,default,func):
leaf=1<<(num-1).bit_length()
self.leaf=leaf
self.d=default
self.data=[default]*leaf*2
self.lazy=[0]*leaf*2
self.f=func
def merge(self,a,b):
return self.f(a,b)
def indices(self,l,r):
L,R=l+self.leaf,r+self.leaf
lm=(L//(L&-L))>>1
rm=(R//(R&-R))>>1
while L<R:
if R<=rm:
yield R
if L<=lm:
yield L
L>>=1; R>>=1
while L:
yield L
L>>=1
def zeroindices(self,k):
K=k+self.leaf
limit=(K//(K&-K))>>1
while K:
if K<=limit:
yield K
K>>=1
def _propagates(self,*ids):
for i in reversed(ids):
v=self.lazy[i-1]
if v==0:
continue
self.lazy[2*i-1]+=v; self.lazy[2*i]+=v
self.data[2*i-1]+=v; self.data[2*i]+=v
self.lazy[i-1]=0
def add(self,l,r,x):
L,R=l+self.leaf,r+self.leaf
while L<R:
if L&1:
self.lazy[L-1]+=x; self.data[L-1]+=x
L+=1
if R&1:
R-=1
self.lazy[R-1]+=x; self.data[R-1]+=x
L>>=1; R>>=1
for i in self.indices(l,r):
self.data[i-1]=self.merge(self.data[2*i-1],self.data[2*i])+self.lazy[i-1]
def add1(self,k,x):
k+=self.leaf
self.data[k-1]+=x
while k:
k>>=1
self.data[k-1]=self.merge(self.data[2*k-1],self.data[2*k])+self.lazy[k-1]
def query0(self,k):
self._propagates(*self.zeroindices(k))
L,R=self.leaf,k+self.leaf
ret=0
while L<R:
if L&1:
ret=self.merge(ret,self.data[L-1])
L+=1
if R&1:
R-=1
ret=self.merge(ret,self.data[R-1])
L>>=1; R>>=1
return ret
import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
def f(a,b):
return max(a,b)
sst=StarrySkyTree(n+1,0,f)
R=[[] for _ in range(n+1)]
for _ in range(m):
l,r,a=list(map(int,input().split()))
R[r].append((l,a))
for i in range(1,n+1):
v=sst.query0(i)
sst.add1(i,v)
for l,a in R[i]:
sst.add(l,i+1,a)
print((sst.query0(n+1))) | class StarrySkyTree:
def __init__(self,num):
leaf=1<<(num-1).bit_length()
self.leaf=leaf
self.data=[0]*leaf*2
self.lazy=[0]*leaf*2
def indices(self,l,r):
L,R=l+self.leaf,r+self.leaf
lm=(L//(L&-L))>>1
rm=(R//(R&-R))>>1
while L<R:
if R<=rm:
yield R
if L<=lm:
yield L
L>>=1; R>>=1
while L:
yield L
L>>=1
def zeroindices(self,k):
K=k+self.leaf
limit=(K//(K&-K))>>1
while K:
if K<=limit:
yield K
K>>=1
def _propagates(self,*ids):
for i in reversed(ids):
v=self.lazy[i-1]
if v==0:
continue
self.lazy[2*i-1]+=v; self.lazy[2*i]+=v
self.data[2*i-1]+=v; self.data[2*i]+=v
self.lazy[i-1]=0
def add(self,l,r,x):
L,R=l+self.leaf,r+self.leaf
while L<R:
if L&1:
self.lazy[L-1]+=x; self.data[L-1]+=x
L+=1
if R&1:
R-=1
self.lazy[R-1]+=x; self.data[R-1]+=x
L>>=1; R>>=1
for i in self.indices(l,r):
self.data[i-1]=max(self.data[2*i-1],self.data[2*i])+self.lazy[i-1]
def add1(self,k,x):
k+=self.leaf
self.data[k-1]+=x
while k:
k>>=1
self.data[k-1]=max(self.data[2*k-1],self.data[2*k])+self.lazy[k-1]
def query0(self,k):
self._propagates(*self.zeroindices(k))
L,R=self.leaf,k+self.leaf
ret=0
while L<R:
if L&1:
ret=max(ret,self.data[L-1])
L+=1
if R&1:
R-=1
ret=max(ret,self.data[R-1])
L>>=1; R>>=1
return ret
import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
sst=StarrySkyTree(n+1)
R=[[] for _ in range(n+1)]
for _ in range(m):
l,r,a=list(map(int,input().split()))
R[r].append((l,a))
for i in range(1,n+1):
v=sst.query0(i)
sst.add1(i,v)
for l,a in R[i]:
sst.add(l,i+1,a)
print((sst.query0(n+1))) | p03182 |
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
class RAQ_RMQ:
def __init__(self, n, a=None, F=min, e=float("inf")):
self.n = n
self.n0 = 2**(n-1).bit_length()
self.e = e
self.F = F
self.lazy = [0]*(2*self.n0)
if a is None:
self.data = [e]*(2*self.n0)
else:
self.data = [0]*(2*self.n0)
self.construct(a)
def construct(self, a):
for i, x in enumerate(a):
self.data[i+self.n0] = x
for i in range(self.n0-1, 0, -1):
self.data[i] = self.F(self.data[2*i], self.data[2*i+1])
def bottomup(self, i):
i += self.n0
k = i//(i & -i)
c = k.bit_length()
for j in range(c-1):
k >>= 1
self.data[k] = self.F(self.data[2*k], self.data[2*k+1]) + self.lazy[k]
def topdown(self, i):
i += self.n0
k = i//(i & -i)
c = k.bit_length()
for j in range(c-1):
idx = k >> (c - j - 1)
ax = self.lazy[idx]
if not ax:
continue
self.lazy[idx] = 0
self.data[2*idx] += ax
self.data[2*idx+1] += ax
self.lazy[2*idx] += ax
self.lazy[2*idx+1] += ax
def query(self, l, r):
self.topdown(l)
self.topdown(r)
L = l+self.n0
R = r+self.n0
s = self.e
while L < R:
if R & 1:
R -= 1
s = self.F(s, self.data[R])
if L & 1:
s = self.F(s, self.data[L])
L += 1
L >>= 1
R >>= 1
return s
def add(self, l, r, x):
L = l+self.n0
R = r+self.n0
while L < R :
if R & 1:
R -= 1
self.data[R] += x
self.lazy[R] += x
if L & 1:
self.data[L] += x
self.lazy[L] += x
L += 1
L >>= 1
R >>= 1
self.bottomup(l)
self.bottomup(r)
n,m = list(map(int, input().split()))
memo = [[] for i in range(n+2)]
for i in range(m):
l,r,a = list(map(int, input().split()))
memo[l].append((l,a))
memo[r+1].append((l,-a))
seg = RAQ_RMQ(n+2, a=[0]*(n+2), F=max, e=-float("inf"))
for i in range(1, n+2):
for j, a in memo[i]:
seg.add(0, j, a)
tmp = seg.query(0, i)
seg.add(i, i+1, tmp)
ans = seg.query(0, n+1)
print(ans) | import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
class RAQ_RMQ:
def __init__(self, n, F=min, e=float("inf"), fill=None):
self.n = n
self.n0 = 2**(n-1).bit_length()
self.e = e
self.F = F
self.lazy = [0]*(2*self.n0)
if fill is None:
fill = e
self.data = [fill]*(2*self.n0)
def construct(self, a):
for i, x in enumerate(a):
self.data[i+self.n0] = x
for i in range(self.n0-1, 0, -1):
self.data[i] = self.F(self.data[2*i], self.data[2*i+1])
def bottomup(self, i):
i += self.n0
k = i//(i & -i)
c = k.bit_length()
for j in range(c-1):
k >>= 1
self.data[k] = self.F(self.data[2*k], self.data[2*k+1]) + self.lazy[k]
def topdown(self, i):
i += self.n0
k = i//(i & -i)
c = k.bit_length()
for j in range(c-1):
idx = k >> (c - j - 1)
ax = self.lazy[idx]
if not ax:
continue
self.lazy[idx] = 0
self.data[2*idx] += ax
self.data[2*idx+1] += ax
self.lazy[2*idx] += ax
self.lazy[2*idx+1] += ax
def query(self, l, r):
self.topdown(l)
self.topdown(r)
L = l+self.n0
R = r+self.n0
s = self.e
while L < R:
if R & 1:
R -= 1
s = self.F(s, self.data[R])
if L & 1:
s = self.F(s, self.data[L])
L += 1
L >>= 1
R >>= 1
return s
def add(self, l, r, x):
L = l+self.n0
R = r+self.n0
while L < R :
if R & 1:
R -= 1
self.data[R] += x
self.lazy[R] += x
if L & 1:
self.data[L] += x
self.lazy[L] += x
L += 1
L >>= 1
R >>= 1
self.bottomup(l)
self.bottomup(r)
n,m = list(map(int, input().split()))
memo = [[] for i in range(n+2)]
for i in range(m):
l,r,a = list(map(int, input().split()))
memo[l].append((l,a))
memo[r+1].append((l,-a))
seg = RAQ_RMQ(n+2, F=max, e=-float("inf"), fill=0)
for i in range(1, n+2):
for j, a in memo[i]:
seg.add(0, j, a)
tmp = seg.query(0, i)
seg.add(i, i+1, tmp)
ans = seg.query(0, n+1)
print(ans) | p03182 |
"""
遅延セグメント木（区間演算、区間更新）
dat[] の要素に モノイド M をもつ
laz[] の要素に Aut(M) をもつ（ただし作用素は「右」から作用とする）
アクセスは0-indexed, 内部のツリーは 1-indexed（つまりすべての和は tree[1]）
関数は閉区間
引数：
N: 処理する区間の長さ
op_M = operator: モノイド演算 (max, min, __add__,ラムダ式,関数定義など)
e_M: 単位元
compose: 作用素を合成させる関数 (max, min, __add__,ラムダ式,関数定義など)
funcval(x,f) = f(x) 関数適用
ID_M: 恒等作用素
"""
""" 作用素の例：
f \mapsto min(f,-)
compose = min
funcval = min
ID_M = INF = 10**18
f \mapsto max(f,-)
compose = max
funcval = max
ID_M = 0
f \mapsto f (定数関数)（区間代入、最後の操作のみが影響する）
compose = lambda f,g: (f if g == ID_M else g)
funcval = lambda x,f: (x if f == ID_M else f)
ID_M = None #Noneではなく、範囲外の数にすると速くなる
"""
class lazy_segment_tree:
def __init__(self, N, operator_M, e_M, compose, funcval, ID_M=None):
self.compose = compose #作用素の合成（右から）
self.ID_M = ID_M #恒等作用素
self.funcval = funcval #関数適用
self.op_M = operator_M # Mの演算
self.e_M = e_M # Mの単位元
####################################
self.height = (N-1).bit_length() #木の段数
self.N0 = N0 = 1<<self.height #木の横幅 >= N
self.dat = [self.e_M]*(2*N0) #データの木
self.laz = [self.ID_M]*(2*N0) #作用素の木
"""
length = [N0>>1]*N0
for i in range(2,N0): length[i] = length[i>>1]>>1
self.length = length #区間の長さ
"""
# 長さNの配列 initial で dat を初期化
def build(self, initial):
self.dat[self.N0:self.N0+len(initial)] = initial[:]
for k in range(self.N0-1,0,-1):
self.dat[k] = self.op_M(self.dat[2*k], self.dat[2*k+1])
# dat[k] に laz[k] を適用して、laz[k] を伝播
def propagate(self,k):
if self.laz[k] == self.ID_M: return;
self.dat[k] = self.reflect(k)
if self.N0 <= k:
self.laz[k] = self.ID_M
return
else:
self.laz[2*k ] = self.compose(self.laz[2*k ],self.laz[k])
self.laz[2*k+1] = self.compose(self.laz[2*k+1],self.laz[k])
self.laz[k] = self.ID_M
return
# 遅延をすべて解消する
def propagate_all(self):
for i in range(1,2*self.N0): self.propagate(i)
# laz[k]およびその上に位置する作用素をすべて伝播
def thrust(self,k):
for i in range(self.height,-1,-1): self.propagate(k>>i)
def thrust2(self,L,R):
for i in range(self.height,0,-1):
self.propagate(L>>i)
if (L>>i) != R>>i:
self.propagate(R>>i)
# 区間[l,r]に関数 f を作用
def update(self, l,r,f):
l += self.N0; r += self.N0
#まず伝播させる
#self.thrust(l>>1); self.thrust(r>>1)
self.thrust2(l,r)
L = l; R = r+1
#[l.r]に対応する区間たちに関数 f を適用
while L < R:
if R & 1:
R -= 1
self.laz[R] = self.compose(self.laz[R], f)
if L & 1:
self.laz[L] = self.compose(self.laz[L], f)
L += 1
L >>= 1; R >>= 1
# 再計算
#self.recalc_dat(l); self.recalc_dat(r)
self.recalc_dat2(l,r)
def reflect(self,k):
if self.laz[k] == self.ID_M: return self.dat[k]
else: return self.funcval(self.dat[k],self.laz[k])
# dat[k] を更新したときに上部を再計算
def recalc_dat(self,k):
k //= 2
while k:
self.dat[k] = self.op_M(self.funcval(self.dat[2*k],self.laz[2*k]),self.funcval(self.dat[2*k+1],self.laz[2*k+1]))
#self.dat[k] = self.op_M(self.reflect(2*k),self.reflect(2*k+1)))
k //= 2
def recalc_dat2(self,l,r):
l //= 2; r //= 2
while l:
#self.dat[l] = self.op_M(self.reflect(2*l),self.reflect(2*l+1))
self.dat[l] = self.op_M(self.funcval(self.dat[2*l],self.laz[2*l]),self.funcval(self.dat[2*l+1],self.laz[2*l+1]))
if l != r:
#self.dat[r] = self.op_M(self.reflect(2*r),self.reflect(2*r+1))
self.dat[r] = self.op_M(self.funcval(self.dat[2*r],self.laz[2*r]),self.funcval(self.dat[2*r+1],self.laz[2*r+1]))
l //= 2; r //= 2
# val[k] を取得。
def point_get(self, k):
k += self.N0
res = self.dat[k]
while k:
if self.laz[k] != self.ID_M:
res = self.funcval(res, self.laz[k])
k //= 2
return res
# values[k] = x 代入する
def point_set(self, k,x):
k += self.N0
self.thrust(k)
self.dat[k] = x
self.recalc_dat(k)
# 区間[L,R]をopでまとめる
def query(self, L,R):
L += self.N0; R += self.N0 + 1
self.thrust2(L,R)
#self.thrust(L); self.thrust(R-1)
sl = sr = self.e_M
while L < R:
if R & 1:
R -= 1
sr = self.op_M(self.reflect(R),sr)
if L & 1:
sl = self.op_M(sl,self.reflect(L))
L += 1
L >>= 1; R >>= 1
return self.op_M(sl,sr)
###########################################################################
###########################################################################
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.buffer.readline
n,m = [int(i) for i in readline().split()]
lra = [tuple(int(i) for i in readline().split()) for _ in range(m)]
from operator import add, itemgetter
operator_M = max
compose = add
funcval = add
ID_M = 0
e_M = -10**18
seg = lazy_segment_tree(n+1, operator_M, e_M, compose, funcval, ID_M)
seg.build([0]+[ID_M]*(n))
#seg.build([0]*n)
ans = []
lra.sort(key = itemgetter(1))
j = 0
for i in range(1,n+1):
#print(seg.laz,seg.dat,i,seg.query(0,i-1))
seg.point_set(i,seg.query(0,i-1))
while j < m and i == lra[j][1]:
#print("hoge")
seg.update(lra[j][0],lra[j][1],lra[j][2])
j += 1
seg.propagate_all()
print((max(seg.dat[seg.N0:seg.N0+n+1])))
#print(seg.laz,seg.dat)
| """
遅延セグメント木（区間演算、区間更新）
dat[] の要素に モノイド M をもつ
laz[] の要素に Aut(M) をもつ（ただし作用素は「右」から作用とする）
アクセスは0-indexed, 内部のツリーは 1-indexed（つまりすべての和は tree[1]）
関数は閉区間
引数：
N: 処理する区間の長さ
op_M = operator: モノイド演算 (max, min, __add__,ラムダ式,関数定義など)
e_M: 単位元
compose: 作用素を合成させる関数 (max, min, __add__,ラムダ式,関数定義など)
funcval(x,f) = f(x) 関数適用
ID_M: 恒等作用素
"""
""" 作用素の例：
f \mapsto min(f,-)
compose = min
funcval = min
ID_M = INF = 10**18
f \mapsto max(f,-)
compose = max
funcval = max
ID_M = 0
f \mapsto f (定数関数)（区間代入、最後の操作のみが影響する）
compose = lambda f,g: (f if g == ID_M else g)
funcval = lambda x,f: (x if f == ID_M else f)
ID_M = None #Noneではなく、範囲外の数にすると速くなる
"""
class lazy_segment_tree:
def __init__(self, N, operator_M, e_M, compose, funcval, ID_M=None):
self.compose = compose #作用素の合成（右から）
self.ID_M = ID_M #恒等作用素
self.funcval = funcval #関数適用
self.op_M = operator_M # Mの演算
self.e_M = e_M # Mの単位元
####################################
self.height = (N-1).bit_length() #木の段数
self.N0 = N0 = 1<<self.height #木の横幅 >= N
self.dat = [self.e_M]*(2*N0) #データの木
self.laz = [self.ID_M]*(2*N0) #作用素の木
"""
length = [N0>>1]*N0
for i in range(2,N0): length[i] = length[i>>1]>>1
self.length = length #区間の長さ
"""
# 長さNの配列 initial で dat を初期化
def build(self, initial):
self.dat[self.N0:self.N0+len(initial)] = initial[:]
for k in range(self.N0-1,0,-1):
self.dat[k] = self.op_M(self.dat[2*k], self.dat[2*k+1])
# dat[k] に laz[k] を適用して、laz[k] を伝播
def propagate(self,k):
if self.laz[k] == self.ID_M: return;
self.dat[k] = self.reflect(k)
if self.N0 <= k:
self.laz[k] = self.ID_M
return
else:
self.laz[2*k ] = self.compose(self.laz[2*k ],self.laz[k])
self.laz[2*k+1] = self.compose(self.laz[2*k+1],self.laz[k])
self.laz[k] = self.ID_M
return
# 遅延をすべて解消する
def propagate_all(self):
for i in range(1,2*self.N0): self.propagate(i)
# laz[k]およびその上に位置する作用素をすべて伝播
def thrust(self,k):
for i in range(self.height,-1,-1): self.propagate(k>>i)
def thrust2(self,L,R):
for i in range(self.height,0,-1):
self.propagate(L>>i)
if (L>>i) != R>>i:
self.propagate(R>>i)
# 区間[l,r]に関数 f を作用
def update(self, l,r,f):
l += self.N0; r += self.N0
#まず伝播させる
#self.thrust(l>>1); self.thrust(r>>1)
self.thrust2(l,r)
L = l; R = r+1
#[l.r]に対応する区間たちに関数 f を適用
while L < R:
if R & 1:
R -= 1
self.laz[R] = self.compose(self.laz[R], f)
if L & 1:
self.laz[L] = self.compose(self.laz[L], f)
L += 1
L >>= 1; R >>= 1
# 再計算
#self.recalc_dat(l); self.recalc_dat(r)
self.recalc_dat2(l,r)
def reflect(self,k):
if self.laz[k] == self.ID_M: return self.dat[k]
else: return self.funcval(self.dat[k],self.laz[k])
# dat[k] を更新したときに上部を再計算
def recalc_dat(self,k):
k //= 2
while k:
self.dat[k] = self.op_M(self.funcval(self.dat[2*k],self.laz[2*k]),self.funcval(self.dat[2*k+1],self.laz[2*k+1]))
#self.dat[k] = self.op_M(self.reflect(2*k),self.reflect(2*k+1)))
k //= 2
def recalc_dat2(self,l,r):
l //= 2; r //= 2
while l:
#self.dat[l] = self.op_M(self.reflect(2*l),self.reflect(2*l+1))
self.dat[l] = self.op_M(self.funcval(self.dat[2*l],self.laz[2*l]),self.funcval(self.dat[2*l+1],self.laz[2*l+1]))
if l != r:
#self.dat[r] = self.op_M(self.reflect(2*r),self.reflect(2*r+1))
self.dat[r] = self.op_M(self.funcval(self.dat[2*r],self.laz[2*r]),self.funcval(self.dat[2*r+1],self.laz[2*r+1]))
l //= 2; r //= 2
# val[k] を取得。
def point_get(self, k):
k += self.N0
res = self.dat[k]
while k:
if self.laz[k] != self.ID_M:
res = self.funcval(res, self.laz[k])
k //= 2
return res
# values[k] = x 代入する
def point_set(self, k,x):
k += self.N0
#self.thrust(k)
self.dat[k] = x
self.recalc_dat(k)
# 区間[L,R]をopでまとめる
def query(self, L,R):
L += self.N0; R += self.N0 + 1
self.thrust2(L,R)
#self.thrust(L); self.thrust(R-1)
sl = sr = self.e_M
while L < R:
if R & 1:
R -= 1
sr = self.op_M(self.reflect(R),sr)
if L & 1:
sl = self.op_M(sl,self.reflect(L))
L += 1
L >>= 1; R >>= 1
return self.op_M(sl,sr)
###########################################################################
###########################################################################
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.buffer.readline
n,m = [int(i) for i in readline().split()]
lra = [tuple(int(i) for i in readline().split()) for _ in range(m)]
from operator import add, itemgetter
operator_M = max
compose = add
funcval = add
ID_M = 0
e_M = -10**18
seg = lazy_segment_tree(n+1, operator_M, e_M, compose, funcval, ID_M)
seg.build([0]+[ID_M]*(n))
#seg.build([0]*n)
ans = []
lra.sort(key = itemgetter(1))
j = 0
for i in range(1,n+1):
#print(seg.laz,seg.dat,i,seg.query(0,i-1))
seg.point_set(i,seg.query(0,i-1))
while j < m and i == lra[j][1]:
#print("hoge")
seg.update(lra[j][0],lra[j][1],lra[j][2])
j += 1
seg.propagate_all()
print((max(seg.dat[seg.N0:seg.N0+n+1])))
#print(seg.laz,seg.dat)
| p03182 |
"""
遅延セグメント木（区間演算、区間更新）
dat[] の要素に モノイド M をもつ
laz[] の要素に Aut(M) をもつ（ただし作用素は「右」から作用とする）
アクセスは0-indexed, 内部のツリーは 1-indexed（つまりすべての和は tree[1]）
関数は閉区間
引数：
N: 処理する区間の長さ
op_M = operator: モノイド演算 (max, min, __add__,ラムダ式,関数定義など)
e_M: 単位元
compose: 作用素を合成させる関数 (max, min, __add__,ラムダ式,関数定義など)
funcval(x,f) = f(x) 関数適用
ID_M: 恒等作用素
"""
""" 作用素の例：
f \mapsto min(f,-)
compose = min
funcval = min
ID_M = INF = 10**18
f \mapsto max(f,-)
compose = max
funcval = max
ID_M = 0
f \mapsto f (定数関数)（区間代入、最後の操作のみが影響する）
compose = lambda f,g: (f if g == ID_M else g)
funcval = lambda x,f: (x if f == ID_M else f)
ID_M = None #Noneではなく、範囲外の数にすると速くなる
"""
class lazy_segment_tree:
def __init__(self, N, operator_M, e_M, compose, funcval, ID_M=None):
self.compose = compose #作用素の合成（右から）
self.ID_M = ID_M #恒等作用素
self.funcval = funcval #関数適用
self.op_M = operator_M # Mの演算
self.e_M = e_M # Mの単位元
####################################
self.height = (N-1).bit_length() #木の段数
self.N0 = N0 = 1<<self.height #木の横幅 >= N
self.dat = [self.e_M]*(2*N0) #データの木
self.laz = [self.ID_M]*(2*N0) #作用素の木
"""
length = [N0>>1]*N0
for i in range(2,N0): length[i] = length[i>>1]>>1
self.length = length #区間の長さ
"""
# 長さNの配列 initial で dat を初期化
def build(self, initial):
self.dat[self.N0:self.N0+len(initial)] = initial[:]
for k in range(self.N0-1,0,-1):
self.dat[k] = self.op_M(self.dat[2*k], self.dat[2*k+1])
# dat[k] に laz[k] を適用して、laz[k] を伝播
def propagate(self,k):
if self.laz[k] == self.ID_M: return;
self.dat[k] = self.reflect(k)
if self.N0 <= k:
self.laz[k] = self.ID_M
return
else:
self.laz[2*k ] = self.compose(self.laz[2*k ],self.laz[k])
self.laz[2*k+1] = self.compose(self.laz[2*k+1],self.laz[k])
self.laz[k] = self.ID_M
return
# 遅延をすべて解消する
def propagate_all(self):
for i in range(1,2*self.N0): self.propagate(i)
# laz[k]およびその上に位置する作用素をすべて伝播
def thrust(self,k):
for i in range(self.height,-1,-1): self.propagate(k>>i)
def thrust2(self,L,R):
for i in range(self.height,0,-1):
self.propagate(L>>i)
if (L>>i) != R>>i:
self.propagate(R>>i)
# 区間[l,r]に関数 f を作用
def update(self, l,r,f):
l += self.N0; r += self.N0
#まず伝播させる
#self.thrust(l>>1); self.thrust(r>>1)
self.thrust2(l,r)
L = l; R = r+1
#[l.r]に対応する区間たちに関数 f を適用
while L < R:
if R & 1:
R -= 1
self.laz[R] = self.compose(self.laz[R], f)
if L & 1:
self.laz[L] = self.compose(self.laz[L], f)
L += 1
L >>= 1; R >>= 1
# 再計算
#self.recalc_dat(l); self.recalc_dat(r)
self.recalc_dat2(l,r)
def reflect(self,k):
if self.laz[k] == self.ID_M: return self.dat[k]
else: return self.funcval(self.dat[k],self.laz[k])
# dat[k] を更新したときに上部を再計算
def recalc_dat(self,k):
k //= 2
while k:
self.dat[k] = self.op_M(self.funcval(self.dat[2*k],self.laz[2*k]),self.funcval(self.dat[2*k+1],self.laz[2*k+1]))
#self.dat[k] = self.op_M(self.reflect(2*k),self.reflect(2*k+1)))
k //= 2
def recalc_dat2(self,l,r):
l //= 2; r //= 2
while l:
#self.dat[l] = self.op_M(self.reflect(2*l),self.reflect(2*l+1))
self.dat[l] = self.op_M(self.funcval(self.dat[2*l],self.laz[2*l]),self.funcval(self.dat[2*l+1],self.laz[2*l+1]))
if l != r:
#self.dat[r] = self.op_M(self.reflect(2*r),self.reflect(2*r+1))
self.dat[r] = self.op_M(self.funcval(self.dat[2*r],self.laz[2*r]),self.funcval(self.dat[2*r+1],self.laz[2*r+1]))
l //= 2; r //= 2
# val[k] を取得。
def point_get(self, k):
k += self.N0
res = self.dat[k]
while k:
if self.laz[k] != self.ID_M:
res = self.funcval(res, self.laz[k])
k //= 2
return res
# values[k] = x 代入する
def point_set(self, k,x):
k += self.N0
self.thrust(k)
self.dat[k] = x
self.recalc_dat(k)
# 区間[L,R]をopでまとめる
def query(self, L,R):
L += self.N0; R += self.N0 + 1
self.thrust2(L,R)
#self.thrust(L); self.thrust(R-1)
sl = sr = self.e_M
while L < R:
if R & 1:
R -= 1
sr = self.op_M(self.reflect(R),sr)
if L & 1:
sl = self.op_M(sl,self.reflect(L))
L += 1
L >>= 1; R >>= 1
return self.op_M(sl,sr)
###########################################################################
###########################################################################
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.buffer.readline
n,m = [int(i) for i in readline().split()]
lra = [tuple(int(i) for i in readline().split()) for _ in range(m)]
from operator import add, itemgetter
operator_M = max
compose = add
funcval = add
ID_M = 0
e_M = -10**18
seg = lazy_segment_tree(n+1, operator_M, e_M, compose, funcval, ID_M)
seg.build([0]+[ID_M]*(n))
#seg.build([0]*n)
ans = []
lra.sort(key = itemgetter(1))
j = 0
"""
N0 = self.N0
self.thrust(k)
self.dat[k] = x
self.recalc_dat(k)
"""
N0 = seg.N0
for i in range(1,n+1):
#print(seg.laz,seg.dat,i,seg.query(0,i-1))
#seg.point_set(i,seg.query(0,i-1))
seg.dat[i+N0] = seg.query(0,i-1)
seg.recalc_dat(i+N0)
while j < m and i == lra[j][1]:
#print("hoge")
seg.update(*lra[j])#[0],lra[j][1],lra[j][2])
j += 1
seg.propagate_all()
print((max(seg.dat[seg.N0:seg.N0+n+1])))
#print(seg.laz,seg.dat)
| """
遅延セグメント木（区間演算、区間更新）
dat[] の要素に モノイド M をもつ
laz[] の要素に Aut(M) をもつ（ただし作用素は「右」から作用とする）
アクセスは0-indexed, 内部のツリーは 1-indexed（つまりすべての和は tree[1]）
関数は閉区間
引数：
N: 処理する区間の長さ
op_M = operator: モノイド演算 (max, min, __add__,ラムダ式,関数定義など)
e_M: 単位元
compose: 作用素を合成させる関数 (max, min, __add__,ラムダ式,関数定義など)
funcval(x,f) = f(x) 関数適用
ID_M: 恒等作用素
"""
""" 作用素の例：
f \mapsto min(f,-)
compose = min
funcval = min
ID_M = INF = 10**18
f \mapsto max(f,-)
compose = max
funcval = max
ID_M = 0
f \mapsto f (定数関数)（区間代入、最後の操作のみが影響する）
compose = lambda f,g: (f if g == ID_M else g)
funcval = lambda x,f: (x if f == ID_M else f)
ID_M = None #Noneではなく、範囲外の数にすると速くなる
"""
class lazy_segment_tree:
def __init__(self, N, operator_M, e_M, compose, funcval, ID_M=None):
self.compose = compose #作用素の合成（右から）
self.ID_M = ID_M #恒等作用素
self.funcval = funcval #関数適用
self.op_M = operator_M # Mの演算
self.e_M = e_M # Mの単位元
####################################
self.height = (N-1).bit_length() #木の段数
self.N0 = N0 = 1<<self.height #木の横幅 >= N
self.dat = [self.e_M]*(2*N0) #データの木
self.laz = [self.ID_M]*(2*N0) #作用素の木
"""
length = [N0>>1]*N0
for i in range(2,N0): length[i] = length[i>>1]>>1
self.length = length #区間の長さ
"""
# 長さNの配列 initial で dat を初期化
def build(self, initial):
self.dat[self.N0:self.N0+len(initial)] = initial[:]
for k in range(self.N0-1,0,-1):
self.dat[k] = self.op_M(self.dat[2*k], self.dat[2*k+1])
# dat[k] に laz[k] を適用して、laz[k] を伝播
def propagate(self,k):
if self.laz[k] == self.ID_M: return;
self.dat[k] = self.reflect(k)
if self.N0 <= k:
self.laz[k] = self.ID_M
return
else:
self.laz[2*k ] = self.compose(self.laz[2*k ],self.laz[k])
self.laz[2*k+1] = self.compose(self.laz[2*k+1],self.laz[k])
self.laz[k] = self.ID_M
return
# 遅延をすべて解消する
def propagate_all(self):
for i in range(1,2*self.N0): self.propagate(i)
# laz[k]およびその上に位置する作用素をすべて伝播
def thrust(self,k):
for i in range(self.height,-1,-1): self.propagate(k>>i)
def thrust2(self,L,R):
for i in range(self.height,0,-1):
self.propagate(L>>i)
if (L>>i) != R>>i:
self.propagate(R>>i)
# 区間[l,r]に関数 f を作用
def update(self, l,r,f):
l += self.N0; r += self.N0
#まず伝播させる
#self.thrust(l>>1); self.thrust(r>>1)
#self.thrust2(l,r)
L = l; R = r+1
#[l.r]に対応する区間たちに関数 f を適用
while L < R:
if R & 1:
R -= 1
self.laz[R] = self.compose(self.laz[R], f)
if L & 1:
self.laz[L] = self.compose(self.laz[L], f)
L += 1
L >>= 1; R >>= 1
# 再計算
#self.recalc_dat(l); self.recalc_dat(r)
self.recalc_dat2(l,r)
def reflect(self,k):
if self.laz[k] == self.ID_M: return self.dat[k]
else: return self.funcval(self.dat[k],self.laz[k])
# dat[k] を更新したときに上部を再計算
def recalc_dat(self,k):
k //= 2
while k:
self.dat[k] = self.op_M(self.funcval(self.dat[2*k],self.laz[2*k]),self.funcval(self.dat[2*k+1],self.laz[2*k+1]))
#self.dat[k] = self.op_M(self.reflect(2*k),self.reflect(2*k+1)))
k //= 2
def recalc_dat2(self,l,r):
l //= 2; r //= 2
while l:
#self.dat[l] = self.op_M(self.reflect(2*l),self.reflect(2*l+1))
self.dat[l] = self.op_M(self.funcval(self.dat[2*l],self.laz[2*l]),self.funcval(self.dat[2*l+1],self.laz[2*l+1]))
if l != r:
#self.dat[r] = self.op_M(self.reflect(2*r),self.reflect(2*r+1))
self.dat[r] = self.op_M(self.funcval(self.dat[2*r],self.laz[2*r]),self.funcval(self.dat[2*r+1],self.laz[2*r+1]))
l //= 2; r //= 2
# val[k] を取得。
def point_get(self, k):
k += self.N0
res = self.dat[k]
while k:
if self.laz[k] != self.ID_M:
res = self.funcval(res, self.laz[k])
k //= 2
return res
# values[k] = x 代入する
def point_set(self, k,x):
k += self.N0
self.thrust(k)
self.dat[k] = x
self.recalc_dat(k)
# 区間[L,R]をopでまとめる
def query(self, L,R):
L += self.N0; R += self.N0 + 1
self.thrust2(L,R)
#self.thrust(L); self.thrust(R-1)
sl = sr = self.e_M
while L < R:
if R & 1:
R -= 1
sr = self.op_M(self.reflect(R),sr)
if L & 1:
sl = self.op_M(sl,self.reflect(L))
L += 1
L >>= 1; R >>= 1
return self.op_M(sl,sr)
###########################################################################
###########################################################################
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.buffer.readline
n,m = [int(i) for i in readline().split()]
lra = [tuple(int(i) for i in readline().split()) for _ in range(m)]
from operator import add, itemgetter
operator_M = max
compose = add
funcval = add
ID_M = 0
e_M = -10**18
seg = lazy_segment_tree(n+1, operator_M, e_M, compose, funcval, ID_M)
seg.build([0]+[ID_M]*(n))
#seg.build([0]*n)
ans = []
lra.sort(key = itemgetter(1))
j = 0
"""
N0 = self.N0
self.thrust(k)
self.dat[k] = x
self.recalc_dat(k)
"""
N0 = seg.N0
for i in range(1,n+1):
#print(seg.laz,seg.dat,i,seg.query(0,i-1))
#seg.point_set(i,seg.query(0,i-1))
seg.dat[i+N0] = seg.query(0,i-1)
seg.recalc_dat(i+N0)
while j < m and i == lra[j][1]:
#print("hoge")
seg.update(*lra[j])#[0],lra[j][1],lra[j][2])
j += 1
seg.propagate_all()
print((max(seg.dat[seg.N0:seg.N0+n+1])))
#print(seg.laz,seg.dat)
| p03182 |
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
N0 = 2**N.bit_length()
LV = 2**N0
INF = 2**31-1
data = [0]*(2*N0)
lazy = [0]*(2*N0)
def gindex(l, r):
L = l + N0; R = r + N0
lm = (L // (L & -L)) >> 1
rm = (R // (R & -R)) >> 1
while L < R:
if R <= rm:
yield R
if L <= lm:
yield L
L >>= 1; R >>= 1
while L:
yield L
L >>= 1
def propagates(*ids):
for i in reversed(ids):
v = lazy[i-1]
if not v:
continue
lazy[2*i-1] += v; lazy[2*i] += v
data[2*i-1] += v; data[2*i] += v
lazy[i-1] = 0
def update(l, r, x):
# 2. 区間[l, r)のdata, lazyの値を更新
L = N0 + l; R = N0 + r
while L < R:
if R & 1:
R -= 1
lazy[R-1] += x; data[R-1] += x
if L & 1:
lazy[L-1] += x; data[L-1] += x
L += 1
L >>= 1; R >>= 1
# 3. 更新される区間を部分的に含んだ区間のdataの値を更新 (lazyの値を考慮)
for i in gindex(l, r):
data[i-1] = max(data[2*i-1], data[2*i]) + lazy[i-1]
def query(l, r):
# 1. トップダウンにlazyの値を伝搬
propagates(*gindex(l, r))
L = N0 + l; R = N0 + r
# 2. 区間[l, r)の最小値を求める
s = -INF
while L < R:
if R & 1:
R -= 1
s = max(s, data[R-1])
if L & 1:
s = max(s, data[L-1])
L += 1
L >>= 1; R >>= 1
return s
xs = [0]*(N+1)
ys = [[] for _ in range(N+1)]
for _ in range(M):
l, r, a = list(map(int, input().split()))
xs[l] += a
ys[r].append((l,a))
for i in range(1, N+1):
#[0,i)にxs[i]を加算
update(0,i,xs[i])
update(i, i+1, query(0, i)-query(i,i+1))
for l, a in ys[i]:
update(0, l, -a)
print((query(0,N+1)))
| import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
N0 = 2**((N+1).bit_length())
INF = 10**18
data = [0]*(2*N0)
lazy = [0]*(2*N0)
def gindex(l, r):
L = l + N0; R = r + N0
lm = (L // (L & -L)) >> 1
rm = (R // (R & -R)) >> 1
while L < R:
if R <= rm:
yield R
if L <= lm:
yield L
L >>= 1; R >>= 1
while L:
yield L
L >>= 1
def propagates(*ids):
for i in reversed(ids):
v = lazy[i-1]
if not v:
continue
lazy[2*i-1] += v; lazy[2*i] += v
data[2*i-1] += v; data[2*i] += v
lazy[i-1] = 0
def update(l, r, x):
L = N0 + l; R = N0 + r
while L < R:
if R & 1:
R -= 1
lazy[R-1] += x; data[R-1] += x
if L & 1:
lazy[L-1] += x; data[L-1] += x
L += 1
L >>= 1; R >>= 1
for i in gindex(l, r):
data[i-1] = max(data[2*i-1], data[2*i]) + lazy[i-1]
def update2(k, x):
k += N0-1
data[k] = x
while k >= 0:
k = (k - 1) // 2
data[k] = max(data[2*k+1], data[2*k+2])
def query(l, r):
propagates(*gindex(l, r))
L = N0 + l; R = N0 + r
s = -INF
while L < R:
if R & 1:
R -= 1
s = max(s, data[R-1])
if L & 1:
s = max(s, data[L-1])
L += 1
L >>= 1; R >>= 1
return s
xs = [0]*(N+1)
ys = [[] for _ in range(N+1)]
for _ in range(M):
l, r, a = list(map(int, input().split()))
xs[l] += a
ys[r].append((l,a))
rs = [0]*(N+1)
for i in range(1, N+1):
#[0,i)にxs[i]を加算
update(0,i,xs[i])
r = query(0, i)
update2(i, r)
rs[i] = r
for l, a in ys[i]:
update(0, l, -a)
print((max(rs)))
| p03182 |
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
N0 = 2**((N+1).bit_length())
INF = 10**18
data = [0]*(2*N0)
lazy = [0]*(2*N0)
def gindex(l, r):
L = l + N0; R = r + N0
lm = (L // (L & -L)) >> 1
rm = (R // (R & -R)) >> 1
while L < R:
if R <= rm:
yield R
if L <= lm:
yield L
L >>= 1; R >>= 1
while L:
yield L
L >>= 1
def propagates(*ids):
for i in reversed(ids):
v = lazy[i-1]
if not v:
continue
lazy[2*i-1] += v; lazy[2*i] += v
data[2*i-1] += v; data[2*i] += v
lazy[i-1] = 0
def update(l, r, x):
L = N0 + l; R = N0 + r
while L < R:
if R & 1:
R -= 1
lazy[R-1] += x; data[R-1] += x
if L & 1:
lazy[L-1] += x; data[L-1] += x
L += 1
L >>= 1; R >>= 1
for i in gindex(l, r):
data[i-1] = max(data[2*i-1], data[2*i]) + lazy[i-1]
def update2(k, x):
k += N0-1
data[k] = x
while k >= 0:
k = (k - 1) // 2
data[k] = max(data[2*k+1], data[2*k+2])
def query(l, r):
propagates(*gindex(l, r))
L = N0 + l; R = N0 + r
s = -INF
while L < R:
if R & 1:
R -= 1
s = max(s, data[R-1])
if L & 1:
s = max(s, data[L-1])
L += 1
L >>= 1; R >>= 1
return s
xs = [0]*(N+1)
ys = [[] for _ in range(N+1)]
for _ in range(M):
l, r, a = list(map(int, input().split()))
xs[l] += a
ys[r].append((l,a))
rs = [0]*(N+1)
for i in range(1, N+1):
#[0,i)にxs[i]を加算
update(0,i,xs[i])
r = query(0, i)
update2(i, r)
rs[i] = r
for l, a in ys[i]:
update(0, l, -a)
print((max(rs)))
| import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
N0 = 2**((N+1).bit_length())
INF = 10**18
data = [0]*(2*N0)
lazy = [0]*(2*N0)
def gindex(l, r):
L = l + N0; R = r + N0
lm = (L // (L & -L)) >> 1
rm = (R // (R & -R)) >> 1
while L < R:
if R <= rm:
yield R
if L <= lm:
yield L
L >>= 1; R >>= 1
while L:
yield L
L >>= 1
def propagates(*ids):
for i in reversed(ids):
v = lazy[i-1]
if not v:
continue
lazy[2*i-1] += v; lazy[2*i] += v
data[2*i-1] += v; data[2*i] += v
lazy[i-1] = 0
def update(l, r, x):
L = N0 + l; R = N0 + r
while L < R:
if R & 1:
R -= 1
lazy[R-1] += x; data[R-1] += x
if L & 1:
lazy[L-1] += x; data[L-1] += x
L += 1
L >>= 1; R >>= 1
for i in gindex(l, r):
data[i-1] = max(data[2*i-1], data[2*i]) + lazy[i-1]
def update2(k, x):
k += N0-1
data[k] = x
while k >= 0:
k = (k - 1) // 2
data[k] = max(data[2*k+1], data[2*k+2])
def query(l, r):
propagates(*gindex(l, r))
L = N0 + l; R = N0 + r
s = -INF
while L < R:
if R & 1:
R -= 1
s = max(s, data[R-1])
if L & 1:
s = max(s, data[L-1])
L += 1
L >>= 1; R >>= 1
return s
xs = [0]*(N+1)
ys = [[] for _ in range(N+1)]
for _ in range(M):
l, r, a = list(map(int, input().split()))
xs[l] += a
ys[r].append((l,a))
for i in range(1, N+1):
update(0,i,xs[i])
update2(i, query(0, i))
for l, a in ys[i]:
update(0, l, -a)
print((query(0,N+1)))
| p03182 |
a,b=list(map(int,input().split()));print(('Yay!' if max(a,b)<=8 else ':(')) | print(('Yay!'if max(list(map(int,input().split())))<9 else':(')) | p03323 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.