input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
check=dict()
N,b,d=0,[],0
#ttfは235、chaはabc
def dfs_sub(n,ttf,cha):
global check,d
check[0]=min(check[n]+n*d,check[0]) if 0 in check else check[n]+n*d
if n//ttf==0:
check[n//ttf]=min(check[n]+(n%ttf)*d,check[n//ttf]) if n//ttf in check else check[n]+(n%ttf)*d
else:
if n//ttf in check:
if check[n//ttf]>check[n]+(n%ttf)*d+cha:
check[n//ttf]=check[n]+(n%ttf)*d+cha
dfs(n//ttf)
else:
check[n//ttf]=check[n]+(n%ttf)*d+cha
dfs(n//ttf)
if 1+n//ttf in check:
if check[1+n//ttf]>check[n]+(ttf-n%ttf)*d+cha:
check[1+n//ttf]=check[n]+(ttf-n%ttf)*d+cha
dfs(1+n//ttf)
else:
check[1+n//ttf]=check[n]+(ttf-n%ttf)*d+cha
dfs(1+n//ttf)
def dfs(n):
global b,check,d
for i,j in zip([2,3,5],b):
dfs_sub(n,i,j)
t=int(eval(input()))
for i in range(t):
N,*b,d=list(map(int,input().split()))
check={N:0}
dfs(N)
print((check[0]))
| def f(n):
if (m:=s.get(n,-1))<0:s[n]=m=min([d*n]+[abs(p*k-n)*d+c+f(k)for p,c in zip(a,b)for k in(n//p,0--n//p)])
return m
exec("n,*b,d=map(int,input().split());a=2,3,5;s={0:0,1:d};print(f(n));"*int(eval(input()))) | p02669 |
check=dict()
#ttfは235、chaはabc
def dfs_sub(n,ttf,cha):
global check,d
#-1ずつしていく場合
check[0]=min(check[n]+n*d,check[0])
#最寄りまで-してく場合
x1,x2=n//ttf,n%ttf
if x1 in check:
if check[x1]>check[n]+x2*d+cha:
check[x1]=check[n]+x2*d+cha
dfs(x1)
else:
check[x1]=check[n]+x2*d+cha
dfs(x1)
#最寄りまで+1してく場合
x1,x2=n//ttf+1,ttf-n%ttf
if x1 in check:
if check[x1]>check[n]+x2*d+cha:
check[x1]=check[n]+x2*d+cha
dfs(x1)
else:
check[x1]=check[n]+x2*d+cha
dfs(x1)
def dfs(n):
global b
for i,j in zip([2,3,5],b):
dfs_sub(n,i,j)
t=int(eval(input()))
for i in range(t):
N,*b,d=list(map(int,input().split()))
check={N:0,0:N*d}
dfs(N)
print((check[0]))
| def dfs(n):
global b,check,d
#ttfは235、chaはabc
for ttf,cha in zip([2,3,5],b):
#-1ずつしていく場合
check[0]=min(check[n]+n*d,check[0])
#最寄りまで-してく場合
x1,x2=n//ttf,n%ttf
if x1 in check:
if check[x1]>check[n]+x2*d+cha:
check[x1]=check[n]+x2*d+cha
dfs(x1)
else:
check[x1]=check[n]+x2*d+cha
dfs(x1)
#最寄りまで+1してく場合
x1,x2=n//ttf+1,ttf-n%ttf
if x1 in check:
if check[x1]>check[n]+x2*d+cha:
check[x1]=check[n]+x2*d+cha
dfs(x1)
else:
check[x1]=check[n]+x2*d+cha
dfs(x1)
t=int(eval(input()))
for i in range(t):
N,*b,d=list(map(int,input().split()))
check={N:0,0:N*d}
dfs(N)
print((check[0]))
| p02669 |
from math import ceil,floor,log
from decimal import *
from heapq import *
import sys
input=sys.stdin.readline
T=int(eval(input()))
cases=[list(map(int,input().split())) for _ in range(T)]
getcontext().prec=20
num=0
cnt=0
def main():
for i in cases:
l2=[0]*3
N,l2[0],l2[1],l2[2],D=i
d = {}
num=0
cnt=0
for j in range(60): #2の累乗
for k in range(38): #3の累乗
for l in range(26): #5の累乗
div=pow(2,j)*pow(3,k)*pow(5,l)
x=Decimal(N)/Decimal(div)
c=x.to_integral_exact(rounding=ROUND_CEILING)
f=x.to_integral_exact(rounding=ROUND_FLOOR)
if d.get(c)==None:
d[c]=float("inf")
if d.get(f)==None:
d[f]=float("inf")
d[N]=0
#print(d)
q=[]
q.append((0,N))
heapify(q)
#print(d)
while len(q)>0:
dist,u=heappop(q)
if d[u]<dist: continue
for j in range(3):
num=1+pow(2,j)
cnt=l2[j]
x = Decimal(u) / Decimal(num)
v1 = x.to_integral_exact(rounding=ROUND_CEILING)
v2 = x.to_integral_exact(rounding=ROUND_FLOOR)
# v1=ceil(u/2)
# v2=floor(u/2)
alt1 = d[u] + min(cnt+((num-(u%num))%num)*D,(u-v1)*D)
alt2 = d[u] + min(cnt+(u%num)*D,(u-v2)*D)
if d[v1] > alt1:
d[v1] = alt1
heappush(q, (alt1, v1))
if d[v2] > alt2:
d[v2] = alt2
heappush(q, (alt2, v2))
#print(d)
#input()
print((d[0]))
#print(len(d))
if __name__ == '__main__':
main() | from math import ceil,floor,log
#from decimal import Decimal,ROUND_CEILING,ROUND_FLOOR,getcontext
from heapq import *
import sys
input=sys.stdin.readline
T=int(eval(input()))
cases=[list(map(int,input().split())) for _ in range(T)]
#getcontext().prec=20
num=0
cnt=0
def main():
for i in cases:
l2=[0]*3
N,l2[0],l2[1],l2[2],D=i
d = {}
num=0
cnt=0
for j in range(60): #2の累乗
for k in range(38): #3の累乗
for l in range(26): #5の累乗
div=pow(2,j)*pow(3,k)*pow(5,l)
x=N//div
#x=Decimal(N)/Decimal(div)
if N%div!=0:
c=x+1
else:
c=x
f=x
if d.get(c)==None:
d[c]=float("inf")
if d.get(f)==None:
d[f]=float("inf")
d[N]=0
#print(d)
q=[]
q.append((0,N))
heapify(q)
#print(d)
while True:
dist,u=heappop(q)
if d[u]<dist: continue
if u==0:
print(dist)
break
for j in range(3):
num=1+pow(2,j)
cnt=l2[j]
x =u//num
if u%num!=0:
v1 = x+1
else:
v1 = x
v2 = x
# v1=ceil(u/2)
# v2=floor(u/2)
alt1 = d[u] + min(cnt+((num-(u%num))%num)*D,(u-v1)*D)
alt2 = d[u] + min(cnt+(u%num)*D,(u-v2)*D)
if d[v1] > alt1:
d[v1] = alt1
heappush(q, (alt1, v1))
if d[v2] > alt2:
d[v2] = alt2
heappush(q, (alt2, v2))
#print(d)
#input()
#print(d[0])
#print(len(d))
if __name__ == '__main__':
main() | p02669 |
from sys import stdin, stdout, setrecursionlimit
from collections import deque, defaultdict, Counter
from heapq import heappush, heappop
from functools import lru_cache
import math
setrecursionlimit(10**6)
rl = lambda: stdin.readline()
rll = lambda: stdin.readline().split()
rli = lambda: list(map(int, stdin.readline().split()))
rlf = lambda: list(map(float, stdin.readline().split()))
INF, NINF = float('inf'), float('-inf')
MOD = 10**9 + 7
def main():
n = int(rl())
A = []
for _ in range(n):
w, s, v = rli()
A.append((w, s, v))
ans = 0
A.sort(key = lambda I: (I[0] + I[1]))
maxs = 2*10**4 + 100
dp = [0 for _ in range(maxs+1)]
for w, s, v in A:
for i in range(maxs, -1, -1):
if i - w < 0: continue
if i - w > s: continue
dp[i] = max(dp[i], dp[i-w] + v)
ans = max(ans, dp[i])
print(ans)
stdout.close()
if __name__ == "__main__":
main() | from sys import stdin, stdout, setrecursionlimit
from collections import deque, defaultdict, Counter
from heapq import heappush, heappop
from functools import lru_cache
import math
setrecursionlimit(10**6)
rl = lambda: stdin.readline()
rll = lambda: stdin.readline().split()
rli = lambda: list(map(int, stdin.readline().split()))
rlf = lambda: list(map(float, stdin.readline().split()))
INF, NINF = float('inf'), float('-inf')
MOD = 10**9 + 7
def main():
n = int(rl())
A = []
mw, ms = 0, 0
for _ in range(n):
w, s, v = rli()
mw, ms = max(mw, w), max(ms, s)
A.append((w, s, v))
ans = 0
A.sort(key = lambda I: (I[0] + I[1]))
maxs = mw + ms + 100
dp = [0 for _ in range(maxs+1)]
for w, s, v in A:
for i in range(maxs, -1, -1):
if i - w < 0: break
if i - w > s: continue
dp[i] = max(dp[i], dp[i-w] + v)
ans = max(ans, dp[i])
print(ans)
stdout.close()
if __name__ == "__main__":
main() | p03183 |
import sys
n = int(eval(input()))
blocks = []
for line in sys.stdin.readlines():
w, s, v = list(map(int, line.split()))
blocks.append((w + s, w, s, v))
blocks.sort()
dp = [-1] * 20001
dp[0] = 0
for _, w, s, v in blocks:
for i in range(min(s, 20000 - w), -1, -1):
dp[i + w] = max(dp[i + w], dp[i] + v)
print((max(dp)))
| import sys
n = int(eval(input()))
blocks = []
for line in sys.stdin.readlines():
w, s, v = list(map(int, line.split()))
blocks.append((w + s, w, s, v))
blocks.sort()
dp = [-1] * 20001
dp[0] = 0
for _, w, s, v in blocks:
for i in range(s, -1, -1):
if dp[i] == -1:
continue
dp[i + w] = max(dp[i + w], dp[i] + v)
print((max(dp)))
| p03183 |
n = int(eval(input()))
dp = [0] * (n * 10 ** 4 + 1)
bs = [list(map(int, input().split())) for _ in range(n)]
bs.sort(key=lambda x: x[0] + x[1])
for w, s, v in bs:
for i in range(w + s, w - 1, -1):
dpw = dp[i - w] + v
if dpw > dp[i]:
dp[i] = dpw
print((max(dp)))
| def f(n):
dp = [0] * (n * 10 ** 4 + 1)
bs = [list(map(int, input().split())) for _ in range(n)]
bs.sort(key=lambda x: x[0] + x[1])
for w, s, v in bs:
for i in range(w + s, w - 1, -1):
dpw = dp[i - w] + v
if dpw > dp[i]:
dp[i] = dpw
print((max(dp)))
n = int(eval(input()))
f(n)
| p03183 |
def f(n):
dp = [0] * (n * 10 ** 4 + 1)
bs = [list(map(int, input().split())) for _ in range(n)]
bs.sort(key=lambda x: x[0] + x[1])
for w, s, v in bs:
for i in range(w + s, w - 1, -1):
dpw = dp[i - w] + v
if dpw > dp[i]:
dp[i] = dpw
print((max(dp)))
n = int(eval(input()))
f(n)
| def f(n):
mx = 0
dp = [0] * (n * 10 ** 4 + 1)
bs = [list(map(int, input().split())) for _ in range(n)]
bs.sort(key=lambda x: x[0] + x[1])
for w, s, v in bs:
for i in range(w + s, w - 1, -1):
dpw = dp[i - w] + v
if dpw > dp[i]:
dp[i] = dpw
if dpw > mx:
mx = dpw
print(mx)
n = int(eval(input()))
f(n)
| p03183 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
from functools import cmp_to_key
n=int(eval(input()))
B=[list(map(int,input().split())) for _ in range(n)]
def cmp(a,b):
va=min(a[1],b[1]-a[0])
vb=min(b[1],a[1]-b[0])
if(va==vb): return 0
return -1 if(va>vb) else 1
B.sort(key=cmp_to_key(cmp))
dp=[-INF]*(30101)
dp[0]=0
for i in range(n):
w,s,v=B[i]
ndp=dp[:]
for total in range(20101):
if(total<=s):
ndp[total+w]=max(ndp[total+w],dp[total]+v)
dp=ndp[:]
print((max(dp[:20101])))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
from functools import cmp_to_key
n=int(eval(input()))
B=[list(map(int,input().split())) for _ in range(n)]
def cmp(a,b):
va=min(a[1],b[1]-a[0])
vb=min(b[1],a[1]-b[0])
if(va==vb): return 0
return -1 if(va>vb) else 1
B.sort(key=cmp_to_key(cmp))
maxS=20000
dp=[-INF]*(maxS+1)
dp[0]=0
for i in range(n):
w,s,v=B[i]
ndp=dp[:]
for total in range(maxS+1):
if(total<=s and total+s<=maxS):
ndp[total+w]=max(ndp[total+w],dp[total]+v)
dp=ndp[:]
print((max(dp)))
resolve() | p03183 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
from functools import cmp_to_key
n=int(eval(input()))
B=[list(map(int,input().split())) for _ in range(n)]
def cmp(a,b):
va=min(a[1],b[1]-a[0])
vb=min(b[1],a[1]-b[0])
if(va==vb): return 0
return -1 if(va>vb) else 1
B.sort(key=cmp_to_key(cmp))
maxS=20000
dp=[-INF]*(maxS+1)
dp[0]=0
for i in range(n):
w,s,v=B[i]
ndp=dp[:]
for total in range(maxS+1):
if(total<=s and total+s<=maxS):
ndp[total+w]=max(ndp[total+w],dp[total]+v)
dp=ndp[:]
print((max(dp)))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n = int(eval(input()))
WSV = [tuple(map(int, input().split())) for _ in range(n)]
WSV.sort(key = lambda tup:tup[0] + tup[1])
# dp[i][w] : i 番目まで見て、total weight が w のときの max value
# solid_max <= 10^4 なので、total weight > 10^4 は考えなくて良い
res = 0
solid_max = 10 ** 4
dp = [-1] * (solid_max + 1)
dp[0] = 0
for w0, s0, v in WSV:
for w in range(solid_max, -1, -1):
if dp[w] == -1:
continue
if w > s0: # w <= s0
continue
if w + w0 > solid_max:
res = max(res, dp[w] + v)
else:
dp[w + w0] = max(dp[w + w0], dp[w] + v)
res = max(res, max(dp))
print(res)
resolve() | p03183 |
n=int(eval(input()));
ans=0;
p=[0]*22222;
for w,s,v in sorted([list(map(int,input().split()))for _ in[0]*n],key=lambda a:a[0]+a[1]):
for j in range(s,-1,-1):
p[j+w]=max(p[j+w],p[j]+v);
ans=max(ans,p[j+w]);
print(ans)
| p=[0]*6**6
for w,s,v in sorted([list(map(int,input().split()))for _ in[0]*int(eval(input()))],key=lambda a:a[0]+a[1]):
for j in range(s,-1,-1):p[j+w]=max(p[j+w],p[j]+v)
print((max(p))) | p03183 |
import sys
input = sys.stdin.readline
N=int(eval(input()))
B=sorted([list(map(int,input().split())) for i in range(N)],key=lambda x:x[0]+x[1])
#W+Sの順にソートすると無駄がない。
DP=[0]*(10**4+2)
#重さの合計がWのときの価値。
#W=10**4+1ならそれ以上更新されないので、W>=10**4+1以上のものはそこに置く
for w,s,v in B:
if 10**4+1-w<=s:
if DP[-1]<max(DP[10**4+1-w:s+1])+v:
DP[-1]=max(DP[10**4+1-w:s+1])+v
for i in range(min(10**4-w,s),-1,-1):
if DP[i+w]<DP[i]+v:
DP[i+w]=DP[i]+v
print((max(DP))) | import sys
input = sys.stdin.readline
N=int(eval(input()))
B=sorted([list(map(int,input().split())) for i in range(N)],key=lambda x:x[0]+x[1])
#W+Sの順にソートすると無駄がない。
DP=[0]*(10**4+2)
#重さの合計がWのときの価値。
#W=10**4+1ならそれ以上更新されないので、W>=10**4+1以上のものはそこに置く
for w,s,v in B:
if 10**4+1-w<=s:
x=max(DP[10**4+1-w:s+1])+v
if DP[-1]<x:
DP[-1]=x
if 10**4-w<s:
for i in range(10**4-w,-1,-1):
if DP[i+w]<DP[i]+v:
DP[i+w]=DP[i]+v
else:
for i in range(s,-1,-1):
if DP[i+w]<DP[i]+v:
DP[i+w]=DP[i]+v
print((max(DP))) | p03183 |
from collections import defaultdict
import sys
input=sys.stdin.readline
r,c,k=list(map(int,input().split()))
l=[0]*((r+1)*(c+1))
for i in range(k):
a1,a2,a3=list(map(int,input().split()))
l[a1*(c+1)+a2]=a3
dp0=[[0 for i in range(c+1)] for j in range(r+1)]
dp1=[[0 for i in range(c+1)] for j in range(r+1)]
dp2=[[0 for i in range(c+1)] for j in range(r+1)]
dp3=[[0 for i in range(c+1)] for j in range(r+1)]
for i in range(r):
for j in range(c):
x=l[i*(c+1)+j+1]
y=l[(i+1)*(c+1)+j]
dp3[i+1][j+1]=max(dp2[i][j+1]+x,dp3[i][j+1],dp2[i+1][j]+y,dp3[i+1][j])
dp2[i+1][j+1]=max(dp2[i][j+1]+x,dp3[i][j+1],dp1[i+1][j]+y,dp2[i+1][j])
dp1[i+1][j+1]=max(dp2[i][j+1]+x,dp3[i][j+1],dp0[i+1][j]+y,dp1[i+1][j])
dp0[i+1][j+1]=max(dp2[i][j+1]+x,dp3[i][j+1],dp0[i+1][j])
z=l[r*(c+1)+c]
print((max(dp2[r][c]+z,dp3[r][c]))) | import sys
input=sys.stdin.readline
r,c,k=list(map(int,input().split()))
l=[0]*((r+1)*(c+1))
for i in range(k):
a1,a2,a3=list(map(int,input().split()))
l[a1*(c+1)+a2]=a3
dp0=[[0 for i in range(c+1)] for j in range(r+1)]
dp1=[[0 for i in range(c+1)] for j in range(r+1)]
dp2=[[0 for i in range(c+1)] for j in range(r+1)]
dp3=[[0 for i in range(c+1)] for j in range(r+1)]
for i in range(r):
for j in range(c):
x=l[i*(c+1)+j+1]
y=l[(i+1)*(c+1)+j]
dp3[i+1][j+1]=max(dp2[i][j+1]+x,dp3[i][j+1],dp2[i+1][j]+y,dp3[i+1][j])
dp2[i+1][j+1]=max(dp2[i][j+1]+x,dp3[i][j+1],dp1[i+1][j]+y,dp2[i+1][j])
dp1[i+1][j+1]=max(dp2[i][j+1]+x,dp3[i][j+1],dp0[i+1][j]+y,dp1[i+1][j])
dp0[i+1][j+1]=max(dp2[i][j+1]+x,dp3[i][j+1],dp0[i+1][j])
z=l[r*(c+1)+c]
print((max(dp2[r][c]+z,dp3[r][c]))) | p02586 |
import sys
mod=10**9+7 ; inf=float("inf")
from math import sqrt, ceil
from collections import deque, Counter, defaultdict #すべてのkeyが用意されてる defaultdict(int)で初期化
# input=lambda: sys.stdin.readline().strip()
sys.setrecursionlimit(11451419)
from decimal import ROUND_HALF_UP,Decimal #変換後の末尾桁を0や0.01で指定
#Decimal((str(0.5)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
from functools import lru_cache
#メモ化再帰defの冒頭に毎回 @lru_cache(maxsize=10**10)
#引数にlistはだめ
#######ここまでテンプレ#######
#ソート、"a"+"b"、再帰ならPython3の方がいい
#######ここから天ぷら########
h,w,k=list(map(int,input().split()))
# R=[]
A=[[0]*w for i in range(h)]
dp=[[[0]*4 for j in range(w)] for i in range(h)]
for s in sys.stdin.readlines():
x,y,v=list(map(int,s.split()))
x-=1;y-=1
A[x][y]=v
# dp[x][y][1]=v
# dp[x][y][2]=v
# dp[x][y][3]=v;
dp[0][0][1]=A[0][0]
for i in range(h):
for j in range(w):
for k in range(4):
here=dp[i][j][k]
if i<h-1:
dp[i+1][j][0] = max(here,dp[i+1][j][0])
dp[i+1][j][1] = max(here+A[i+1][j], dp[i+1][j][1])
if j<w-1:
dp[i][j+1][k] = max(dp[i][j+1][k], here)
if k<=2:
dp[i][j+1][k+1]= max(dp[i][j+1][k+1],here+ A[i][j+1])
print(( max(dp[-1][-1])))
| import sys
R, C, K = list(map(int, input().split()))
item = [[0] * (C + 1) for _ in range(R + 1)] # dp配列と合わせるために, 0行目, 0列目を追加している.
for s in sys.stdin.readlines():
r, c, v = list(map(int, s.split()))
item[r][c] = v
dp = [[[0] * (C + 1) for _ in range(R + 1)] for _ in range(4)]
for i in range(R + 1):
for j in range(C + 1):
for k in range(4):
here = dp[k][i][j]
# 次の行に移動する場合
if i + 1 <= R:
# 移動先のアイテムを取らない場合
dp[0][i + 1][j] = max(dp[0][i + 1][j], here)
# 移動先のアイテムを取る場合
dp[1][i + 1][j] = max(dp[1][i + 1][j], here + item[i + 1][j])
# 次の列に移動する場合
if j + 1 <= C:
# 移動先のアイテムを取らない場合
dp[k][i][j + 1] = max(dp[k][i][j + 1], here)
# 現在のkが3未満のときのみ, 移動先のアイテムを取ることが可能
if k < 3:
dp[k + 1][i][j + 1] = max(dp[k + 1][i][j + 1], here + item[i][j + 1])
ans = 0
for k in range(4):
ans = max(ans, dp[k][-1][-1])
print(ans) | p02586 |
R, C, K = list(map(int, input().split()))
Items = [[0] * (C + 1) for _ in range(R + 1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
Items[r][c] = v
DP = [[[-float('inf')] * 4 for _ in range(C + 1)] for __ in range(R + 1)]
for y in range(R+1):
for x in range(C+1):
if y == 0:
DP[y][x][0] = 0
continue
if x == 0:
DP[y][x][0] = 0
continue
if Items[y][x] == 0:
for k in range(4):
DP[y][x][0] = max(DP[y][x][0], DP[y - 1][x][k])
if k != 0:
DP[y][x][k] = DP[y][x-1][k]
DP[y][x][0] = max(DP[y][x][0], DP[y][x-1][0])
else:
for k in range(4):
DP[y][x][0] = max(DP[y][x][0], DP[y - 1][x][k])
DP[y][x][0] = max(DP[y][x][0], DP[y][x - 1][0])
for k in range(1, 4):
DP[y][x][k] = max(DP[y][x-1][k-1] + Items[y][x], DP[y][x-1][k])
if k == 1:
DP[y][x][k] = max(DP[y][x][k], max(DP[y-1][x]) + Items[y][x])
print((max(DP[R][C]))) | R, C, K = list(map(int, input().split()))
Items = [[0] * (C + 1) for _ in range(R + 1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
Items[r][c] = v
DP = [[0] * 4 for _ in range(R + 1)]
for x in range(1, C+1):
for y in range(1, R+1):
v = Items[y][x]
if v:
DP[y][3] = max(DP[y][3], DP[y][2] + v)
DP[y][2] = max(DP[y][2], DP[y][1] + v)
DP[y][1] = max(max(DP[y][1], DP[y][0] + v), max(DP[y-1]) + v)
DP[y][0] = max(DP[y][0], max(DP[y-1]))
else:
DP[y][0] = max(DP[y][0], max(DP[y-1]))
print((max(DP[R]))) | p02586 |
import os,io
import sys
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
r,c,k=list(map(int,input().split()))
dp = [[[0 for y in range(c)] for z in range(r)] for P in range(4)]
m=[]
for i in range(r):
m.append([])
for j in range(c):
m[i].append(0)
for i in range(k):
ri,ci,v=list(map(int,input().split()))
m[ri-1][ci-1]=v
dp[0][0][0]=0
dp[1][0][0]=m[0][0]
dp[2][0][0]=m[0][0]
dp[3][0][0]=m[0][0]
for i in range(r):
for j in range(c):
if j+1<c:
dp[0][i][j+1]=max(dp[0][i][j+1],dp[0][i][j])
dp[1][i][j+1]=max(dp[1][i][j],max(dp[1][i][j+1],dp[0][i][j]+m[i][j+1]))
dp[2][i][j+1]=max(dp[2][i][j],max(dp[2][i][j+1],dp[1][i][j]+m[i][j+1]))
dp[3][i][j+1]=max(dp[3][i][j],max(dp[3][i][j+1],dp[2][i][j]+m[i][j+1]))
if i+1<r:
dp[0][i+1][j]=dp[3][i][j]
dp[1][i+1][j]=dp[3][i][j]+m[i+1][j]
dp[2][i+1][j]=dp[3][i][j]+m[i+1][j]
dp[3][i+1][j]=dp[3][i][j]+m[i+1][j]
print((dp[3][r-1][c-1]))
| import os,io
import sys
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
r,c,k=list(map(int,input().split()))
dp = [0]*(r*c*4)
m=[]
for i in range(r):
m.append([])
for j in range(c):
m[i].append(0)
for i in range(k):
ri,ci,v=list(map(int,input().split()))
m[ri-1][ci-1]=v
dp[0*r*c+0*c+0]=0
dp[1*r*c+0*c+0]=m[0][0]
dp[2*r*c+0*c+0]=m[0][0]
dp[3*r*c+0*c+0]=m[0][0]
for i in range(r):
for j in range(c):
if j+1<c:
dp[0*r*c+i*c+j+1]=max(dp[0*r*c+i*c+j+1],dp[0*r*c+i*c+j])
dp[1*r*c+i*c+j+1]=max(dp[1*r*c+i*c+j],max(dp[1*r*c+i*c+j+1],dp[0*r*c+i*c+j]+m[i][j+1]))
dp[2*r*c+i*c+j+1]=max(dp[2*r*c+i*c+j],max(dp[2*r*c+i*c+j+1],dp[1*r*c+i*c+j]+m[i][j+1]))
dp[3*r*c+i*c+j+1]=max(dp[3*r*c+i*c+j],max(dp[3*r*c+i*c+j+1],dp[2*r*c+i*c+j]+m[i][j+1]))
if i+1<r:
dp[0*r*c+(i+1)*c+j]=dp[3*r*c+i*c+j]
dp[1*r*c+(i+1)*c+j]=dp[3*r*c+i*c+j]+m[i+1][j]
dp[2*r*c+(i+1)*c+j]=dp[3*r*c+i*c+j]+m[i+1][j]
dp[3*r*c+(i+1)*c+j]=dp[3*r*c+i*c+j]+m[i+1][j]
print((dp[3*r*c+(r-1)*c+c-1]))
| p02586 |
import os,io
import sys
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
r,c,k=list(map(int,input().split()))
dp = [0]*(r*c*4)
m=[]
for i in range(r):
m.append([])
for j in range(c):
m[i].append(0)
for i in range(k):
ri,ci,v=list(map(int,input().split()))
m[ri-1][ci-1]=v
dp[0*r*c+0*c+0]=0
dp[1*r*c+0*c+0]=m[0][0]
dp[2*r*c+0*c+0]=m[0][0]
dp[3*r*c+0*c+0]=m[0][0]
for i in range(r):
for j in range(c):
if j+1<c:
dp[0*r*c+i*c+j+1]=max(dp[0*r*c+i*c+j+1],dp[0*r*c+i*c+j])
dp[1*r*c+i*c+j+1]=max(dp[1*r*c+i*c+j],max(dp[1*r*c+i*c+j+1],dp[0*r*c+i*c+j]+m[i][j+1]))
dp[2*r*c+i*c+j+1]=max(dp[2*r*c+i*c+j],max(dp[2*r*c+i*c+j+1],dp[1*r*c+i*c+j]+m[i][j+1]))
dp[3*r*c+i*c+j+1]=max(dp[3*r*c+i*c+j],max(dp[3*r*c+i*c+j+1],dp[2*r*c+i*c+j]+m[i][j+1]))
if i+1<r:
dp[0*r*c+(i+1)*c+j]=dp[3*r*c+i*c+j]
dp[1*r*c+(i+1)*c+j]=dp[3*r*c+i*c+j]+m[i+1][j]
dp[2*r*c+(i+1)*c+j]=dp[3*r*c+i*c+j]+m[i+1][j]
dp[3*r*c+(i+1)*c+j]=dp[3*r*c+i*c+j]+m[i+1][j]
print((dp[3*r*c+(r-1)*c+c-1]))
| import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
r,c,k=list(map(int,input().split()))
dp = [0]*(r*c*4)
m=[0]*(r*c)
for i in range(k):
ri,ci,v=list(map(int,input().split()))
m[(ri-1)*c+ci-1]=v
dp[0*r*c+0*c+0]=0
dp[1*r*c+0*c+0]=m[0]
dp[2*r*c+0*c+0]=m[0]
dp[3*r*c+0*c+0]=m[0]
for i in range(r):
for j in range(c):
if j+1<c:
dp[0*r*c+i*c+j+1]=max(dp[0*r*c+i*c+j+1],dp[0*r*c+i*c+j])
dp[1*r*c+i*c+j+1]=max(dp[1*r*c+i*c+j],max(dp[1*r*c+i*c+j+1],dp[0*r*c+i*c+j]+m[i*c+j+1]))
dp[2*r*c+i*c+j+1]=max(dp[2*r*c+i*c+j],max(dp[2*r*c+i*c+j+1],dp[1*r*c+i*c+j]+m[i*c+j+1]))
dp[3*r*c+i*c+j+1]=max(dp[3*r*c+i*c+j],max(dp[3*r*c+i*c+j+1],dp[2*r*c+i*c+j]+m[i*c+j+1]))
if i+1<r:
a=dp[3*r*c+i*c+j]
b=a+m[(i+1)*c+j]
dp[0*r*c+(i+1)*c+j]=a
dp[1*r*c+(i+1)*c+j]=b
dp[2*r*c+(i+1)*c+j]=b
dp[3*r*c+(i+1)*c+j]=b
print((dp[3*r*c+(r-1)*c+c-1]))
| p02586 |
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
R, C, k = list(map(int, input().split()))
field = [[0] * C for _ in range(R)]
for _ in range(k):
r, c, v = list(map(int, input().split()))
r -= 1; c -= 1
field[r][c] = v
# dp[taken 0 - 2][R][C]
dp = [[-1] * (C + 1) * (R + 1) for _ in range(4)]
dp[0][0] = 0
for j in range(C):
for i in range(R):
for k in range(4):
ij = i * C + j
ij1 = i * C + j + 1
i1j = (i + 1) * C + j
# Use
if field[i][j] and k < 3:
dp[k+1][ij1] = max(dp[k+1][ij1], dp[k][ij] + field[i][j])
dp[0][i1j] = max(dp[0][i1j], dp[k][ij] + field[i][j])
# No use down
dp[0][i1j] = max(dp[0][i1j], dp[k][ij])
# No use right
dp[k][ij1] = max(dp[k][ij1], dp[k][ij])
ans = 0
for i in range(4):
for j in range(R + 1):
ans = max(ans, dp[i][j * C + C - 1])
print(ans) | #!/usr/bin/env python3
import sys
input = sys.stdin.readline
R, C, k = list(map(int, input().split()))
field = [[0] * C for _ in range(R)]
for _ in range(k):
r, c, v = list(map(int, input().split()))
r -= 1; c -= 1
field[r][c] = v
# dp[taken 0 - 2][R][C]
dp = [[-1] * (C + 1) * (R + 1) for _ in range(4)]
dp[0][0] = 0
for j in range(C):
for i in range(R):
for k in range(4):
ij = i * C + j
ij1 = ij + 1
i1j = ij + C
item = field[i][j]
# Use
if item and k < 3:
dp[k+1][ij1] = max(dp[k+1][ij1], dp[k][ij] + item)
dp[0][i1j] = max(dp[0][i1j], dp[k][ij] + item)
# No use down
dp[0][i1j] = max(dp[0][i1j], dp[k][ij])
# No use right
dp[k][ij1] = max(dp[k][ij1], dp[k][ij])
ans = 0
for i in range(4):
for j in range(R + 1):
ans = max(ans, dp[i][j * C + C - 1])
print(ans) | p02586 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
R, C, K = mapint()
dp = [[[0]*4 for _ in range(C)] for _ in range(R)]
from collections import defaultdict
dic = [[0]*C for _ in range(R)]
for _ in range(K):
r, c, v = mapint()
dic[r-1][c-1] = v
for r in range(R):
for c in range(C):
v = dic[r][c]
for i in range(4):
if c!=0:
dp[r][c][i] = dp[r][c-1][i]
if r!=0:
dp[r][c][0] = max(dp[r][c][0], dp[r-1][c][i])
for i in range(2, -1, -1):
dp[r][c][i+1] = max(dp[r][c][i+1], dp[r][c][i]+v)
print((max(dp[R-1][C-1]))) | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
R, C, K = mapint()
last_dp = [[0]*4 for _ in range(C)]
dic = [[0]*C for _ in range(R)]
for _ in range(K):
r, c, v = mapint()
dic[r-1][c-1] = v
for r in range(R):
dp = [[0]*4 for _ in range(C)]
for c in range(C):
v = dic[r][c]
for i in range(4):
if c!=0:
dp[c][i] = dp[c-1][i]
if r!=0:
dp[c][0] = max(dp[c][0], last_dp[c][i])
if v!=0:
for i in range(2, -1, -1):
dp[c][i+1] = max(dp[c][i+1], dp[c][i]+v)
last_dp = dp
print((max(dp[C-1]))) | p02586 |
R, C, K = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(K)]
items = [[0] * (C + 1) for _ in range(R + 1)]
for r, c, v in X:
items[r][c] = v
dp = [[[0] * 4 for _ in range(C + 1)] for _ in range(R + 1)]
for i in range(1, R + 1):
for j in range(1, C + 1):
# k=0, horizontal and vertical transitions are allowed
dp[i][j][0] = max(dp[i][j - 1][0], dp[i - 1][j][0], dp[i - 1][j][1],
dp[i - 1][j][2], dp[i - 1][j][3])
# k=1~3, horizontal transition and picking up are allowed
dp[i][j][3] = max(dp[i][j - 1][3], dp[i][j - 1][2] + items[i][j],
dp[i][j][2] + items[i][j])
dp[i][j][2] = max(dp[i][j - 1][2], dp[i][j - 1][1] + items[i][j],
dp[i][j][1] + items[i][j])
dp[i][j][1] = max(dp[i][j - 1][1], dp[i][j - 1][0] + items[i][j],
dp[i][j][0] + items[i][j])
print((max(dp[-1][-1])))
|
R, C, K = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(K)]
items = [[0] * (C + 1) for _ in range(R + 1)]
for r, c, v in X:
items[r][c] = v
dp = [[0] * 4 for _ in range(C + 1)]
for i in range(1, R + 1):
# Vertical transition
for j in range(1, C + 1):
dp[j][0] = max(dp[j])
for k in range(1, 4):
dp[j][k] = 0
# Horizontal or picking-up transition
for j in range(1, C + 1):
for k in reversed(list(range(4))):
dp[j][k] = max(dp[j][k], dp[j - 1][k])
if items[i][j] and k < 3:
dp[j][k + 1] = max(dp[j][k + 1], dp[j][k] + items[i][j])
print((max(dp[-1])))
| p02586 |
from sys import stdin
input = stdin.readline
(R,C,K) = list(map(int, input().split()))
rcv = [list(map(int, input().split())) for _ in range(K)]
grids = [[0]*C for _ in range(R)]
for r,c,v in rcv:
grids[r-1][c-1] = v
from collections import defaultdict
dp = defaultdict(int)
for r in range(R):
for c in range(C):
tmp = value = grids[r][c]
for i in range(1,4):
if c:
tmp = max(tmp, dp[r,c-1,i])
if i > 1:
tmp = max(tmp, dp[r,c-1,i-1] + value)
if r and i == 1:
tmp = max(tmp, dp[r-1,c,3] + value)
dp[r,c,i] = tmp
print((dp[R-1,C-1,3])) | # from sys import stdin
# input = stdin.readline
(R,C,K) = list(map(int, input().split()))
rcv = [list(map(int, input().split())) for _ in range(K)]
grids = [[0]*C for _ in range(R)]
for r,c,v in rcv:
grids[r-1][c-1] = v
dp = [0] * C
for r in range(R):
# print(dp)
ndp = [0] * C
elm = [0] * 4
for c in range(C):
elm[0] = max(elm[0], dp[c])
value = grids[r][c]
if value:
nelm = [0] * 4
nelm[0] = elm[0]
# print(f'{value=}')
# print(f'{ elm=}')
# print(f'{nelm=}')
for i in range(3)[::-1]:
nelm[i + 1] = max(elm[i + 1], elm[i] + value)
# print(f'{value=}')
# print(f'{ elm=}')
# print(f'{nelm=}')
elm = nelm
ndp[c] = max(elm)
dp = ndp
print((dp[-1])) | p02586 |
import sys
from collections import deque
import bisect
import copy
import heapq
import itertools
import math
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7
def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
class V:
def __init__(self, f, v=None):
self.f = f
self.v = v
def __str__(self):
return str(self.v)
def ud(self, n):
if n is None:
return
if self.v is None:
self.v = n
return
self.v = self.f(self.v, n)
def main():
R, C, K = read_values()
V2 = [0] * (R * C)
for _ in range(K):
r, c, v = read_values()
r -= 1
c -= 1
V2[r * C + c] = v
dp = [[V(max, 0) for _ in range(4)] for _ in range(R * C)]
for i in range(R * C):
r = i // C
c = i % C
if c + 1 < C:
# not take
for k in range(4):
dp[i + 1][k].ud(dp[i][k].v)
# take
for k in range(3):
dp[i + 1][k + 1].ud(dp[i][k].v + V2[i])
# next r
if r + 1 < R:
for k in range(3):
dp[i + C][0].ud(dp[i][k].v + V2[i])
dp[i + C][0].ud(dp[i][3].v)
print((max(k.v + (V2[-1] if i < 3 else 0) for i, k in enumerate(dp[-1]))))
if __name__ == "__main__":
main()
| import sys
from collections import deque
import bisect
import copy
import heapq
import itertools
import math
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7
def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
def main():
R, C, K = read_values()
V = [0] * (R * C)
for _ in range(K):
r, c, v = read_values()
r -= 1
c -= 1
V[r * C + c] = v
dp = [0 for _ in range(R * C * 4)]
for i in range(R * C):
r = i // C
c = i % C
if c + 1 < C:
# not take
for k in range(4):
dp[4 * (i + 1) + k] = max(dp[4 * (i + 1) + k], dp[4 * i + k])
# take
for k in range(3):
dp[4 * (i + 1) + k + 1] = max(dp[4 * (i + 1) + k + 1], dp[4 * i + k] + V[i])
# next r
if r + 1 < R:
for k in range(4):
dp[4 * (i + C)] = max(dp[4 * (i + C)], dp[4 * i + k] + (V[i] if k < 3 else 0))
res = 0
for k in range(4):
res = max(res, dp[4 * (R * C - 1) + k] + (V[-1] if k < 3 else 0))
print(res)
if __name__ == "__main__":
main()
| p02586 |
import sys
input = sys.stdin.buffer.readline
def main():
R, C, K = list(map(int, input().split()))
dp = [[[0, None, None, None] for j in range(C + 1)] for i in range(R + 1)]
dp[0][0][0] = 0
G = [[None for j in range(C)] for i in range(R)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
G[r - 1][c - 1] = v
for i in range(R):
for j in range(C):
if i == 0:
break
if G[i][j] is not None:
if dp[i][j + 1][0] is not None:
dp[i + 1][j + 1][1] = max(dp[i + 1][j + 1][0], dp[i][j + 1][0]) + G[i][j]
dp[i + 1][j + 1][0] = max(dp[i + 1][j + 1][0], dp[i][j + 1][0])
if dp[i][j + 1][1] is not None:
dp[i + 1][j + 1][1] = max(dp[i + 1][j + 1][0], dp[i][j + 1][1]) + G[i][j]
dp[i + 1][j + 1][0] = max(dp[i + 1][j + 1][0], dp[i][j + 1][1])
if dp[i][j + 1][2] is not None:
dp[i + 1][j + 1][1] = max(dp[i + 1][j + 1][0], dp[i][j + 1][2]) + G[i][j]
dp[i + 1][j + 1][0] = max(dp[i + 1][j + 1][0], dp[i][j + 1][2])
if dp[i][j + 1][3] is not None:
dp[i + 1][j + 1][1] = max(dp[i + 1][j + 1][0], dp[i][j + 1][3]) + G[i][j]
dp[i + 1][j + 1][0] = max(dp[i + 1][j + 1][0], dp[i][j + 1][3])
else:
if dp[i][j + 1][0] is not None:
dp[i + 1][j + 1][0] = max(dp[i + 1][j + 1][0], dp[i][j + 1][0])
if dp[i][j + 1][1] is not None:
dp[i + 1][j + 1][0] = max(dp[i + 1][j + 1][0], dp[i][j + 1][1])
if dp[i][j + 1][2] is not None:
dp[i + 1][j + 1][0] = max(dp[i + 1][j + 1][0], dp[i][j + 1][2])
if dp[i][j + 1][3] is not None:
dp[i + 1][j + 1][0] = max(dp[i + 1][j + 1][0], dp[i][j + 1][3])
for j in range(C):
if G[i][j] is not None:
if dp[i + 1][j + 1][0] is not None and dp[i + 1][j][0] is not None:
if dp[i + 1][j][1] is not None:
if dp[i + 1][j + 1][1] is not None:
dp[i + 1][j + 1][1] = max(dp[i + 1][j + 1][1], dp[i + 1][j][0] + G[i][j], dp[i + 1][j][1])
else:
dp[i + 1][j + 1][1] = max(dp[i + 1][j][1], dp[i + 1][j][0] + G[i][j])
else:
if dp[i + 1][j + 1][1] is not None:
dp[i + 1][j + 1][1] = max(dp[i + 1][j + 1][1], dp[i + 1][j][0] + G[i][j])
else:
dp[i + 1][j + 1][1] = dp[i + 1][j][0] + G[i][j]
if dp[i + 1][j + 1][1] is not None and dp[i + 1][j][1] is not None:
if dp[i + 1][j][2] is not None:
if dp[i + 1][j + 1][2] is not None:
dp[i + 1][j + 1][2] = max(dp[i + 1][j + 1][2], dp[i + 1][j][1] + G[i][j], dp[i + 1][j][2])
else:
dp[i + 1][j + 1][2] = max(dp[i + 1][j][2], dp[i + 1][j][1] + G[i][j])
else:
if dp[i + 1][j + 1][2] is not None:
dp[i + 1][j + 1][2] = max(dp[i + 1][j + 1][2], dp[i + 1][j][1] + G[i][j])
else:
dp[i + 1][j + 1][2] = dp[i + 1][j][1] + G[i][j]
if dp[i + 1][j + 1][2] is not None and dp[i + 1][j][2] is not None:
if dp[i + 1][j][3] is not None:
if dp[i + 1][j + 1][3] is not None:
dp[i + 1][j + 1][3] = max(dp[i + 1][j + 1][3], dp[i + 1][j][2] + G[i][j], dp[i + 1][j][3])
else:
dp[i + 1][j + 1][3] = max(dp[i + 1][j][3], dp[i + 1][j][2] + G[i][j])
else:
if dp[i + 1][j + 1][3] is not None:
dp[i + 1][j + 1][3] = max(dp[i + 1][j + 1][3], dp[i + 1][j][2] + G[i][j])
else:
dp[i + 1][j + 1][3] = dp[i + 1][j][2] + G[i][j]
else:
if dp[i + 1][j][0] is not None:
if dp[i + 1][j + 1][0] is not None:
dp[i + 1][j + 1][0] = max(dp[i + 1][j + 1][0], dp[i + 1][j][0])
else:
dp[i + 1][j + 1][0] = dp[i + 1][j][0]
if dp[i + 1][j][1] is not None:
if dp[i + 1][j + 1][1] is not None:
dp[i + 1][j + 1][1] = max(dp[i + 1][j + 1][1], dp[i + 1][j][1])
else:
dp[i + 1][j + 1][1] = dp[i + 1][j][1]
if dp[i + 1][j][2] is not None:
if dp[i + 1][j + 1][2] is not None:
dp[i + 1][j + 1][2] = max(dp[i + 1][j + 1][2], dp[i + 1][j][2])
else:
dp[i + 1][j + 1][2] = dp[i + 1][j][2]
if dp[i + 1][j][3] is not None:
if dp[i + 1][j + 1][3] is not None:
dp[i + 1][j + 1][3] = max(dp[i + 1][j + 1][3], dp[i + 1][j][3])
else:
dp[i + 1][j + 1][3] = dp[i + 1][j][3]
res = 0
for d in dp[R][C]:
if d is not None:
res = max(res, d)
print(res)
if __name__ == '__main__':
main() | import sys
input = sys.stdin.buffer.readline
R, C, K = list(map(int, input().split()))
G = [[None for j in range(C)] for i in range(R)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
G[r - 1][c - 1] = v
dp = [[0, 0, 0, 0] for _ in range(C)]
for i in range(R):
for j in range(C):
if G[i][j] is not None:
dp[j][0], dp[j][1] = max(dp[j]), max(dp[j]) + G[i][j]
dp[j][2], dp[j][3] = 0, 0
else:
dp[j][0] = max(dp[j])
dp[j][1], dp[j][2], dp[j][3] = 0, 0, 0
for j in range(1, C):
if G[i][j] is not None:
dp[j][0] = max(dp[j - 1][0], dp[j][0])
dp[j][1] = max(dp[j - 1][1], dp[j - 1][0] + G[i][j], dp[j][1])
if dp[j - 1][1] != 0:
dp[j][2] = max(dp[j - 1][2], dp[j - 1][1] + G[i][j], dp[j][2])
if dp[j - 1][2] != 0:
dp[j][3] = max(dp[j - 1][3], dp[j - 1][2] + G[i][j], dp[j][3])
else:
dp[j][0] = max(dp[j - 1][0], dp[j][0])
dp[j][1] = max(dp[j - 1][1], dp[j][1])
dp[j][2] = max(dp[j - 1][2], dp[j][2])
dp[j][3] = max(dp[j - 1][3], dp[j][3])
print((max(dp[-1]))) | p02586 |
def main():
import sys
my_input = sys.stdin.readline
H, W, K = list(map(int, my_input().split()))
V = [[0] * W for _ in range(H)]
for i in range(K):
h, w, v = list(map(int, my_input().split()))
h, w = h - 1, w - 1
V[h][w] = v
# dp[h][w][x] := h行w列にいて、h行からx個アイテムを拾っている時の価値の総和の最大値
dp = [[[0] * 4 for j in range(W + 1)] for i in range(H + 1)]
for h in range(1, H + 1):
for w in range(1, W + 1):
for k in range(1, 4):
dp[h][w][k] = max(
dp[h][w][k],
dp[h - 1][w][-1],
dp[h - 1][w][-1] + V[h - 1][w - 1],
dp[h][w - 1][k],
dp[h][w - 1][k - 1] + V[h - 1][w - 1])
print((max(dp[-1][-1])))
if __name__ == "__main__":
main()
| def main():
import sys
my_input = sys.stdin.readline
H, W, K = list(map(int, my_input().split()))
V = [[0] * W for _ in range(H)]
for i in range(K):
h, w, v = list(map(int, my_input().split()))
h, w = h - 1, w - 1
V[h][w] = v
# dp1 ~ 4[h][w][x] := h行w列にいて、h行からn個アイテムを拾っている時の価値の総和の最大値
dp0 = [[0] * (W + 1) for _ in range(H + 1)]
dp1 = [[0] * (W + 1) for _ in range(H + 1)]
dp2 = [[0] * (W + 1) for _ in range(H + 1)]
dp3 = [[0] * (W + 1) for _ in range(H + 1)]
for h in range(1, H + 1):
for w in range(1, W + 1):
dp1[h][w] = max(
dp1[h][w],
dp3[h - 1][w] + V[h - 1][w - 1],
dp1[h][w - 1],
dp0[h][w - 1] + V[h - 1][w - 1]
)
dp2[h][w] = max(
dp2[h][w],
dp3[h - 1][w] + V[h - 1][w - 1],
dp2[h][w - 1],
dp1[h][w - 1] + V[h - 1][w - 1]
)
dp3[h][w] = max(
dp3[h][w],
dp3[h - 1][w] + V[h - 1][w - 1],
dp3[h][w - 1],
dp2[h][w - 1] + V[h - 1][w - 1]
)
print((dp3[-1][-1]))
if __name__ == "__main__":
main()
| p02586 |
R, C, K=list(map(int, input().split()))
math=[[0]*C for _ in range(R)]
for _ in range(K):
r, c, v=list(map(int, input().split()))
math[r-1][c-1]=v
dp=[[[0]*4 for __ in range(C)] for _ in range(R)]
if math[0][0]>0:
dp[0][0][1]=math[0][0]+0
for j in range(1, C):
dp[0][j][0]=dp[0][j-1][0]+0
dp[0][j][1]=max(dp[0][j-1][1], dp[0][j-1][0]+math[0][j])
dp[0][j][2]=max(dp[0][j-1][2], dp[0][j-1][1]+math[0][j])
dp[0][j][3]=max(dp[0][j-1][3], dp[0][j-1][2]+math[0][j])
for i in range(1, R):
dp[i][0][0]=max(dp[i-1][0])
dp[i][0][1]=dp[i][0][0]+math[i][0]
for j in range(1, C):
dp[i][j][0]=max(dp[i][j-1][0], max(dp[i-1][j]))
dp[i][j][1]=max(dp[i][j-1][1], dp[i][j-1][0]+math[i][j], max(dp[i-1][j])+math[i][j])
dp[i][j][2]=max(dp[i][j-1][2], dp[i][j-1][1]+math[i][j])
dp[i][j][3]=max(dp[i][j-1][3], dp[i][j-1][2]+math[i][j])
print((max(dp[-1][-1]))) | R, C, K=list(map(int, input().split()))
math=[[0]*C for _ in range(R)]
for _ in range(K):
r, c, v=list(map(int, input().split()))
math[r-1][c-1]=v
dp=[[[0]*C for __ in range(R)] for _ in range(4)]
if math[0][0]>0:
dp[1][0][0]=math[0][0]+0
for j in range(1, C):
dp[0][0][j]=dp[0][0][j-1]+0
dp[1][0][j]=max(dp[1][0][j-1], dp[0][0][j-1]+math[0][j])
dp[2][0][j]=max(dp[2][0][j-1], dp[1][0][j-1]+math[0][j])
dp[3][0][j]=max(dp[3][0][j-1], dp[2][0][j-1]+math[0][j])
for i in range(1, R):
dp[0][i][0]=max(dp[0][i-1][0], dp[1][i-1][0], dp[2][i-1][0], dp[3][i-1][0])
dp[1][i][0]=dp[0][i][0]+math[i][0]
for j in range(1, C):
dp[0][i][j]=max(dp[0][i][j-1], max(dp[0][i-1][j], dp[1][i-1][j], dp[2][i-1][j], dp[3][i-1][j]))
dp[1][i][j]=max(dp[1][i][j-1], dp[0][i][j-1]+math[i][j], max(dp[0][i-1][j], dp[1][i-1][j], dp[2][i-1][j], dp[3][i-1][j])+math[i][j])
dp[2][i][j]=max(dp[2][i][j-1], dp[1][i][j-1]+math[i][j])
dp[3][i][j]=max(dp[3][i][j-1], dp[2][i][j-1]+math[i][j])
print((max(dp[0][-1][-1], dp[1][-1][-1], dp[2][-1][-1], dp[3][-1][-1]))) | p02586 |
import base64
exec(base64.b64decode(b'import subprocess
import sys

code = r"""#pragma GCC optimize("unroll-loops")

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>

using namespace std;

using int64 = long long;

#define all(_) begin(_), end(_)
#define rall(_) rbegin(_), rend(_)

int64 dp[3000][3000][4];

namespace FastIO {
class Scanner {
  static constexpr int buf_size = (1 << 18);
  static constexpr int integer_size = 20;
  static constexpr int string_size = 1000; // default
  char buf[buf_size] = {};
  char *cur = buf, *ed = buf;

 public:
  Scanner() {}

  template <class T>
  inline Scanner& operator>>(T& val) {
    read(val);
    return *this;
  }

 private:
  inline void reload() {
    size_t len = ed - cur;
    memmove(buf, cur, len);
    char* tmp = buf + len;
    ed = tmp + fread(tmp, 1, buf_size - len, stdin);
    *ed = 0;
    cur = buf;
  }

  inline void skip_space() {
    while (true) {
      if (cur == ed) reload();
      while (*cur == ' ' || *cur == '\n') ++cur;
      if (__builtin_expect(cur != ed, 1)) return;
    }
  }

  template <class T, std::enable_if_t<std::is_same<T, int>::value, int> = 0>
  inline void read(T& num) {
    skip_space();
    if (cur + integer_size >= ed) reload();
    bool neg = false;
    num = 0;
    if (*cur == '-') neg = true, ++cur;
    while (*cur >= '0') num = num * 10 + (*cur ^ 48), ++cur;
    if (neg) num = -num;
  }

  template <class T, std::enable_if_t<std::is_same<T, int64>::value, int> = 0>
  inline void read(T& num) {
    skip_space();
    if (cur + integer_size >= ed) reload();
    bool neg = false;
    num = 0;
    if (*cur == '-') neg = true, ++cur;
    while (*cur >= '0') num = num * 10 + (*cur ^ 48), ++cur;
    if (neg) num = -num;
  }

  template <class T,
            std::enable_if_t<std::is_same<T, std::string>::value, int> = 0>
  inline void read(T& str) {
    skip_space();
    if (cur + str.size() >= ed) reload();
    auto it = cur;
    while (!(*cur == ' ' || *cur == '\n')) ++cur;
    str = std::string(it, cur);
  }

  template <class T, std::enable_if_t<std::is_same<T, char>::value, int> = 0>
  inline void read(T& c) {
    skip_space();
    if (cur + 1 >= ed) reload();
    c = *cur, ++cur;
  }

  template <class T, std::enable_if_t<std::is_same<T, double>::value, int> = 0>
  inline void read(T& num) {
    skip_space();
    if (cur + integer_size >= ed) reload();
    bool neg = false;
    num = 0;
    if (*cur == '-') neg = true, ++cur;
    while (*cur >= '0' && *cur <= '9') num = num * 10 + (*cur ^ 48), ++cur;
    if (*cur != '.') return;
    ++cur;
    T base = 0.1;
    while (*cur >= '0' && *cur <= '9') {
      num += base * (*cur ^ 48);
      ++cur;
      base *= 0.1;
    }
    if (neg) num = -num;
  }

  template <class T,
            std::enable_if_t<std::is_same<T, long double>::value, int> = 0>
  inline void read(T& num) {
    skip_space();
    if (cur + integer_size >= ed) reload();
    bool neg = false;
    num = 0;
    if (*cur == '-') neg = true, ++cur;
    while (*cur >= '0' && *cur <= '9') num = num * 10 + (*cur ^ 48), ++cur;
    if (*cur != '.') return;
    ++cur;
    T base = 0.1;
    while (*cur >= '0' && *cur <= '9') {
      num += base * (*cur ^ 48);
      ++cur;
      base *= 0.1;
    }
    if (neg) num = -num;
  }

  template <class T>
  inline void read(std::vector<T>& vec) {
    for (T& e : vec) read(e);
  }

  template <class T, class U>
  inline void read(std::pair<T, U>& p) {
    read(p.first, p.second);
  }

  template <class Tuple, std::size_t... Is>
  inline void tuple_scan(Tuple& tp, std::index_sequence<Is...>) {
    (read(std::get<Is>(tp)), ...);
  }

  template <class... Args>
  inline void read(std::tuple<Args...>& tp) {
    tuple_scan(tp, std::index_sequence_for<Args...>{});
  }

  inline void read() {}

  template <class Head, class... Tail>
  inline void read(Head&& head, Tail&&... tail) {
    read(head);
    read(std::forward<Tail>(tail)...);
  }
};

class Printer {
  static constexpr int buf_size = (1 << 18);
  static constexpr int integer_size = 20;
  static constexpr int string_size = (1 << 6);
  static constexpr int margin = 1;
  static constexpr int n = 10000;
  char buf[buf_size + margin] = {};
  char table[n * 4] = {};
  char* cur = buf;

 public:
  constexpr Printer() { build(); }

  ~Printer() { flush(); }

  template <class T>
  inline Printer& operator<<(T val) {
    write(val);
    return *this;
  }

  template<class T>
  inline void println(T val) {
    write(val);
    write('\n');
  }

 private:
  constexpr void build() {
    for (int i = 0; i < 10000; ++i) {
      int tmp = i;
      for (int j = 3; j >= 0; --j) {
        table[i * 4 + j] = tmp % 10 + '0';
        tmp /= 10;
      }
    }
  }

  inline void flush() {
    fwrite(buf, 1, cur - buf, stdout);
    cur = buf;
  }

  template <class T, std::enable_if_t<std::is_same<T, int>::value, int> = 0>
  inline int get_digit(T n) {
    if (n >= (int)1e5) {
      if (n >= (int)1e8) return 9;
      if (n >= (int)1e7) return 8;
      if (n >= (int)1e6) return 7;
      return 6;
    } else {
      if (n >= (int)1e4) return 5;
      if (n >= (int)1e3) return 4;
      if (n >= (int)1e2) return 3;
      if (n >= (int)1e1) return 2;
      return 1;
    }
  }

  template <class T, std::enable_if_t<std::is_same<T, int64>::value, int> = 0>
  inline int get_digit(T n) {
    if (n >= (int64)1e10) {
      if (n >= (int64)1e14) {
        if (n >= (int64)1e18) return 19;
        if (n >= (int64)1e17) return 18;
        if (n >= (int64)1e16) return 17;
        if (n >= (int64)1e15) return 16;
        return 15;
      } else {
        if (n >= (int64)1e14) return 15;
        if (n >= (int64)1e13) return 14;
        if (n >= (int64)1e12) return 13;
        if (n >= (int64)1e11) return 12;
        return 11;
      }
    } else {
      if (n >= (int64)1e5) {
        if (n >= (int64)1e9) return 10;
        if (n >= (int64)1e8) return 9;
        if (n >= (int64)1e7) return 8;
        if (n >= (int64)1e6) return 7;
        return 6;
      } else {
        if (n >= (int64)1e4) return 5;
        if (n >= (int64)1e3) return 4;
        if (n >= (int64)1e2) return 3;
        if (n >= (int64)1e1) return 2;
        return 1;
      }
    }
  }

  template <class T, std::enable_if_t<std::is_same<T, int>::value, int> = 0>
  inline void write(T num) {
    if (__builtin_expect(cur + integer_size >= buf + buf_size, 0)) flush();
    if (num == 0) {
      write('0');
      return;
    }
    if (num < 0) {
      write('-');
      num = -num;
    }
    int len = get_digit(num);
    int digits = len;
    while (num >= 10000) {
      memcpy(cur + len - 4, table + (num % 10000) * 4, 4);
      num /= 10000;
      len -= 4;
    }
    memcpy(cur, table + num * 4 + (4 - len), len);
    cur += digits;
  }

  template <class T, std::enable_if_t<std::is_same<T, int64>::value, int> = 0>
  inline void write(T num) {
    if (__builtin_expect(cur + integer_size >= buf + buf_size, 0)) flush();
    if (num == 0) {
      write('0');
      return;
    }
    if (num < 0) {
      write('-');
      num = -num;
    }
    int len = get_digit(num);
    int digits = len;
    while (num >= 10000) {
      memcpy(cur + len - 4, table + (num % 10000) * 4, 4);
      num /= 10000;
      len -= 4;
    }
    memcpy(cur, table + num * 4 + (4 - len), len);
    cur += digits;
  }

  template <class T, std::enable_if_t<std::is_same<T, char>::value, int> = 0>
  inline void write(T c) {
    if (__builtin_expect(cur + 1 >= buf + buf_size, 0)) flush();
    *cur = c;
    ++cur;
  }

  template <class T,
            std::enable_if_t<std::is_same<T, std::string>::value, int> = 0>
  inline void write(T str) {
    if (__builtin_expect(cur + str.size() >= buf + buf_size, 0)) flush();
    for (char c : str) write(c);
  }

  template <class T,
            std::enable_if_t<std::is_same<T, const char*>::value, int> = 0>
  inline void write(T str) {
    if (__builtin_expect(cur + string_size >= buf + buf_size, 0)) flush();
    for (int i = 0; str[i]; ++i) write(str[i]);
  }
};
}  // namespace FastIO

FastIO::Scanner fin;
FastIO::Printer fout;


int main() {
  int r, c, k; fin >> r >> c >> k;
  int val[r][c];
  fill(val[0], val[r], 0);
  for (int i = 0; i < k; ++i) {
    int x, y, z; fin >> x >> y >> z;
    --x; --y;
    val[x][y] = z;
  }

  if (val[0][0] != 0) dp[0][0][1] = val[0][0];

  for (int i = 0; i < r; ++i) {
    for (int j = 0; j < c; ++j) {
      if (i == 0 && j == 0) continue;

      if (val[i][j] != 0) {
        if (i > 0) {
          for (int l = 0; l < 4; ++l) dp[i][j][0] = max(dp[i][j][0], dp[i - 1][j][l]);
          for (int l = 0; l < 4; ++l) dp[i][j][1] = max(dp[i][j][1], dp[i - 1][j][l] + val[i][j]);
        }
        if (j > 0) {
          dp[i][j][0] = max(dp[i][j][0], dp[i][j - 1][0]);
          for (int l = 1; l < 4; ++l) {
            dp[i][j][l] = max({dp[i][j][l], dp[i][j - 1][l], dp[i][j - 1][l - 1] + val[i][j]});
          }
        }
      } else {
        if (i > 0) {
          for (int l = 0; l < 4; ++l) dp[i][j][0] = max(dp[i][j][0], dp[i - 1][j][l]);
        }
        if (j > 0) {
          for (int l = 0; l < 4; ++l) dp[i][j][l] = max(dp[i][j][l], dp[i][j - 1][l]);
        }
      }
    }
  }

  int64 ans = 0;
  for (int i = 0; i < 4; ++i) ans = max(ans, dp[r - 1][c - 1][i]);
  fout.println(ans);

  return 0;
}
"""

with open('sol.cpp', 'w') as f:
    f.write(code)

subprocess.Popen(['g++', '-std=c++17', '-O2', 'sol.cpp']).communicate()
subprocess.Popen(['./a.out'], stdin=sys.stdin, stdout=sys.stdout).communicate()')) | import base64
exec(base64.b64decode(b'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')) | p02586 |
R, C,K = list(map(int, input().split()))
dp = [[[0]*(C+1) for k in range(R+1)] for _ in range(4)]
# dp[r][c][j] :=r index c columns already j cnt
dp[0][0][0] = 0
D = [[0 for i in range(C+1)] for j in range(R+1)]
import random
for i in range(K):
r, c, v = list(map(int,input().split()))
D[r][c] = v
for i in range(R+1):
for j in range(C+1):
if D[i][j] > 0:
v = D[i][j]
M = max(dp[k][i-1][j] for k in range(4))
dp[0][i][j] = max(dp[0][i][j-1], M)
dp[1][i][j] = max(dp[0][i][j-1]+v, dp[1][i][j-1], M+v)
dp[2][i][j] = max(dp[1][i][j-1]+v, dp[2][i][j-1])
dp[3][i][j] = max(dp[2][i][j-1]+v, dp[3][i][j-1])
else:
M = max(dp[k][i-1][j] for k in range(4))
dp[0][i][j] = max(dp[0][i][j-1], M)
dp[1][i][j] = dp[1][i][j-1]
dp[2][i][j] = dp[2][i][j-1]
dp[3][i][j] = dp[3][i][j-1]
ans = 0
for i in range(4):
ans = max(ans, dp[i][-1][-1])
print(ans)
| ## 一時間もTLEのために時間を無駄にした 学びもないつまんない問題...
R, C, K = list(map(int, input().split()))
dp = [[[0]*(C+1) for _ in range(R+1)]for __ in range(4)]
# dp[r][c][j] :=r index c columns already j cnt
dp[0][0][0] = 0
D = [[0 for i in range(C+1)] for j in range(R+1)]
for i in range(K):
r, c, v = list(map(int, input().split()))
D[r][c] = v
for i in range(R+1):
for j in range(C+1):
if D[i][j] > 0:
v = D[i][j]
M = max(dp[k][i-1][j] for k in range(4))
dp[0][i][j] = max(dp[0][i][j-1], M)
dp[1][i][j] = max(dp[0][i][j-1]+v, dp[1][i][j-1], M+v)
dp[2][i][j] = max(dp[1][i][j-1]+v, dp[2][i][j-1])
dp[3][i][j] = max(dp[2][i][j-1]+v, dp[3][i][j-1])
else:
M = max(dp[k][i-1][j] for k in range(4))
dp[0][i][j] = max(dp[0][i][j-1], M)
dp[1][i][j] = dp[1][i][j-1]
dp[2][i][j] = dp[2][i][j-1]
dp[3][i][j] = dp[3][i][j-1]
ans = 0
for i in range(4):
ans = max(ans, dp[i][-1][-1])
print(ans)
| p02586 |
def main():
R, C, K = list(map(int, input().split()))
a = dict()
for _ in range(K):
r, c, v = list(map(int, input().split()))
a[(r-1, c-1)] = v
dp = [[[0]*4 for _ in range(C+1)] for _ in range(R+1)]
for i in range(R):
for j in range(C):
v = max(dp[i][j+1])
u = 0
if (i, j) in a: u = a[(i, j)]
dp[i+1][j+1][0] = max(dp[i+1][j+1][0], v)
dp[i+1][j+1][1] = max(dp[i+1][j+1][1], dp[i+1][j][1], dp[i+1][j][0] + u, v + u)
dp[i+1][j+1][2] = max(dp[i+1][j+1][2], dp[i+1][j][2], dp[i+1][j][1] + u )
dp[i+1][j+1][3] = max(dp[i+1][j+1][3], dp[i+1][j][3], dp[i+1][j][2] + u )
return max(dp[R][C])
if __name__ == '__main__':
print((main()))
| def main():
R, C, K = list(map(int, input().split()))
a = dict()
for _ in range(K):
r, c, v = list(map(int, input().split()))
a[(r-1, c-1)] = v
dp = [[[0]*4 for _ in range(C+1)] for _ in range(2)]
for i in range(R):
for j in range(C):
v = max(dp[0][j+1])
u = 0
if (i, j) in a: u = a[(i, j)]
dp[1][j+1][0] = max(dp[1][j+1][0], v)
dp[1][j+1][1] = max(dp[1][j+1][1], dp[1][j][1], dp[1][j][0] + u, v + u)
dp[1][j+1][2] = max(dp[1][j+1][2], dp[1][j][2], dp[1][j][1] + u )
dp[1][j+1][3] = max(dp[1][j+1][3], dp[1][j][3], dp[1][j][2] + u )
dp[1], dp[0] = dp[0], dp[1]
return max(dp[0][C])
if __name__ == '__main__':
print((main())) | p02586 |
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
#read = sys.stdin.buffer.read
def main():
global field
R, C, K = list(map(int, input().split()))
field = []
for _ in range(R):
tmp = [0] * C
field.append(tmp)
DP0 = copy.deepcopy(field)
DP1 = copy.deepcopy(field)
DP2 = copy.deepcopy(field)
DP3 = copy.deepcopy(field)
for _ in range(K):
r, c, k = list(map(int, input().split()))
field[r-1][c-1] = k
i = 0
DP1[0][0] = field[0][0]
for j in range(1, C):
DP3[i][j] = max(DP2[i][j-1] + field[i][j], DP3[i][j-1])
DP2[i][j] = max(DP1[i][j-1] + field[i][j], DP2[i][j-1])
DP1[i][j] = max(DP0[i][j-1] + field[i][j], DP1[i][j-1])
DP0[i][j] = DP0[i][j-1]
for i in range(1, R):
for j in range(C):
DP3[i][j] = max(DP2[i][j-1] + field[i][j], DP3[i][j-1])
DP2[i][j] = max(DP1[i][j-1] + field[i][j], DP2[i][j-1])
DP1[i][j] = max(DP0[i][j-1] + field[i][j], DP1[i][j-1], max(DP0[i-1][j], DP1[i-1][j], DP2[i-1][j], DP3[i-1][j]) + field[i][j])
DP0[i][j] = max(DP0[i][j-1], DP0[i-1][j], DP1[i-1][j], DP2[i-1][j], DP3[i-1][j])
ans = max(DP3[R-1][C-1], DP2[R-1][C-1], DP1[R-1][C-1], DP0[R-1][C-1])
print(ans)
if __name__ == "__main__":
main()
| import sys
import copy
from collections import deque
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
#read = sys.stdin.buffer.read
def main():
global field
R, C, K = list(map(int, input().split()))
field = []
for _ in range(R):
tmp = [0] * C
field.append(tmp)
DP1 = copy.deepcopy(field)
DP2 = copy.deepcopy(field)
DP3 = copy.deepcopy(field)
for _ in range(K):
r, c, k = list(map(int, input().split()))
field[r-1][c-1] = k
i = 0
DP1[0][0] = field[0][0]
for j in range(1, C):
DP3[i][j] = max(DP2[i][j-1] + field[i][j], DP3[i][j-1])
DP2[i][j] = max(DP1[i][j-1] + field[i][j], DP2[i][j-1])
DP1[i][j] = max(field[i][j], DP1[i][j-1])
for i in range(1, R):
for j in range(C):
DP3[i][j] = max(DP2[i][j-1] + field[i][j], DP3[i][j-1])
DP2[i][j] = max(DP1[i][j-1] + field[i][j], DP2[i][j-1])
DP1[i][j] = max(field[i][j], DP1[i][j-1], max(DP1[i-1][j], DP2[i-1][j], DP3[i-1][j]) + field[i][j])
ans = max(DP3[R-1][C-1], DP2[R-1][C-1], DP1[R-1][C-1])
print(ans)
if __name__ == "__main__":
main()
| p02586 |
f=lambda:list(map(int,input().split()))
R,C,K=f()
g=[[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r,c,v=f()
g[r][c]=v
dp=[[[0]*4 for _ in range(C+2)] for _ in range(R+2)]
for i in range(1,R+1):
for j in range(1,C+1):
for k in range(3,-1,-1):
if k: dp[i][j][k]=max(dp[i][j][k],dp[i][j][k-1]+g[i][j])
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k])
dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k])
print((max(dp[R][C][k] for k in range(4)))) | f=lambda:list(map(int,input().split()))
R,C,K=f()
g=[[0]*(R+1) for _ in range(C+1)]
for _ in range(K):
r,c,v=f()
g[c][r]=v
dp=[[0]*4 for _ in range(R+1)]
for i in range(1,C+1):
for j in range(1,R+1):
t=g[i][j]
if t:
for k in range(3,0,-1):
dp[j][k]=max(dp[j][k],dp[j][k-1]+t)
dp[j][1]=max(dp[j][k],max(dp[j-1])+t)
dp[j][0]=max(dp[j][0],max(dp[j-1]))
print((max(dp[R]))) | p02586 |
f=lambda:list(map(int,input().split()))
R,C,K=f()
g=[[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r,c,v=f()
g[r][c]=v
dp=[[[0]*(C+2) for _ in range(R+2)] for _ in range(4)]
for i in range(1,R+1):
for j in range(1,C+1):
for k in range(3,-1,-1):
if k: dp[k][i][j]=max(dp[k][i][j],dp[k-1][i][j]+g[i][j])
dp[0][i+1][j]=max(dp[0][i+1][j],dp[k][i][j])
dp[k][i][j+1]=max(dp[k][i][j+1],dp[k][i][j])
print((max(dp[i][R][C] for i in range(4)))) | f=lambda:list(map(int,input().split()))
R,C,K=f()
g=[[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r,c,v=f()
g[r][c]=v
dp=[[[0]*(C+2) for _ in range(R+2)] for _ in range(4)]
for i in range(1,R+1):
for j in range(1,C+1):
for k in range(3,-1,-1):
if k: dp[k][i][j]=max(dp[k][i][j],dp[k-1][i][j]+g[i][j])
dp[0][i+1][j]=max(dp[0][i+1][j],dp[k][i][j])
dp[k][i][j+1]=max(dp[k][i][j+1],dp[k][i][j])
print((max(dp[k][R][C] for k in range(4)))) | p02586 |
import sys
input = sys.stdin.readline
R, C, K = list(map(int, input().split()))
items = dict()
for _ in range(K):
r, c, v = list(map(int, input().split()))
items[(r-1,c-1)] = v
dp = [0] * 4 * R * C
if (0,0) in items:
dp[1] = items[(0,0)]
def ind(i,j,k):
return 4 * C * i + 4 * j + k
for row in range(R):
for col in range(C):
for pick in range(4):
curr = dp[ind(row,col,pick)]
#Go Right
if col + 1 < C:
dp[ind(row,col+1,pick)] = max(curr, dp[ind(row,col+1,pick)])
if (row, col+1) in items and pick < 3:
dp[ind(row,col+1,pick+1)] = max(curr + items[(row,col+1)], dp[ind(row,col+1,pick+1)])
#Go Down
if row + 1 < R:
dp[ind(row+1,col,0)] = max(curr, dp[ind(row+1,col,0)])
if (row + 1, col) in items:
dp[ind(row+1,col,1)] = max(curr + items[(row+1,col)], dp[ind(row+1,col,1)])
print((max(dp)))
| import sys
input = sys.stdin.readline
R, C, K = list(map(int, input().split()))
items = [0] * R * C
for _ in range(K):
r, c, v = list(map(int, input().split()))
items[C * (r-1) + c-1] = v
dp = [0] * 4 * R * C
dp[1] = items[0]
def ind(i,j,k):
return 4 * C * i + 4 * j + k
for row in range(R):
for col in range(C):
for pick in range(4):
curr = dp[ind(row,col,pick)]
#Go Right
if col + 1 < C:
dp[ind(row,col+1,pick)] = max(curr, dp[ind(row,col+1,pick)])
if pick < 3:
dp[ind(row,col+1,pick+1)] = max(curr + items[C * row + col+1], dp[ind(row,col+1,pick+1)])
#Go Down
if row + 1 < R:
dp[ind(row+1,col,0)] = max(curr, dp[ind(row+1,col,0)])
dp[ind(row+1,col,1)] = max(curr + items[C * (row+1) + col], dp[ind(row+1,col,1)])
print((max(dp)))
| p02586 |
import bisect
import sys,io
import math
from collections import deque
from heapq import heappush, heappop
input = sys.stdin.buffer.readline
def sRaw():
return input().rstrip("\r")
def iRaw():
return int(eval(input()))
def ssRaw():
return input().split()
def isRaw():
return list(map(int, ssRaw()))
INF = 1 << 29
DIV = (10**9) + 7
#DIV = 998244353
def mod_inv_prime(a, mod=DIV):
return pow(a, mod-2, mod)
def mod_inv(a, b):
r = a
w = b
u = 1
v = 0
while w != 0:
t = r//w
r -= t*w
r, w = w, r
u -= t*v
u, v = v, u
return (u % b+b) % b
def CONV_TBL(max, mod=DIV):
fac, finv, inv = [0]*max, [0]*max, [0]*max
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, max):
fac[i] = fac[i-1]*i % mod
inv[i] = mod - inv[mod % i] * (mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
class CONV:
def __init__(self):
self.fac = fac
self.finv = finv
pass
def ncr(self, n, k):
if(n < k):
return 0
if(n < 0 or k < 0):
return 0
return fac[n]*(finv[k]*finv[n-k] % DIV) % DIV
return CONV()
def cumsum(As):
s = 0
for a in As:
s += a
yield s
sys.setrecursionlimit(200005)
def dijkstra(G,start=0):
heap = []
cost = [INF]*len(G)
heappush(heap,(0,start))
while len(heap)!=0:
c,n = heappop(heap)
if cost[n] !=INF:
continue
cost[n]=c
for e in G[n]:
ec,v = e
if cost[v]!=INF:
continue
heappush(heap,(ec+c,v))
return cost
def main():
R,C,K = isRaw()
mas = [[0 for _ in range(C)]for _ in range(R)]
for k in range(K):
r,c,v = isRaw()
mas[r-1][c-1]=v
dp = [[[0 for _ in range(4)]for _ in range(C)] for r in range(R)]
dp[0][0][1]=mas[0][0]
dp[0][0][2]=mas[0][0]
dp[0][0][3]=mas[0][0]
for r in range(R):
for c in range(C):
if r>0:
dp[r][c][0] = max(dp[r][c][0],dp[r-1][c][-1] )
dp[r][c][1] = max(dp[r][c][1],dp[r-1][c][-1]+mas[r][c])
dp[r][c][2] = max(dp[r][c][2],dp[r-1][c][-1]+mas[r][c])
dp[r][c][3] = max(dp[r][c][3],dp[r-1][c][-1]+mas[r][c])
if c>0:
dp[r][c][0] = max(dp[r][c][0],dp[r][c-1][0])
dp[r][c][1] = max(dp[r][c][1], dp[r][c-1][1], dp[r][c-1][0]+mas[r][c])
dp[r][c][2] = max(dp[r][c][2], dp[r][c-1][2], dp[r][c-1][1]+mas[r][c])
dp[r][c][3] = max(dp[r][c][3], dp[r][c-1][3], dp[r][c-1][2]+mas[r][c])
print((max([dp[-1][-1][ni] for ni in range(4)])))
main()
| import bisect
import sys,io
import math
from collections import deque
from heapq import heappush, heappop
input = sys.stdin.buffer.readline
def sRaw():
return input().rstrip("\r")
def iRaw():
return int(eval(input()))
def ssRaw():
return input().split()
def isRaw():
return list(map(int, ssRaw()))
INF = 1 << 29
DIV = (10**9) + 7
#DIV = 998244353
def mod_inv_prime(a, mod=DIV):
return pow(a, mod-2, mod)
def mod_inv(a, b):
r = a
w = b
u = 1
v = 0
while w != 0:
t = r//w
r -= t*w
r, w = w, r
u -= t*v
u, v = v, u
return (u % b+b) % b
def CONV_TBL(max, mod=DIV):
fac, finv, inv = [0]*max, [0]*max, [0]*max
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, max):
fac[i] = fac[i-1]*i % mod
inv[i] = mod - inv[mod % i] * (mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
class CONV:
def __init__(self):
self.fac = fac
self.finv = finv
pass
def ncr(self, n, k):
if(n < k):
return 0
if(n < 0 or k < 0):
return 0
return fac[n]*(finv[k]*finv[n-k] % DIV) % DIV
return CONV()
def cumsum(As):
s = 0
for a in As:
s += a
yield s
sys.setrecursionlimit(200005)
def dijkstra(G,start=0):
heap = []
cost = [INF]*len(G)
heappush(heap,(0,start))
while len(heap)!=0:
c,n = heappop(heap)
if cost[n] !=INF:
continue
cost[n]=c
for e in G[n]:
ec,v = e
if cost[v]!=INF:
continue
heappush(heap,(ec+c,v))
return cost
def main():
R,C,K = isRaw()
mas = [[0 for _ in range(C)]for _ in range(R)]
for k in range(K):
r,c,v = isRaw()
mas[r-1][c-1]=v
dp = [[[0 for _ in range(C)] for _ in range(R)] for _ in range(3)]
dp0 = dp[0]
dp1 = dp[1]
dp2 = dp[2]
dp0[0][0]=mas[0][0]
dp1[0][0]=mas[0][0]
dp2[0][0]=mas[0][0]
for r in range(R):
for c in range(C):
mrc = mas[r][c]
dp0[r][c] = mrc
dp1[r][c] = mrc
dp2[r][c] = mrc
if r>0:
dp0[r][c] = max(dp0[r][c], dp2[r-1][c]+mrc)
dp1[r][c] = max(dp1[r][c], dp2[r-1][c]+mrc)
dp2[r][c] = max(dp2[r][c], dp2[r-1][c]+mrc)
if c>0:
dp0[r][c] = max(dp0[r][c], dp0[r][c-1], mrc)
dp1[r][c] = max(dp1[r][c], dp1[r][c-1], dp0[r][c-1]+mrc)
dp2[r][c] = max(dp2[r][c], dp2[r][c-1], dp1[r][c-1]+mrc)
print((max([dp[ni][-1][-1] for ni in range(3)])))
main()
| p02586 |
R,C,K=list(map(int,input().split()))
l=[[0] * C for i in range(R)]
dp=[[[0] * 4 for i in range(C)] for j in range(R)]
for i in range(K):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
l[a][b]=c
dp[0][0][1]=l[0][0]
for x in range(1,R+C-1):
for y in range(R):
i=y
j=x-y
if j<0 or C<=j:
continue
for k in range(4):
A=0
if 0<j:
A=max(A,dp[i][j-1][k])
if 0<k:
A=max(A,dp[i][j-1][k-1]+l[i][j])
if 0<i and k<2:
for q in range(4):
A=max(A,dp[i-1][j][q]+k*l[i][j])
dp[i][j][k]=A
X=dp[R-1][C-1][3]
for k in range(3):
X=max(X,dp[R-1][C-1][k])
print(X)
| R,C,K=list(map(int,input().split()))
l=[[0] * C for i in range(R)]
for i in range(K):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
l[a][b]=c
dp=[0]*C
for i in range(R):
ndp=[0]*C
kdp=[0]*4
kdp[0]=dp[0]
kdp[1]=l[i][0]+dp[0]
ndp[0]=kdp[1]
for j in range(1,C):
kdp[0]=max(kdp[0],dp[j])
for k in range(2,-1,-1):
kdp[k+1]=max(kdp[k+1],kdp[k]+l[i][j])
ndp[j]=max(kdp)
dp=ndp
print((dp[C-1])) | p02586 |
R,C,K=list(map(int,input().split()))
l=[[0] * C for i in range(R)]
for i in range(K):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
l[a][b]=c
dp=[0]*C
for i in range(R):
ndp=[0]*C
kdp=[0]*4
kdp[0]=dp[0]
kdp[1]=l[i][0]+dp[0]
ndp[0]=kdp[1]
for j in range(1,C):
kdp[0]=max(kdp[0],dp[j])
for k in range(2,-1,-1):
kdp[k+1]=max(kdp[k+1],kdp[k]+l[i][j])
ndp[j]=max(kdp)
dp=ndp
print((dp[C-1])) | R,C,K=list(map(int,input().split()))
l=[[0] * C for i in range(R)]
for i in range(K):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
l[a][b]=c
dp=[0]*C
for i in range(R):
ndp=[0]*C
kdp=[0]*4
for j in range(0,C):
kdp[0]=max(kdp[0],dp[j])
for k in range(2,-1,-1):
kdp[k+1]=max(kdp[k+1],kdp[k]+l[i][j])
ndp[j]=max(kdp)
dp=ndp
print((dp[C-1])) | p02586 |
R,C,K=list(map(int,input().split()))
l=[[0] * C for i in range(R)]
for i in range(K):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
l[a][b]=c
dp=[0]*C
for i in range(R):
ndp=[0]*C
kdp=[0]*4
for j in range(0,C):
kdp[0]=max(kdp[0],dp[j])
for k in range(2,-1,-1):
kdp[k+1]=max(kdp[k+1],kdp[k]+l[i][j])
ndp[j]=max(kdp)
dp=ndp
print((dp[C-1]))
| R,C,K=list(map(int,input().split()))
l=[[0] * C for i in range(R)]
for i in range(K):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
l[a][b]=c
dp=[[0] * C for i in range(R)]
for i in range(R):
kdp=[0]*4
for j in range(C):
if i>0:
kdp[0]=max(kdp[0],dp[i-1][j])
for k in range(2,-1,-1):
kdp[k+1]=max(kdp[k+1],kdp[k]+l[i][j])
dp[i][j]=max(dp[i][j],kdp[k+1])
print((dp[R-1][C-1])) | p02586 |
#!/usr/bin/env python3
import collections
import sys
input=sys.stdin.readline
r,c,k=list(map(int,input().split()))
items=collections.defaultdict(int)
for _ in range(k):
tr,tc,tv=list(map(int,input().split()))
items[(tr,tc)]=tv
dp=[[[0]*4 for _ in range(c+1)] for _ in range(r+1)]
for i in range(1,r+1):
for j in range(1,c+1):
tv=items[(i,j)]
left_max=max(dp[i-1][j])
#左から来るときは取った個数をリセットする
dp[i][j][0]=max(dp[i][j-1][0],left_max)
dp[i][j][1]=max(dp[i][j-1][1],dp[i][j-1][0]+tv,left_max+tv)
dp[i][j][2]=max(dp[i][j-1][2],dp[i][j-1][1]+tv)
dp[i][j][3]=max(dp[i][j-1][3],dp[i][j-1][2]+tv)
print((max(dp[r][c]))) | #!/usr/bin/env python3
import sys
input=sys.stdin.readline
r,c,k=list(map(int,input().split()))
items=[0]*(r*c)
for _ in range(k):
tr,tc,tv=list(map(int,input().split()))
items[c*(tr-1)+tc-1]=tv
dp=[0]*(4*r*c)
for i in range(1,r+1):
for j in range(1,c+1):
tv=items[c*(i-1)+j-1]
change_pos=4*(c*(i-1)+j-1)
left_pos=4*(c*(i-2)+j-1)
up_pos=4*(c*(i-1)+j-2)
if i!=1:
left_max=max(dp[left_pos],dp[left_pos+1],dp[left_pos+2],dp[left_pos+3])
else:
left_max=0
if j!=1:
dp[change_pos]=max(dp[up_pos],left_max)
dp[change_pos+1]=max(dp[up_pos+1],dp[up_pos]+tv,left_max+tv)
dp[change_pos+2]=max(dp[up_pos+2],dp[up_pos+1]+tv)
dp[change_pos+3]=max(dp[up_pos+3],dp[up_pos+2]+tv)
else:
dp[change_pos]=left_max
dp[change_pos+1]=left_max+tv
print((max(dp[-1],dp[-2],dp[-3],dp[-4]))) | p02586 |
import sys
input=sys.stdin.readline
def main():
r,c,k=list(map(int,input().split()))
v=dict()
for _ in range(k):
ri,ci,a=list(map(int,input().split()))
ri-=1
ci-=1
v[(ri,ci)]=a
dp=[[[0]*4 for _ in range(c)] for i in range(r)]
#print(dp)
if (0,0) in v:
if v[(0,0)]>0:
dp[0][0][1]=v[(0,0)]
for i in range(r):
for j in range(c):
if i>0:
if (i,j) in v:
if v[(i,j)]>0:
for k in range(min(3,j+1)+1):
dp[i][j][1]=max(dp[i][j][1],dp[i-1][j][k]+v[(i,j)])
for k in range(4):
dp[i][j][k]=max(dp[i][j][k],dp[i-1][j][k])
if j>0:
if (i,j) in v:
if v[(i,j)]>0:
for k in range(min(3,j+1)+1):
if k>0:
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k-1]+v[(i,j)])
for k in range(4):
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k])
#print(dp)
print((max(dp[r-1][c-1])))
if __name__=="__main__":
main() | import sys
input=sys.stdin.readline
def main():
r,c,k=map(int,input().split())
v=[[0]*c for _ in range(r)]
for _ in range(k):
ri,ci,a=map(int,input().split())
ri-=1
ci-=1
v[ri][ci]=a
dp=[[[0]*c for _ in range(r)] for i in range(4)]
#print(dp)
if v[0][0]>0:
dp[1][0][0]=v[0][0]
for i in range(r):
for j in range(c):
for k in range(4):
if i>0:
dp[1][i][j]=max(dp[1][i][j],dp[k][i-1][j]+v[i][j])
dp[0][i][j]=max(dp[0][i][j],dp[k][i-1][j])
if j>0:
if k>0:
dp[k][i][j]=max(dp[k][i][j],dp[k-1][i][j-1]+v[i][j])
dp[k][i][j]=max(dp[k][i][j],dp[k][i][j-1])
#print(dp)
ans=0
for i in range(4):
ans=max(dp[i][r-1][c-1],ans)
return print(ans)
if __name__=="__main__":
main()
| p02586 |
def main(R,C,K,V):
dp = [[[0,0,0,0] for _ in range(C)] for _ in range(R)]
dp[0][0][1] = V[0][0]
for i in range(R):
for j in range(C):
for n in range(4):
if n!=0:
if i != 0 and n==1:
dp[i][j][n] = max(dp[i-1][j][0],dp[i-1][j][1],dp[i-1][j][2],dp[i-1][j][3])+V[i][j]
if j != 0:
dp[i][j][n] = max(dp[i][j][n],dp[i][j-1][n],dp[i][j-1][n-1]+V[i][j])
if n==0:
if i != 0:
dp[i][j][n] = max(dp[i-1][j][0],dp[i-1][j][1],dp[i-1][j][2],dp[i-1][j][3])
print((max(dp[-1][-1])))
if __name__ == '__main__':
R,C,K = list(map(int,input().split()))
rcv = [list(map(int,input().split())) for _ in range(K)]
V = [[0]*C for _ in range(R)]
for i in range(K):
r,c,v = rcv[i]
r -= 1
c -= 1
V[r][c] = v
main(R,C,K,V) | def main(R,C,K,V):
dp = [0]*(4*R*C)
dp[1+4*0+4*C*0] = V[0][0]
for k in range(4*R*C):
n = k%4
j = k//4%C
i = k//(4*C)
if n!=0:
if i != 0 and n==1:
dp[k] = max(dp[k-4*C-n:k-4*C-n+4])+V[i][j]
if j != 0:
dp[k] = max(dp[k],dp[k-4],dp[k-5]+V[i][j])
if n==0:
if i != 0:
dp[k] = max(dp[k-4*C-n:k-4*C-n+4])
print((max(dp[-5:-1])))
if __name__ == '__main__':
R,C,K = list(map(int,input().split()))
C += 1
rcv = [list(map(int,input().split())) for _ in range(K)]
V = [[0]*C for _ in range(R)]
for i in range(K):
r,c,v = rcv[i]
r -= 1
c -= 1
V[r][c] = v
main(R,C,K,V) | p02586 |
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def a_int(): return int(read())
def ints(): return list(map(int, read().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, zip(*ret)))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
'''
dp[i][j]...(0,0)からスタートして(i,j)に到達する経路のなかでの最大の価値
dp[i][j]=max(dp[i][j-1],dp[i-1][j]) + v[i][j]
dp[i][j][k] ... (0,0)からスタートして(i,j)に到達する経路のなかでi行目ですでにk(以下)個選んでいるときの最大の価値
遷移は、i,jのvを拾うときと拾わないときのmax
dp[i][j][k] = max(dp[i][j-1][k-1]+V[i,j], dp[i][j-1][k]
) #k個のままのほうが価値が高いかk-1から拾ったほうが価値が高いか
上からの遷移 # 拾うか拾わないかでこうかな
dp[i][j][0]=max(dp[i][j-1][0],max_k(dp[i-1][j]))
dp[i][j][1]=max(dp[i][j-1][0],max_k(dp[i-1][j][k])+V[i][j])
'''
R, C, K = ints()
RCV = read_tuple(K)
V = [[0] * C for _ in ra(R)]
for r, c, v in RCV:
V[r - 1][c - 1] = v
# dp = [[[0] * 4 for _ in ra(C)] for _ in ra(R)]
dp0 = [[0] * C for _ in ra(R)]
dp1 = [[0] * C for _ in ra(R)]
dp2 = [[0] * C for _ in ra(R)]
dp3 = [[0] * C for _ in ra(R)]
# dp[0][0][0] = 0
dp1[0][0] = V[0][0]
dp2[0][0] = V[0][0]
dp3[0][0] = V[0][0]
for j in ra(1, C):
dp1[0][j] = max(dp1[0][j - 1], dp0[0][j - 1] + V[0][j])
dp2[0][j] = max(dp2[0][j - 1], dp1[0][j - 1] + V[0][j])
dp3[0][j] = max(dp3[0][j - 1], dp2[0][j - 1] + V[0][j])
for i in ra(1, R):
dp0[i][0] = dp1[i - 1][0]
dp1[i][0] = dp0[i][0] + V[i][0]
# dp2[i][0] = dp0[i][0] + V[i][0]
# dp3[i][0] = dp0[i][0] + V[i][0]
for i in ra(1, R):
for j in ra(1, C):
ma = max(dp0[i - 1][j],
dp1[i - 1][j],
dp2[i - 1][j],
dp3[i - 1][j])
dp0[i][j] = max(dp0[i][j - 1], # 左
ma) # 上
dp1[i][j] = max(dp0[i][j - 1] + V[i][j], # 左から来て拾う
dp1[i][j - 1], # 拾わないほうが大きい場合もある
ma + V[i][j]) # 上から来て拾う
dp2[i][j] = max(dp1[i][j - 1] + V[i][j], dp2[i][j - 1])
dp3[i][j] = max(dp2[i][j - 1] + V[i][j], dp3[i][j - 1])
print(max(dp0[R - 1][C - 1],
dp1[R - 1][C - 1],
dp2[R - 1][C - 1],
dp3[R - 1][C - 1],
))
# print(*values, sep='\n')
# print(*dp, sep='\n')
# dp2 = [[-1] * C for _ in ra(R)]
# for i in ra(R):
# for j in ra(C):
# dp2[i][j] = max(dp[i][j])
# print(*dp2, sep='\n')
| import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def a_int(): return int(read())
def ints(): return list(map(int, read().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, zip(*ret)))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
'''
dp[i][j]...(0,0)からスタートして(i,j)に到達する経路のなかでの最大の価値
dp[i][j]=max(dp[i][j-1],dp[i-1][j]) + v[i][j]
dp[i][j][k] ... (0,0)からスタートして(i,j)に到達する経路のなかでi行目ですでにk(以下)個選んでいるときの最大の価値
遷移は、i,jのvを拾うときと拾わないときのmax
dp[i][j][k] = max(dp[i][j-1][k-1]+V[i,j], dp[i][j-1][k]
) #k個のままのほうが価値が高いかk-1から拾ったほうが価値が高いか
上からの遷移 # 拾うか拾わないかでこうかな
dp[i][j][0]=max(dp[i][j-1][0],max_k(dp[i-1][j]))
dp[i][j][1]=max(dp[i][j-1][0],max_k(dp[i-1][j][k])+V[i][j])
'''
R, C, K = ints()
RCV = read_tuple(K)
V = [[0] * C for _ in ra(R)]
for r, c, v in RCV:
V[r - 1][c - 1] = v
# dp = [[[0] * 4 for _ in ra(C)] for _ in ra(R)]
dp0 = [[0] * C for _ in ra(R)]
dp1 = [[0] * C for _ in ra(R)]
dp2 = [[0] * C for _ in ra(R)]
dp3 = [[0] * C for _ in ra(R)]
# dp[0][0][0] = 0
dp1[0][0] = V[0][0]
dp2[0][0] = V[0][0]
dp3[0][0] = V[0][0]
for j in ra(1, C):
dp1[0][j] = max(dp1[0][j - 1], dp0[0][j - 1] + V[0][j])
dp2[0][j] = max(dp2[0][j - 1], dp1[0][j - 1] + V[0][j])
dp3[0][j] = max(dp3[0][j - 1], dp2[0][j - 1] + V[0][j])
for i in ra(1, R):
dp0[i][0] = dp1[i - 1][0]
dp1[i][0] = dp0[i][0] + V[i][0]
dp2[i][0] = dp0[i][0] + V[i][0]
dp3[i][0] = dp0[i][0] + V[i][0]
for i in ra(1, R):
for j in ra(1, C):
ma = max(dp0[i - 1][j],
dp1[i - 1][j],
dp2[i - 1][j],
dp3[i - 1][j])
dp0[i][j] = max(dp0[i][j - 1], # 左
ma) # 上
if ma > max(dp3[i][j - 1], dp2[i][j - 1], dp1[i][j - 1]): # 上から採用
dp1[i][j] = ma + V[i][j]
dp2[i][j] = ma + V[i][j]
dp3[i][j] = ma + V[i][j]
else: # 横から採用
dp1[i][j] = max(dp0[i][j - 1] + V[i][j], # 左から来て拾う
dp1[i][j - 1], # 拾わないほうが大きい場合もある
ma + V[i][j]) # 上から来て拾う
dp2[i][j] = max(dp1[i][j - 1] + V[i][j], dp2[i][j - 1])
dp3[i][j] = max(dp2[i][j - 1] + V[i][j], dp3[i][j - 1])
print(max(dp0[R - 1][C - 1],
dp1[R - 1][C - 1],
dp2[R - 1][C - 1],
dp3[R - 1][C - 1],
))
# print(*values, sep='\n')
# print(*dp3, sep='\n')
# dp2 = [[-1] * C for _ in ra(R)]
# for i in ra(R):
# for j in ra(C):
# dp2[i][j] = max(dp[i][j])
# print(*dp2, sep='\n')
| p02586 |
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
r, c, k = LI()
maze = [[0] * c for _ in range(r)]
for _ in range(k):
R, C, V = LI()
maze[R-1][C-1] = V
dp1 = [[0] * (c+1) for _ in range(r+1)]
dp2 = [[0] * (c+1) for _ in range(r+1)]
dp3 = [[0] * (c+1) for _ in range(r+1)]
for i in range(1, r+1):
for j in range(1, c+1):
dp1[i][j] = max(dp1[i][j-1], dp1[i-1][j] + maze[i-1][j-1], maze[i-1][j-1], dp2[i-1][j] + maze[i-1][j-1], dp3[i-1][j] + maze[i-1][j-1])
dp2[i][j] = max(dp2[i][j-1], dp2[i-1][j], dp1[i][j-1] + maze[i-1][j-1])
dp3[i][j] = max(dp3[i][j-1], dp3[i-1][j], dp2[i][j-1] + maze[i-1][j-1])
ans = max(dp1[-1][-1], dp2[-1][-1], dp3[-1][-1])
print(ans) | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
r, c, k = LI()
maze = [[0] * (c+1) for _ in range(r+1)]
for _ in range(k):
R, C, V = LI()
maze[R][C] = V
dp1 = [[0] * (c+1) for _ in range(r+1)]
dp2 = [[0] * (c+1) for _ in range(r+1)]
dp3 = [[0] * (c+1) for _ in range(r+1)]
for i in range(1, r+1):
for j in range(1, c+1):
dp1[i][j] = max(dp1[i][j-1], dp1[i-1][j] + maze[i][j], dp2[i-1][j] + maze[i][j], dp3[i-1][j] + maze[i][j])
dp2[i][j] = max(dp2[i][j-1], dp1[i][j-1] + maze[i][j])
dp3[i][j] = max(dp3[i][j-1], dp2[i][j-1] + maze[i][j])
ans = max(dp1[-1][-1], dp2[-1][-1], dp3[-1][-1])
print(ans) | p02586 |
#!/usr/bin/env python3
r, c, k = list(map(int, input().split()))
items = [[0] * (c+1) for _ in range(r+1)]
for _ in range(k):
R, C, V = list(map(int, input().split()))
items[R][C] = V
dp0 = [[0] * (c+1) for _ in range(r+1)]
dp1 = [[0] * (c+1) for _ in range(r+1)]
dp2 = [[0] * (c+1) for _ in range(r+1)]
dp3 = [[0] * (c+1) for _ in range(r+1)]
for i in range(1, r+1):
for j in range(1, c+1):
dp0[i][j] = max(dp0[i][j-1], dp0[i-1][j], dp1[i-1][j], dp2[i-1][j], dp3[i-1][j])
dp1[i][j] = max(dp1[i][j-1], dp0[i-1][j] + items[i][j], dp1[i-1][j] + items[i][j], dp2[i-1][j] + items[i][j], dp3[i-1][j] + items[i][j], dp0[i][j-1] + items[i][j])
dp2[i][j] = max(dp2[i][j-1], dp1[i][j-1] + items[i][j])
dp3[i][j] = max(dp3[i][j-1], dp2[i][j-1] + items[i][j])
ans = max(dp0[r][c], dp1[r][c], dp2[r][c], dp3[r][c])
print(ans) | #!/usr/bin/env python3
r, c, k = list(map(int, input().split()))
items = [[0] * (c+1) for _ in range(r+1)]
for _ in range(k):
R, C, V = list(map(int, input().split()))
items[R][C] = V
dp1 = [[0] * (c+1) for _ in range(r+1)]
dp2 = [[0] * (c+1) for _ in range(r+1)]
dp3 = [[0] * (c+1) for _ in range(r+1)]
for i in range(1, r+1):
for j in range(1, c+1):
dp1[i][j] = max(dp1[i][j-1], dp1[i-1][j] + items[i][j], dp2[i-1][j] + items[i][j], dp3[i-1][j] + items[i][j])
dp2[i][j] = max(dp2[i][j-1], dp1[i][j-1] + items[i][j])
dp3[i][j] = max(dp3[i][j-1], dp2[i][j-1] + items[i][j])
ans = max(dp1[r][c], dp2[r][c], dp3[r][c])
print(ans) | p02586 |
#!/usr/bin/env python3
r, c, k = list(map(int, input().split()))
items = [[0] * (c+1) for _ in range(r+1)]
for _ in range(k):
R, C, V = list(map(int, input().split()))
items[R][C] = V
dp1 = [[0] * (c+1) for _ in range(r+1)]
dp2 = [[0] * (c+1) for _ in range(r+1)]
dp3 = [[0] * (c+1) for _ in range(r+1)]
for i in range(1, r+1):
for j in range(1, c+1):
dp1[i][j] = max(dp1[i][j-1], dp1[i-1][j] + items[i][j], dp2[i-1][j] + items[i][j], dp3[i-1][j] + items[i][j])
dp2[i][j] = max(dp2[i][j-1], dp1[i][j-1] + items[i][j])
dp3[i][j] = max(dp3[i][j-1], dp2[i][j-1] + items[i][j])
ans = max(dp1[r][c], dp2[r][c], dp3[r][c])
print(ans) | #!/usr/bin/env python3
r, c, k = list(map(int, input().split()))
items = [[0] * (c+1) for _ in range(r+1)]
for _ in range(k):
R, C, V = list(map(int, input().split()))
items[R][C] = V
dp1 = [[0] * (c+1) for _ in range(r+1)]
dp2 = [[0] * (c+1) for _ in range(r+1)]
dp3 = [[0] * (c+1) for _ in range(r+1)]
for i in range(1, r+1):
for j in range(1, c+1):
v = items[i][j]
dp1[i][j] = max(dp1[i][j-1], dp1[i-1][j] + v, dp2[i-1][j] + v, dp3[i-1][j] + v)
dp2[i][j] = max(dp2[i][j-1], dp1[i][j-1] + v)
dp3[i][j] = max(dp3[i][j-1], dp2[i][j-1] + v)
ans = max(dp1[r][c], dp2[r][c], dp3[r][c])
print(ans) | p02586 |
R,C,K = list(map(int,input().split()))
goods = [[-1]*(C+1) for _ in range(R+1)]
INF = 10**18
for i in range(K):
ri,ci,vi = list(map(int,input().split()))
goods[ri][ci] = vi
DP = [[[-INF,-INF,-INF,-INF] for _ in range(C+1)] for _ in range(R+1)]
DP[1][1][0] = 0
if goods[1][1] != -1:
DP[1][1][1] = goods[1][1]
for j in range(1,C):
DP[1][j+1][0] = 0
if goods[1][j+1] != -1:
DP[1][j+1][1] = max(DP[1][j][1],DP[1][j][0]+goods[1][j+1])
DP[1][j+1][2] = max(DP[1][j][2],DP[1][j][1]+goods[1][j+1])
DP[1][j+1][3] = max(DP[1][j][3],DP[1][j][2]+goods[1][j+1])
else:
DP[1][j+1][1] = DP[1][j][1]
DP[1][j+1][2] = DP[1][j][2]
DP[1][j+1][3] = DP[1][j][3]
for i in range(1,R):
DP[i+1][1][0] = max(DP[i][1])
if goods[i+1][1] != -1:
DP[i+1][1][1] = DP[i+1][1][0] + goods[i+1][1]
for i in range(2,R+1):
for j in range(2,C+1):
DP[i][j][0] = max(max(DP[i-1][j]),DP[i][j-1][0])
if goods[i][j] != -1:
DP[i][j][1] = max(DP[i][j][0]+goods[i][j],DP[i][j-1][1])
DP[i][j][2] = max(DP[i][j-1][2],DP[i][j-1][1]+goods[i][j])
DP[i][j][3] = max(DP[i][j-1][3],DP[i][j-1][2]+goods[i][j])
else:
DP[i][j][1] = DP[i][j-1][1]
DP[i][j][2] = DP[i][j-1][2]
DP[i][j][3] = DP[i][j-1][3]
print((max(DP[R][C]))) | import sys
input = sys.stdin.buffer.readline
R,C,K = list(map(int,input().split()))
goods = [[-1]*(C+1) for _ in range(R+1)]
INF = 10**16
for i in range(K):
ri,ci,vi = list(map(int,input().split()))
goods[ri][ci] = vi
DP = [[[-INF,-INF,-INF,-INF] for _ in range(C+1)] for _ in range(R+1)]
DP[1][1][0] = 0
if goods[1][1] != -1:
DP[1][1][1] = goods[1][1]
for j in range(1,C):
DP[1][j+1][0] = 0
if goods[1][j+1] != -1:
DP[1][j+1][1] = max(DP[1][j][1],DP[1][j][0]+goods[1][j+1])
DP[1][j+1][2] = max(DP[1][j][2],DP[1][j][1]+goods[1][j+1])
DP[1][j+1][3] = max(DP[1][j][3],DP[1][j][2]+goods[1][j+1])
else:
DP[1][j+1][1] = DP[1][j][1]
DP[1][j+1][2] = DP[1][j][2]
DP[1][j+1][3] = DP[1][j][3]
for i in range(1,R):
DP[i+1][1][0] = max(DP[i][1])
if goods[i+1][1] != -1:
DP[i+1][1][1] = DP[i+1][1][0] + goods[i+1][1]
for i in range(2,R+1):
for j in range(2,C+1):
DP[i][j][0] = max(max(DP[i-1][j]),DP[i][j-1][0])
if goods[i][j] != -1:
DP[i][j][1] = max(DP[i][j][0]+goods[i][j],DP[i][j-1][1])
DP[i][j][2] = max(DP[i][j-1][2],DP[i][j-1][1]+goods[i][j])
DP[i][j][3] = max(DP[i][j-1][3],DP[i][j-1][2]+goods[i][j])
else:
DP[i][j][1] = DP[i][j-1][1]
DP[i][j][2] = DP[i][j-1][2]
DP[i][j][3] = DP[i][j-1][3]
print((max(DP[R][C]))) | p02586 |
import sys
def input():
return sys.stdin.buffer.readline()[:-1]
n, m, q = list(map(int, input().split()))
g = [[0 for _ in range(m)] for _ in range(n)]
for _ in range(q):
r, c, v = list(map(int, input().split()))
g[r-1][c-1] = v
dp = [[[0 for _ in range(4)] for _ in range(m)] for _ in range(n)]
dp[0][0][1] = g[0][0]
for i in range(n):
for j in range(m):
if i > 0:
dp[i][j][0] = max(dp[i][j][0], max(dp[i-1][j]))
if j > 0:
dp[i][j][0] = max(dp[i][j][0], dp[i][j-1][0])
for k in range(1, 4):
dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k])
dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k-1] + g[i][j])
if i > 0:
dp[i][j][1] = max(dp[i][j][1], max(dp[i-1][j]) + g[i][j])
if i > 0 and j == 0:
dp[i][0][1] = max(dp[i][0][1], max(dp[i-1][0]) + g[i][j])
print((max(dp[n-1][m-1]))) | import sys
def input():
return sys.stdin.buffer.readline()[:-1]
n, m, q = list(map(int, input().split()))
g = [[0 for _ in range(m)] for _ in range(n)]
for _ in range(q):
r, c, v = list(map(int, input().split()))
g[r-1][c-1] = v
pre = [0 for _ in range(m)]
dp = [[0 for _ in range(4)] for _ in range(m)]
dp[0][1] = g[0][0]
for i in range(n):
for j in range(m):
dp[j][0] = max(dp[j][0], pre[j])
if j > 0:
dp[j][0] = max(dp[j][0], dp[j-1][0])
for k in range(1, 4):
dp[j][k] = max(dp[j][k], dp[j-1][k])
dp[j][k] = max(dp[j][k], dp[j-1][k-1] + g[i][j])
if i > 0:
dp[j][1] = max(dp[j][1], pre[j] + g[i][j])
else:
dp[0][1] = max(dp[0][1], pre[0] + g[i][j])
pre = [max(dp[j]) for j in range(m)]
dp = [[0 for _ in range(4)] for _ in range(m)]
print((pre[-1])) | p02586 |
import sys
read = sys.stdin.buffer.read
readlines = sys.stdin.buffer.readlines
input = sys.stdin.buffer.readline
H, W, K = list(map(int, input().split()))
B = {}
for _ in range(K):
r, c, v = list(map(int, input().split()))
B[(r-1,c-1)] = v
dp = [[0]*(W+1) for _ in range(4)]
for i in range(H):
for j in range(W):
if (i, j) in B:
v = B[(i, j)]
dp[0][j+1] = max(dp[0][j], dp[0][j+1], dp[1][j+1], dp[2][j+1], dp[3][j+1])
dp[1][j+1] = max(dp[1][j], dp[0][j+1]+v)
dp[2][j+1] = max(dp[2][j], dp[1][j]+v)
dp[3][j+1] = max(dp[3][j], dp[2][j]+v)
else:
dp[0][j+1] = max(dp[0][j], dp[0][j+1], dp[1][j+1], dp[2][j+1], dp[3][j+1])
dp[1][j+1] = dp[1][j]
dp[2][j+1] = dp[2][j]
dp[3][j+1] = dp[3][j]
print((max(dp[i][-1] for i in range(4)))) | import sys
input = sys.stdin.buffer.readline
H, W, K = list(map(int, input().split()))
B = {}
for _ in range(K):
r, c, v = list(map(int, input().split()))
B[(r, c)] = v
dp = [[0]*(W+1) for _ in range(4)]
for i in range(1, H+1):
for j in range(1, W+1):
if (i, j) in B:
v = B[(i, j)]
dp[0][j] = max(dp[0][j-1], dp[0][j], dp[1][j], dp[2][j], dp[3][j])
dp[1][j] = max(dp[1][j-1], dp[0][j]+v)
dp[2][j] = max(dp[2][j-1], dp[1][j-1]+v)
dp[3][j] = max(dp[3][j-1], dp[2][j-1]+v)
else:
dp[0][j] = max(dp[0][j-1], dp[0][j], dp[1][j], dp[2][j], dp[3][j])
dp[1][j] = dp[1][j-1]
dp[2][j] = dp[2][j-1]
dp[3][j] = dp[3][j-1]
print((max(dp[i][-1] for i in range(4))))
| p02586 |
# Fast IO (only use in integer input)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
R,C,K = list(map(int,input().split()))
DP = []
Gift = []
for i in range(R):
DP.append([])
Gift.append([])
for _ in range(C):
DP[i].append([0,0,0,0])
Gift[i].append(0)
for _ in range(K):
r,c,v = list(map(int,input().split()))
Gift[r-1][c-1] = v
for i in range(R):
for j in range(C):
if i != 0 and j != 0:
DP[i][j][0] = max(DP[i-1][j][0],DP[i-1][j][1],DP[i-1][j][2],DP[i-1][j][3],DP[i][j-1][0])
DP[i][j][1] = DP[i][j-1][1]
DP[i][j][2] = DP[i][j-1][2]
DP[i][j][3] = DP[i][j-1][3]
if Gift[i][j]:
DP[i][j][3] = max(DP[i][j][3],DP[i][j][2] + Gift[i][j])
DP[i][j][2] = max(DP[i][j][2],DP[i][j][1] + Gift[i][j])
DP[i][j][1] = max(DP[i][j][1],DP[i][j][0] + Gift[i][j])
elif i == 0:
DP[i][j][0] = DP[i][j-1][0]
DP[i][j][1] = DP[i][j-1][1]
DP[i][j][2] = DP[i][j-1][2]
DP[i][j][3] = DP[i][j-1][3]
if Gift[i][j]:
DP[i][j][3] = max(DP[i][j][3],DP[i][j][2] + Gift[i][j])
DP[i][j][2] = max(DP[i][j][2],DP[i][j][1] + Gift[i][j])
DP[i][j][1] = max(DP[i][j][1],DP[i][j][0] + Gift[i][j])
elif j == 0:
DP[i][j][0] = max(DP[i-1][j][0],DP[i-1][j][1],DP[i-1][j][2],DP[i-1][j][3])
if Gift[i][j]:
DP[i][j][3] = max(DP[i][j][3],DP[i][j][2] + Gift[i][j])
DP[i][j][2] = max(DP[i][j][2],DP[i][j][1] + Gift[i][j])
DP[i][j][1] = max(DP[i][j][1],DP[i][j][0] + Gift[i][j])
else:
DP[i][j][1] = Gift[i][j]
print((max(DP[R-1][C-1]))) | # Fast IO (only use in integer input)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
R,C,K = list(map(int,input().split()))
DP = []
Gift = []
for i in range(R):
DP.append([])
Gift.append([])
for _ in range(C):
DP[i].append([0,0,0,0])
Gift[i].append(0)
for _ in range(K):
r,c,v = list(map(int,input().split()))
Gift[r-1][c-1] = v
for i in range(R):
DPi = DP[i]
for j in range(C):
DPij = DPi[j]
if i != 0 and j != 0:
DPij[0] = max(DP[i-1][j][0],DP[i-1][j][1],DP[i-1][j][2],DP[i-1][j][3],DP[i][j-1][0])
DPij[1] = DP[i][j-1][1]
DPij[2] = DP[i][j-1][2]
DPij[3] = DP[i][j-1][3]
if Gift[i][j]:
DPij[3] = max(DPij[3],DPij[2] + Gift[i][j])
DPij[2] = max(DPij[2],DPij[1] + Gift[i][j])
DPij[1] = max(DPij[1],DPij[0] + Gift[i][j])
elif i == 0:
DPij[0] = DP[i][j-1][0]
DPij[1] = DP[i][j-1][1]
DPij[2] = DP[i][j-1][2]
DPij[3] = DP[i][j-1][3]
if Gift[i][j]:
DPij[3] = max(DPij[3],DPij[2] + Gift[i][j])
DPij[2] = max(DPij[2],DPij[1] + Gift[i][j])
DPij[1] = max(DPij[1],DPij[0] + Gift[i][j])
elif j == 0:
DPij[0] = max(DP[i-1][j][0],DP[i-1][j][1],DP[i-1][j][2],DP[i-1][j][3])
if Gift[i][j]:
DPij[3] = max(DPij[3],DPij[2] + Gift[i][j])
DPij[2] = max(DPij[2],DPij[1] + Gift[i][j])
DPij[1] = max(DPij[1],DPij[0] + Gift[i][j])
else:
DPij[1] = Gift[i][j]
print((max(DP[R-1][C-1]))) | p02586 |
# Fast IO (only use in integer input)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
R,C,K = list(map(int,input().split()))
DP = []
Gift = []
for i in range(R):
DP.append([])
Gift.append([])
for _ in range(C):
DP[i].append([0,0,0,0])
Gift[i].append(0)
for _ in range(K):
r,c,v = list(map(int,input().split()))
Gift[r-1][c-1] = v
for i in range(R):
if i > 2:
DP[i - 2] = 0
DPi = DP[i]
for j in range(C):
DPij = DPi[j]
if i != 0 and j != 0:
DPij[0] = max(DP[i-1][j][0],DP[i-1][j][1],DP[i-1][j][2],DP[i-1][j][3],DP[i][j-1][0])
DPij[1] = DP[i][j-1][1]
DPij[2] = DP[i][j-1][2]
DPij[3] = DP[i][j-1][3]
if Gift[i][j]:
DPij[3] = max(DPij[3],DPij[2] + Gift[i][j])
DPij[2] = max(DPij[2],DPij[1] + Gift[i][j])
DPij[1] = max(DPij[1],DPij[0] + Gift[i][j])
elif i == 0:
DPij[0] = DP[i][j-1][0]
DPij[1] = DP[i][j-1][1]
DPij[2] = DP[i][j-1][2]
DPij[3] = DP[i][j-1][3]
if Gift[i][j]:
DPij[3] = max(DPij[3],DPij[2] + Gift[i][j])
DPij[2] = max(DPij[2],DPij[1] + Gift[i][j])
DPij[1] = max(DPij[1],DPij[0] + Gift[i][j])
elif j == 0:
DPij[0] = max(DP[i-1][j][0],DP[i-1][j][1],DP[i-1][j][2],DP[i-1][j][3])
if Gift[i][j]:
DPij[3] = max(DPij[3],DPij[2] + Gift[i][j])
DPij[2] = max(DPij[2],DPij[1] + Gift[i][j])
DPij[1] = max(DPij[1],DPij[0] + Gift[i][j])
else:
DPij[1] = Gift[i][j]
print((max(DP[R-1][C-1]))) | # Fast IO (only use in integer input)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
R,C,K = list(map(int,input().split()))
Gift = []
for i in range(R):
Gift.append([])
for _ in range(C):
Gift[i].append(0)
for _ in range(K):
r,c,v = list(map(int,input().split()))
Gift[r-1][c-1] = v
for i in range(R):
DPi = [None] * C
for j in range(C):
DPi[j] = [0,0,0,0]
DPij = DPi[j]
DPijs1 = DPi[j-1]
if i != 0 and j != 0:
DPij[0] = max(DPLast[j][0],DPLast[j][1],DPLast[j][2],DPLast[j][3],DPijs1[0])
DPij[1] = DPijs1[1]
DPij[2] = DPijs1[2]
DPij[3] = DPijs1[3]
if Gift[i][j]:
DPij[3] = max(DPij[3],DPij[2] + Gift[i][j])
DPij[2] = max(DPij[2],DPij[1] + Gift[i][j])
DPij[1] = max(DPij[1],DPij[0] + Gift[i][j])
elif i == 0 and j != 0:
DPij[0] = DPijs1[0]
DPij[1] = DPijs1[1]
DPij[2] = DPijs1[2]
DPij[3] = DPijs1[3]
if Gift[i][j]:
DPij[3] = max(DPij[3],DPij[2] + Gift[i][j])
DPij[2] = max(DPij[2],DPij[1] + Gift[i][j])
DPij[1] = max(DPij[1],DPij[0] + Gift[i][j])
elif j == 0 and i != 0:
DPij[0] = max(DPLast[j][0],DPLast[j][1],DPLast[j][2],DPLast[j][3])
if Gift[i][j]:
DPij[3] = max(DPij[3],DPij[2] + Gift[i][j])
DPij[2] = max(DPij[2],DPij[1] + Gift[i][j])
DPij[1] = max(DPij[1],DPij[0] + Gift[i][j])
else:
DPij[1] = Gift[i][j]
DPLast = DPi
print((max(DPi[C-1]))) | p02586 |
# -*- coding: utf-8 -*-
R,C,K = list(map(int, input().split()))
items = [[0 for _ in range(C+1)] for _ in range(R+1)]
for i in range(K):
r,c,v = list(map(int, input().split()))
items[r][c] = v
DP_prev = [0 for _ in range(C+1)]
for r in range(1,R+1):
DP = [[0 for _ in range(C+1)],[0 for _ in range(C+1)],[0 for _ in range(C+1)]]
for c in range(1,C+1):
item = items[r][c]
DP1 = max(DP_prev[c]+item,DP[0][c-1])
DP2 = max(DP1,DP[1][c-1],DP[0][c-1]+item)
DP3 = max(DP2,DP[2][c-1],DP[1][c-1]+item)
DP[0][c] = DP1
DP[1][c] = DP2
DP[2][c] = DP3
DP_prev = DP[2]
print((DP_prev[C])) | # -*- coding: utf-8 -*-
R,C,K = list(map(int, input().split()))
items = [[0 for _ in range(C+1)] for _ in range(R+1)]
for i in range(K):
r,c,v = list(map(int, input().split()))
items[r][c] = v
DP_prev = [0 for _ in range(C+1)]
for r in range(1,R+1):
DP1 = [0 for _ in range(C+1)]
DP2 = [0 for _ in range(C+1)]
DP3 = [0 for _ in range(C+1)]
for c in range(1,C+1):
item = items[r][c]
DP1[c] = max(DP_prev[c]+item,DP1[c-1])
DP2[c] = max(DP1[c],DP2[c-1],DP1[c-1]+item)
DP3[c] = max(DP2[c],DP3[c-1],DP2[c-1]+item)
DP_prev = DP3
print((DP_prev[C])) | p02586 |
import sys
input = sys.stdin.readline
r,c,K=list(map(int, input().split()))
grid=[[0]*(c+1) for _ in range(r+1)]
for i in range(K):
ri,ci,vi=list(map(int, input().split()))
grid[ri][ci]=vi
dp=[[[0]*4 for _ in range(c+1)] for _ in range(r+1)]
for i in range(1,r+1):
for j in range(1,c+1):
dp[i][j][0]=max(dp[i][j][0],max(dp[i-1][j]))
v=grid[i][j]
if v==0:
for k in range(4):
dp[i][j][k]=max(dp[i][j][k],dp[i][j-1][k])
else:
dp[i][j][0]=max(dp[i][j][0],dp[i][j-1][0])
dp[i][j][1]=max(dp[i][j][1],max(dp[i-1][j])+v,dp[i][j-1][1])
dp[i][j][2]=max(dp[i][j][2],dp[i][j-1][1]+v,dp[i][j-1][2])
dp[i][j][3]=max(dp[i][j][3],dp[i][j-1][2]+v,dp[i][j-1][3])
print((max(dp[-1][-1]))) | R,C,K = list(map(int,input().split()))
grid=[[0]*C for _ in range(R)]
for i in range(K):
x,y,v = list(map(int,input().split()))
grid[x-1][y-1] = v
dp1 = [[0]*(C+1) for _ in range(R+1)]
dp2 = [[0]*(C+1) for _ in range(R+1)]
dp3 = [[0]*(C+1) for _ in range(R+1)]
for i in range(R):
for j in range(C):
dp1[i][j] = max(dp1[i][j-1],dp1[i-1][j]+grid[i][j],
dp2[i-1][j]+grid[i][j],dp3[i-1][j]+grid[i][j])
dp2[i][j] = max(dp2[i][j-1],dp1[i][j-1]+grid[i][j])
dp3[i][j] = max(dp3[i][j-1],dp2[i][j-1]+grid[i][j])
ans=0
for i in range(R):
for j in range(C):
ans=max(ans,dp1[i][j],dp2[i][j],dp3[i][j])
print(ans) | p02586 |
R,C,K = list(map(int,input().split()))
grid=[[0]*C for _ in range(R)]
for i in range(K):
x,y,v = list(map(int,input().split()))
grid[x-1][y-1] = v
dp1 = [[0]*(C+1) for _ in range(R+1)]
dp2 = [[0]*(C+1) for _ in range(R+1)]
dp3 = [[0]*(C+1) for _ in range(R+1)]
for i in range(R):
for j in range(C):
dp1[i][j] = max(dp1[i][j-1],dp1[i-1][j]+grid[i][j],
dp2[i-1][j]+grid[i][j],dp3[i-1][j]+grid[i][j])
dp2[i][j] = max(dp2[i][j-1],dp1[i][j-1]+grid[i][j])
dp3[i][j] = max(dp3[i][j-1],dp2[i][j-1]+grid[i][j])
ans=0
for i in range(R):
for j in range(C):
ans=max(ans,dp1[i][j],dp2[i][j],dp3[i][j])
print(ans) | R,C,K = list(map(int,input().split()))
grid=[[0]*C for _ in range(R)]
for i in range(K):
x,y,v = list(map(int,input().split()))
grid[x-1][y-1] = v
dp0 = [[0]*(C+1) for _ in range(R+1)]
dp1 = [[0]*(C+1) for _ in range(R+1)]
dp2 = [[0]*(C+1) for _ in range(R+1)]
dp3 = [[0]*(C+1) for _ in range(R+1)]
for i in range(R):
for j in range(C):
dp1[i][j] = max(dp1[i][j-1],dp1[i-1][j]+grid[i][j],
dp2[i-1][j]+grid[i][j],dp3[i-1][j]+grid[i][j])
dp2[i][j] = max(dp2[i][j-1],dp1[i][j-1]+grid[i][j])
dp3[i][j] = max(dp3[i][j-1],dp2[i][j-1]+grid[i][j])
ans=max(dp1[R-1][C-1],dp2[R-1][C-1],dp3[R-1][C-1])
print(ans) | p02586 |
import sys
def input(): return sys.stdin.readline().rstrip()
R, C, k = (int(x) for x in input().split())
V = [[0] * (C + 5) for _ in range(R + 5)]
for _ in range(k):
r, c, v = (int(x) for x in input().split())
V[r][c] = v
# dp[i][j][3]
dp = [[[0] * (C+5) for _ in range(R + 5)] for _ in range(4)]
for i in range(1, R + 3):
for j in range(1, C + 3):
# 行移動
dp[0][i][j] = max(dp[0][i][j], max(dp[k][i - 1][j] for k in range(4)))
dp[1][i][j] = max(dp[1][i][j], max(dp[k][i - 1][j] for k in range(4)) + V[i][j])
for k in range(4):
# 列移動
if k > 0:
dp[k][i][j] = max(dp[k][i][j], dp[k-1][i][j-1] + V[i][j])
dp[k][i][j] = max(dp[k][i][j], dp[k][i][j-1])
print((max(dp[k][R][C] for k in range(4))))
| import sys
def input(): return sys.stdin.readline().rstrip()
R, C, k = (int(x) for x in input().split())
V = [[0] * (C + 5) for _ in range(R + 5)]
for _ in range(k):
r, c, v = (int(x) for x in input().split())
V[r][c] = v
# dp[3][i][j]
dp = [[[0] * (C + 5) for _ in range(R + 5)] for _ in range(4)]
for i in range(R + 3):
for j in range(C + 3):
for k in range(4):
# 行移動
dp[0][i + 1][j] = max(dp[0][i + 1][j], dp[k][i][j])
dp[1][i + 1][j] = max(dp[1][i + 1][j], dp[k][i][j] + V[i + 1][j])
# 列移動
dp[k][i][j + 1] = max(dp[k][i][j + 1], dp[k][i][j])
if k < 3:
dp[k + 1][i][j + 1] = max(dp[k + 1][i][j + 1], dp[k][i][j] + V[i][j + 1])
print((max(dp[k][R][C] for k in range(4))))
| p02586 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
from decimal import Decimal, ROUND_CEILING
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
R, C, K = MAP()
dp = [[[0]*4 for _ in range(C+1)] for _ in range(R+1)]
field = [[0]*(C+1)] + [[0]*(C+1) for _ in range(R)]
for _ in range(K):
r, c, v = MAP()
field[r][c] = v
for i in range(1, R+1):
for j in range(1, C+1):
up_max = max(dp[i-1][j])
p = field[i][j]
dp[i][j][0] = max(up_max, dp[i][j-1][0])
dp[i][j][1] = max(up_max+p, dp[i][j-1][1], dp[i][j-1][0]+p)
dp[i][j][2] = max(dp[i][j-1][2], dp[i][j-1][1]+p)
dp[i][j][3] = max(dp[i][j-1][3], dp[i][j-1][2]+p)
print((max(dp[R][C])))
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
from decimal import Decimal, ROUND_CEILING
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
R, C, K = MAP()
dp1 = [[0]*4 for _ in range(C+1)]
dp2 = [[0]*4 for _ in range(C+1)]
field = [[0]*(C+1)] + [[0]*(C+1) for _ in range(R)]
for _ in range(K):
r, c, v = MAP()
field[r][c] = v
for i in range(1, R+1):
for j in range(1, C+1):
if i%2 == 0:
up_max = max(dp1[j])
p = field[i][j]
dp2[j][0] = max(up_max, dp1[j-1][0])
dp2[j][1] = max(up_max+p, dp2[j-1][1], dp2[j-1][0]+p)
dp2[j][2] = max(dp2[j-1][2], dp2[j-1][1]+p)
dp2[j][3] = max(dp2[j-1][3], dp2[j-1][2]+p)
else:
up_max = max(dp2[j])
p = field[i][j]
dp1[j][0] = max(up_max, dp2[j-1][0])
dp1[j][1] = max(up_max+p, dp1[j-1][1], dp1[j-1][0]+p)
dp1[j][2] = max(dp1[j-1][2], dp1[j-1][1]+p)
dp1[j][3] = max(dp1[j-1][3], dp1[j-1][2]+p)
a = max(dp1[-1])
b = max(dp2[-1])
print((max(a, b)))
| p02586 |
import sys
input = sys.stdin.readline
def solve():
INF = float('inf')
def max2(x, y): return x if x >= y else y
R, C, K = list(map(int, input().split()))
Vss = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
Vss[r][c] = v
dp = [[[-INF]*(4) for j in range(C+1)] for i in range(R+1)]
for i in range(R+1):
dp[i][0][0] = 0
for j in range(C+1):
dp[0][j][0] = 0
dpMax = [[0]*(C+1) for _ in range(R+1)]
for i in range(1, R+1):
for j in range(1, C+1):
V = Vss[i][j]
dp[i][j][0] = max2(dp[i][j-1][0], dpMax[i-1][j])
dp[i][j][1] = max2(dp[i][j][0] + V, dp[i][j-1][1])
dp[i][j][2] = max2(dp[i][j-1][1] + V, dp[i][j-1][2])
dp[i][j][3] = max2(dp[i][j-1][2] + V, dp[i][j-1][3])
dpMax[i][j] = max(dp[i][j])
ans = dpMax[R][C]
print(ans)
solve()
| import sys
input = sys.stdin.readline
def solve():
INF = float('inf')
def max2(x, y): return x if x >= y else y
R, C, K = list(map(int, input().split()))
Vss = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
Vss[r][c] = v
dpMax = [0]*(C+1)
for i in range(1, R+1):
dp0 = [0]*(C+1)
dp1 = [-INF]*(C+1)
dp2 = [-INF]*(C+1)
dp3 = [-INF]*(C+1)
for j in range(1, C+1):
V = Vss[i][j]
dp0[j] = max2(dp0[j-1], dpMax[j])
dp1[j] = max2(dp0[j] + V, dp1[j-1])
dp2[j] = max2(dp1[j-1] + V, dp2[j-1])
dp3[j] = max2(dp2[j-1] + V, dp3[j-1])
dpMax[j] = max(dp0[j], dp1[j], dp2[j], dp3[j])
ans = dpMax[C]
print(ans)
solve()
| p02586 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
import sys
sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(R, C, K, RCV):
V = [[0] * C for _ in range(R)]
for r, c, v in RCV:
V[r-1][c-1] = v
memo = [[[0] * 4 for _ in range(C+1)] for __ in range(R+1)]
for i in range(R):
for j in range(C):
for p in range(4):
memo[i][j+1][p] = max(memo[i][j+1][p], memo[i][j][p])
memo[i+1][j][0] = max(memo[i+1][j][0], memo[i][j][p])
if p != 3:
memo[i][j+1][p+1] = max(memo[i][j+1][p+1], memo[i][j][p] + V[i][j])
memo[i+1][j][0] = max(memo[i+1][j][0], memo[i][j][p] + V[i][j])
return max(memo[R-1][C])
def main():
R, C, K = read_int_n()
RCV = [read_int_n() for _ in range(K)]
print(slv(R, C, K, RCV))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
import sys
sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(R, C, K, RCV):
V = [[0] * C for _ in range(R)]
for r, c, v in RCV:
V[r-1][c-1] = v
memo = [[[0] * (C+1) for _ in range(R+1)] for __ in range(4)]
for i in range(R):
for j in range(C):
for p in range(4):
memo[p][i][j+1] = max(memo[p][i][j+1], memo[p][i][j])
memo[0][i+1][j] = max(memo[0][i+1][j], memo[p][i][j])
if p != 3:
memo[p+1][i][j+1] = max(memo[p+1][i][j+1], memo[p][i][j] + V[i][j])
memo[0][i+1][j] = max(memo[0][i+1][j], memo[p][i][j] + V[i][j])
return max(memo[0][-1])
def main():
R, C, K = read_int_n()
RCV = [read_int_n() for _ in range(K)]
print(slv(R, C, K, RCV))
if __name__ == '__main__':
main()
| p02586 |
def run():
# sys.stdin.readline()
import sys
input = sys.stdin.readline
r,c,k = list(map(int,input().split()))
t = [[0 for i in range(c)] for i in range(r)]
for i in range(k):
a,b,z = list(map(int,input().split()))
t[a-1][b-1] = z
dp = [[[0 for i in range(c)]for i in range(r)]for i in range(4)]
dp[0][0][0] = 0
dp[1][0][0] = t[0][0]
dp[2][0][0] = t[0][0]
dp[3][0][0] = t[0][0]
for i in range(r-1):
dp[0][i+1][0] = dp[1][i][0]
for j in range(1,4):
dp[j][i+1][0] = dp[1][i][0]+t[i+1][0]
for i in range(c-1):
dp[0][0][i+1] = 0
for j in range(1,4):
dp[j][0][i+1] = max(dp[1][0][i],t[0][i+1])
for j in range(2,4):
dp[j][0][i+1] = max(dp[2][0][i],dp[1][0][i]+t[0][i+1])
dp[3][0][i+1] = max(dp[3][0][i],dp[2][0][i]+t[0][i+1])
for i in range(r-1):
for j in range(c-1):
for s in range(0,4):
dp[s][i+1][j+1] = max(dp[0][i+1][j],dp[3][i][j+1])
for s in range(1,4):
dp[s][i+1][j+1] = max(dp[0][i+1][j]+t[i+1][j+1],dp[1][i+1][j],dp[3][i][j+1]+t[i+1][j+1])
for s in range(2,4):
dp[s][i+1][j+1] = max(dp[1][i+1][j]+t[i+1][j+1],dp[2][i+1][j],dp[3][i][j+1]+t[i+1][j+1])
dp[3][i+1][j+1] = max(dp[2][i+1][j]+t[i+1][j+1],dp[3][i+1][j],dp[3][i][j+1]+t[i+1][j+1])
print((dp[3][r-1][c-1]))
if __name__ == "__main__":
run() | def run():
# sys.stdin.readline()
import sys
input = sys.stdin.readline
r,c,k = list(map(int,input().split()))
t = [[0 for i in range(c)] for i in range(r)]
for i in range(k):
a,b,z = list(map(int,input().split()))
t[a-1][b-1] = z
t = tuple(t)
dp = [[[0 for i in range(c)]for i in range(r)]for i in range(4)]
dp[0][0][0] = 0
dp[1][0][0] = t[0][0]
dp[2][0][0] = t[0][0]
dp[3][0][0] = t[0][0]
for i in range(r-1):
dp[0][i+1][0] = dp[1][i][0]
for j in range(1,4):
dp[j][i+1][0] = dp[1][i][0]+t[i+1][0]
for i in range(c-1):
dp[0][0][i+1] = 0
for j in range(1,4):
dp[j][0][i+1] = max(dp[1][0][i],t[0][i+1])
for j in range(2,4):
dp[j][0][i+1] = max(dp[2][0][i],dp[1][0][i]+t[0][i+1])
dp[3][0][i+1] = max(dp[3][0][i],dp[2][0][i]+t[0][i+1])
for i in range(r-1):
for j in range(c-1):
for s in range(0,4):
dp[s][i+1][j+1] = max(dp[0][i+1][j],dp[3][i][j+1])
for s in range(1,4):
dp[s][i+1][j+1] = max(dp[0][i+1][j]+t[i+1][j+1],dp[1][i+1][j],dp[3][i][j+1]+t[i+1][j+1])
for s in range(2,4):
dp[s][i+1][j+1] = max(dp[1][i+1][j]+t[i+1][j+1],dp[2][i+1][j],dp[3][i][j+1]+t[i+1][j+1])
dp[3][i+1][j+1] = max(dp[2][i+1][j]+t[i+1][j+1],dp[3][i+1][j],dp[3][i][j+1]+t[i+1][j+1])
print((dp[3][r-1][c-1]))
if __name__ == "__main__":
run() | p02586 |
from sys import stdin
readline = stdin.readline
R, C, K = list(map(int, readline().split()))
goods = [[0] * C for _ in range(R)]
for _ in range(K):
r, c, v = list(map(int, readline().split()))
goods[r - 1][c - 1] = v
dp = [[[0] * 4 for _ in range(C + 1)] for _ in range(R + 1)]
for i in range(R):
for j in range(C):
if goods[i][j] != 0:
for k in range(2, -1, -1):
if dp[i][j][k] + goods[i][j] > dp[i][j][k + 1]:
dp[i][j][k + 1] = dp[i][j][k] + goods[i][j]
for k in range(4):
if dp[i][j][k] > dp[i][j + 1][k]:
dp[i][j + 1][k] = dp[i][j][k]
if dp[i][j][k] > dp[i + 1][j][0]:
dp[i + 1][j][0] = dp[i][j][k]
print((max(dp[R - 1][C - 1])))
| from sys import stdin
readline = stdin.readline
R, C, K = list(map(int, readline().split()))
goods = [[0] * C for _ in range(R)]
for _ in range(K):
r, c, v = list(map(int, readline().split()))
goods[r - 1][c - 1] = v
n = [0] * (C + 1)
for i in range(R):
c = [0] * 4
c[0] = n[0]
for j in range(C):
if goods[i][j] != 0:
for k in range(2, -1, -1):
if c[k] + goods[i][j] > c[k + 1]:
c[k + 1] = c[k] + goods[i][j]
for k in range(4):
if c[k] > n[j]:
n[j] = c[k]
if n[j + 1] > c[0]:
c[0] = n[j + 1]
print((max(c)))
| p02586 |
from sys import stdin
readline = stdin.readline
R, C, K = list(map(int, readline().split()))
goods = [[0] * C for _ in range(R)]
for _ in range(K):
r, c, v = list(map(int, readline().split()))
goods[r - 1][c - 1] = v
n = [0] * (C + 1)
for i in range(R):
c = [0] * 4
c[0] = n[0]
for j in range(C):
if goods[i][j] != 0:
for k in range(2, -1, -1):
if c[k] + goods[i][j] > c[k + 1]:
c[k + 1] = c[k] + goods[i][j]
for k in range(4):
if c[k] > n[j]:
n[j] = c[k]
if n[j + 1] > c[0]:
c[0] = n[j + 1]
print((max(c)))
| from sys import stdin
readline = stdin.readline
R, C, K = list(map(int, readline().split()))
goods = [[0] * C for _ in range(R)]
for _ in range(K):
r, c, v = list(map(int, readline().split()))
goods[r - 1][c - 1] = v
dp = [0] * (C + 1)
for i in range(R):
cur = [0] * 4
cur[0] = dp[0]
for j in range(C):
if goods[i][j] != 0:
for k in range(2, -1, -1):
cur[k + 1] = max(cur[k + 1], cur[k] + goods[i][j])
dp[j] = max(cur)
cur[0] = max(cur[0], dp[j + 1])
print((max(cur)))
| p02586 |
import sys
input = sys.stdin.buffer.readline
from collections import defaultdict
r,c,k = list(map(int,input().split()))
K = defaultdict(int)
for _ in range(k):
x,y,z= [int(i) for i in input().split()]
K[(x,y)] = z
dp = [[0]*(c+1) for _ in range(4)]
for i in range(1, r+1):
for j in range(1, c+1):
v = K[(i, j)]
dp[0][j] = max(dp[0][j-1], dp[0][j], dp[1][j], dp[2][j], dp[3][j])
dp[1][j] = max(dp[1][j-1], dp[0][j]+v) if v>0 else dp[1][j-1]
dp[2][j] = max(dp[2][j-1], dp[1][j-1]+v) if v>0 else dp[2][j-1]
dp[3][j] = max(dp[3][j-1], dp[2][j-1]+v) if v>0 else dp[3][j-1]
print((max(dp[i][-1] for i in range(4)))) | import sys
input = sys.stdin.buffer.readline
H, W, K = list(map(int, input().split()))
B = {}
for _ in range(K):
r, c, v = list(map(int, input().split()))
B[(r, c)] = v
dp = [[0]*(W+1) for _ in range(4)]
for i in range(1, H+1):
for j in range(1, W+1):
if (i, j) in B:
v = B[(i, j)]
dp[0][j] = max(dp[0][j-1], dp[0][j], dp[1][j], dp[2][j], dp[3][j])
dp[1][j] = max(dp[1][j-1], dp[0][j]+v)
dp[2][j] = max(dp[2][j-1], dp[1][j-1]+v)
dp[3][j] = max(dp[3][j-1], dp[2][j-1]+v)
else:
dp[0][j] = max(dp[0][j-1], dp[0][j], dp[1][j], dp[2][j], dp[3][j])
dp[1][j] = dp[1][j-1]
dp[2][j] = dp[2][j-1]
dp[3][j] = dp[3][j-1]
print((max(dp[i][-1] for i in range(4))))
| p02586 |
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def solve():
def chmax(i, j, c, val):dp[i][j][c]=max(dp[i][j][c],val)
dp = [[[-1] * 4 for _ in range(w+1)] for _ in range(h+1)]
dp[0][0][0] = 0
for i in range(h):
for j in range(w):
if aa[i][j]:
for c in range(2,-1,-1):
pre = dp[i][j][c]
if pre==-1:continue
chmax(i,j,c+1,dp[i][j][c]+aa[i][j])
for c in range(4):
pre = dp[i][j][c]
if pre == -1: continue
chmax(i+1,j,0,pre)
chmax(i,j+1,c,pre)
ans = max(dp[h-1][w-1])
print(ans)
h,w,k=MI()
aa=[[0]*w for _ in range(h)]
for _ in range(k):
i,j,v=MI()
aa[i-1][j-1]=v
solve()
| import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def solve():
dp0 = [0] * (w + 1)
dp1 = [0] * (w + 1)
dp2 = [0] * (w + 1)
dp3 = [0] * (w + 1)
for i in range(h):
for j in range(w):
v = vv[i * w + j]
if v:
dp3[j] = max(dp3[j], dp2[j] + v)
dp2[j] = max(dp2[j], dp1[j] + v)
dp1[j] = max(dp1[j], dp0[j] + v)
dp3[j + 1] = max(dp3[j + 1], dp3[j])
dp2[j + 1] = max(dp2[j + 1], dp2[j])
dp1[j + 1] = max(dp1[j + 1], dp1[j])
dp0[j] = max(dp1[j], dp2[j], dp3[j])
print(dp0[-2])
h, w, k = MI()
vv = [0] * h * w
for _ in range(k):
i, j, v = MI()
i, j = i - 1, j - 1
vv[i * w + j] = v
solve()
| p02586 |
import sys
import math
from collections import defaultdict
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(eval(input()))
NMI = lambda: list(map(int, input().split()))
NLI = lambda: list(NMI())
SI = lambda: eval(input())
def main():
R, C, K = NMI()
item = {(0,0):0}
for i in range(K):
r_, c_, v_, = NMI()
item[(r_ - 1,c_ - 1)] = v_
dp = [[[0 for _ in range(C + 2)] for _ in range(R + 2)] for _ in range(4)]
for i in range(R + 1):
for j in range(C + 1):
for k in range(4):
a = dp[k][i][j]
if (i,j) in item:
v = item[(i,j)]
else:
v = 0
if k == 3:
dp[0][i + 1][j] = max(a, dp[0][i + 1][j])
continue
dp[0][i + 1][j] = max(a, a + v, dp[0][i + 1][j])
dp[k][i][j + 1] = max(a, dp[k][i][j + 1])
dp[k + 1][i][j + 1] = max(a + v, dp[k + 1][i][j + 1])
print((max(dp[0][R][C], dp[1][R][C], dp[2][R][C], dp[3][R][C])))
if __name__ == "__main__":
main() | import sys
import math
from collections import defaultdict
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(eval(input()))
NMI = lambda: list(map(int, input().split()))
NLI = lambda: list(NMI())
SI = lambda: eval(input())
def main():
R, C, K = NMI()
item = [[0] * (C + 1) for i in range(R + 1)]
for i in range(K):
r_, c_, v_, = NMI()
item[r_ - 1][c_ - 1] = v_
dp = [[[0 for _ in range(C + 2)] for _ in range(R + 2)] for _ in range(4)]
for i in range(R + 1):
for j in range(C + 1):
for k in range(4):
a = dp[k][i][j]
v = item[i][j]
if k == 3:
dp[0][i + 1][j] = max(a, dp[0][i + 1][j])
continue
dp[0][i + 1][j] = max(a, a + v, dp[0][i + 1][j])
dp[k][i][j + 1] = max(a, dp[k][i][j + 1])
dp[k + 1][i][j + 1] = max(a + v, dp[k + 1][i][j + 1])
print((max(dp[0][R][C], dp[1][R][C], dp[2][R][C], dp[3][R][C])))
if __name__ == "__main__":
main() | p02586 |
def max2(x,y):
return x if x > y else y
R, C, K = list(map(int, input().split()))
V = [[0]*R for _ in range(C)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[c-1][r-1] = v
dp = [[0]*4 for _ in range(R)]
for j in range(R):
if V[0][j] != 0:
dp[j][1] = max2(dp[j - 1][1], dp[j - 1][0]) + V[0][j]
if j != 0:
dp[j][0] = max2(dp[j - 1][1], dp[j - 1][0])
for i in range(1,C):
for j in range(R):
v = V[i][j]
if v != 0:
if dp[j][2] != 0:
dp[j][3] = max2(dp[j][2] + v, dp[j][3])
if dp[j][1] != 0:
dp[j][2] = max2(dp[j][1] + v, dp[j][2])
dp[j][1] = max2(v, dp[j][1])
if j != 0:
if v != 0:
dp[j][1] = max2(max(dp[j - 1][k] for k in range(4)) + v, dp[j][1])
dp[j][0] = max2(max(dp[j - 1][k] for k in range(4)), dp[j][0])
print((max(dp[-1])))
| R, L, K = list(map(int, input().split()))
V = [[0]*R for _ in range(L)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[c-1][r-1] = v
A, B, C, D = [[0]*(R+1) for _ in range(4)]
for i in range(L):
for j in range(R):
A[j] = max(A[j-1], B[j-1], C[j-1], D[j-1])
v = V[i][j]
if v != 0:
D[j], C[j], B[j] = max(C[j] + v, D[j]), max(B[j] + v, C[j]), max(A[j] + v, B[j])
print((max(A[-2], B[-2], C[-2], D[-2]))) | p02586 |
def max2(x,y):
return x if x > y else y
R, L, K = list(map(int, input().split()))
V = [[0]*R for _ in range(L)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[c-1][r-1] = v
A, B, C, D = [[0]*(R+1) for _ in range(4)]
for i in range(L):
for j in range(R):
A[j] = max(A[j-1], B[j-1], C[j-1], D[j-1])
v = V[i][j]
if v != 0:
D[j], C[j], B[j] = max2(C[j] + v, D[j]), max2(B[j] + v, C[j]), max2(A[j] + v, B[j])
print((max(A[-2], B[-2], C[-2], D[-2]))) | import sys
input = sys.stdin.readline
R, L, K = list(map(int, input().split()))
V = [[0]*R for _ in range(L)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[c-1][r-1] = v
A, B, C, D = [[0]*(R+1) for _ in range(4)]
for i in range(L):
for j in range(R):
A[j] = max(A[j-1],B[j-1],C[j-1],D[j-1])
v = V[i][j]
if v != 0:
D[j], C[j], B[j] = max(C[j]+v,D[j]), max(B[j]+v,C[j]), max(A[j]+v,B[j])
print((max(A[-2],B[-2],C[-2],D[-2]))) | p02586 |
r,c,k = list(map(int,input().split()))
l = [[0]*c for i in range(r)]
for i in range(k):
x,y,v = list(map(int,input().split()))
l[x-1][y-1] = v
dp = [[[0]*4 for i in range(c+1)] for j in range(r+1)]
for i in range(r):
for j in range(c):
if l[i][j] > 0:
v = l[i][j]
dp[i+1][j+1][0] = max(max(dp[i][j+1]),dp[i+1][j][0])
dp[i+1][j+1][1] = max(max(dp[i][j+1])+v,dp[i+1][j][0]+v,dp[i+1][j][1])
dp[i+1][j+1][2] = max(dp[i+1][j][1]+v,dp[i+1][j][2])
dp[i+1][j+1][3] = max(dp[i+1][j][2]+v,dp[i+1][j][3])
else:
dp[i+1][j+1][0] = max(max(dp[i][j+1]),dp[i+1][j][0])
dp[i+1][j+1][1] = dp[i+1][j][1]
dp[i+1][j+1][2] = dp[i+1][j][2]
dp[i+1][j+1][3] = dp[i+1][j][3]
print((max(dp[-1][-1]))) | import sys
input = sys.stdin.readline
r,c,k = list(map(int,input().split()))
l = [[0]*c for i in range(r)]
for i in range(k):
x,y,v = list(map(int,input().split()))
l[x-1][y-1] = v
dp = [[[0]*4 for i in range(c+1)] for j in range(r+1)]
for i in range(r):
for j in range(c):
M = max(dp[i][j+1])
if l[i][j] > 0:
v = l[i][j]
dp[i+1][j+1][0] = max(M,dp[i+1][j][0])
dp[i+1][j+1][1] = max(M+v,dp[i+1][j][0]+v,dp[i+1][j][1])
dp[i+1][j+1][2] = max(dp[i+1][j][1]+v,dp[i+1][j][2])
dp[i+1][j+1][3] = max(dp[i+1][j][2]+v,dp[i+1][j][3])
else:
dp[i+1][j+1][0] = max(M,dp[i+1][j][0])
dp[i+1][j+1][1] = dp[i+1][j][1]
dp[i+1][j+1][2] = dp[i+1][j][2]
dp[i+1][j+1][3] = dp[i+1][j][3]
print((max(dp[-1][-1]))) | p02586 |
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
def main():
R, C, K = list(map(int, input().split()))
D = [[*list(map(int, input().split()))] for _ in [None] * K]
D = {(r - 1, c - 1) : v for r, c, v in D}
dp = [[[-1] * 4 for _ in [None] * C] for _ in [None] * R]
dp[0][0][0] = 0
for r in range(R):
for c in range(C):
v = D.get((r, c), None)
for i in range(4):
if dp[r][c][i] > -1:
if r < R - 1:
dp[r + 1][c][0] = max(dp[r + 1][c][0], dp[r][c][i])
if c < C - 1:
dp[r][c + 1][i] = max(dp[r][c + 1][i], dp[r][c][i])
if i < 3 and v:
if r < R - 1:
dp[r + 1][c][0] = max(dp[r + 1][c][0], dp[r][c][i] + v)
if c < C - 1:
dp[r][c + 1][i + 1] = max(dp[r][c + 1][i + 1], dp[r][c][i] + v)
v = D.get((R - 1, C - 1), 0)
ans = dp[R - 1][C - 1][3]
for i in range(3):
ans = max(ans, dp[R - 1][C - 1][i] + v)
print(ans)
if __name__ == "__main__":
main() | import sys
def solve():
input = sys.stdin.readline
R, C, K = list(map(int, input().split()))
item = [[0 for _ in range(C)] for r in range(R)]
for _ in range(K):
r, c, k = list(map(int, input().split()))
item[r-1][c-1] = k
DP = [[[-1 for _ in range(C)] for r in range(R)] for i in range(4)]
DP[0][0][0] = 0
for r in range(R):
for c in range(C):
for i in range(4):
if DP[i][r][c] > -1:
if r + 1 < R:
DP[0][r+1][c] = max(DP[0][r+1][c], DP[i][r][c])
if c + 1 < C:
DP[i][r][c+1] = max(DP[i][r][c+1], DP[i][r][c])
if i < 3 and item[r][c] > 0:
if r + 1 < R: DP[0][r+1][c] = max(DP[0][r+1][c], DP[i][r][c] + item[r][c])
if c + 1 < C: DP[i+1][r][c+1] = max(DP[i+1][r][c+1], DP[i][r][c] + item[r][c])
ans = DP[3][R-1][C-1]
for i in range(3): ans = max(ans, DP[i][R-1][C-1] + item[R-1][C-1])
print(ans)
return 0
if __name__ == "__main__":
solve()
| p02586 |
#!/usr/bin/env python3
def main():
(R, C, K), *D = [[*list(map(int,o.split()))] for o in open(0)]
D = {(r - 1, c - 1) : v for r, c, v in D}
dp = [[[-1] * C for _ in [None] * R] for _ in [None] * 4]
dp[0][0][0] = 0
for r in range(R):
for c in range(C):
v = D.get((r, c), None)
for i in range(4):
if dp[i][r][c] > -1:
if r < R - 1:
dp[0][r + 1][c] = max(dp[0][r + 1][c], dp[i][r][c])
if c < C - 1:
dp[i][r][c + 1] = max(dp[i][r][c + 1], dp[i][r][c])
if i < 3 and v:
if r < R - 1:
dp[0][r + 1][c] = max(dp[0][r + 1][c], dp[i][r][c] + v)
if c < C - 1:
dp[i + 1][r][c + 1] = max(dp[i + 1][r][c + 1], dp[i][r][c] + v)
v = D.get((R - 1, C - 1), 0)
ans = dp[3][R - 1][C - 1]
for i in range(3):
ans = max(ans, dp[i][R - 1][C - 1] + v)
print(ans)
if __name__ == "__main__":
main() | #!/usr/bin/env python3
import sys
input = sys.stdin.readline
def main():
R, C, K = list(map(int, input().split()))
D = {}
for _ in [None] * K:
r, c, v = list(map(int, input().split()))
D[(r - 1, c - 1)] = v
dp = [[[-1] * C for _ in [None] * R] for _ in [None] * 4]
dp[0][0][0] = 0
for r in range(R):
for c in range(C):
v = D.get((r, c), None)
for i in range(4):
if dp[i][r][c] > -1:
if r < R - 1:
dp[0][r + 1][c] = max(dp[0][r + 1][c], dp[i][r][c])
if c < C - 1:
dp[i][r][c + 1] = max(dp[i][r][c + 1], dp[i][r][c])
if i < 3 and v:
if r < R - 1:
dp[0][r + 1][c] = max(dp[0][r + 1][c], dp[i][r][c] + v)
if c < C - 1:
dp[i + 1][r][c + 1] = max(dp[i + 1][r][c + 1], dp[i][r][c] + v)
v = D.get((R - 1, C - 1), 0)
ans = dp[3][R - 1][C - 1]
for i in range(3):
ans = max(ans, dp[i][R - 1][C - 1] + v)
print(ans)
if __name__ == "__main__":
main() | p02586 |
import bisect
import collections
import copy
import functools
import heapq
import math
import sys
from collections import deque
from collections import defaultdict
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
MOD = 10**9+7
R,C,K = list(map(int,input().split()))
item = [[0]*C for _ in range(R)]
for i in range(K):
r,c,v = list(map(int,input().split()))
item[r-1][c-1] = v
#print(item)
dp = [[[0]*4 for _ in range(C)] for _ in range(R)]
for i in range(R):
for j in range(C):
for k in range(1,4):
#print(i,j,k)
if k == 1:
if i != 0:
if j != 0:
dp[i][j][k] = max(dp[i][j-1][k], dp[i][j-1][k-1] + item[i][j], max(dp[i-1][j]) + item[i][j])
else:
dp[i][j][k] = max(0, 0 + item[i][j], max(dp[i-1][j]) + item[i][j])
else:
if j != 0:
dp[i][j][k] = max(dp[i][j-1][k], dp[i][j-1][k-1] + item[i][j])
else:
dp[i][j][k] = max(0, 0 + item[i][j])
else:
if j != 0:
dp[i][j][k] = max(dp[i][j-1][k], dp[i][j-1][k-1] + item[i][j])
else:
dp[i][j][k] = max(0, 0 + item[i][j])
#print(dp)
print((max(dp[R-1][C-1]))) | import bisect
import collections
import copy
import functools
import heapq
import math
import sys
from collections import deque
from collections import defaultdict
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
MOD = 10**9+7
R,C,K = list(map(int,input().split()))
item = [[0]*C for _ in range(R)]
for i in range(K):
r,c,v = list(map(int,input().split()))
item[r-1][c-1] = v
#print(item)
dp = [[0]*4 for _ in range(C)]
preview = [[0]*4 for _ in range(C)]
for i in range(R):
for j in range(C):
for k in range(1,4):
#print(i,j,k)
if k == 1:
if i != 0:
if j != 0:
dp[j][k] = max(dp[j-1][k], dp[j-1][k-1] + item[i][j], max(preview[j]) + item[i][j])
else:
dp[j][k] = max(0, 0 + item[i][j], max(preview[j]) + item[i][j])
else:
if j != 0:
dp[j][k] = max(dp[j-1][k], dp[j-1][k-1] + item[i][j])
else:
dp[j][k] = max(0, 0 + item[i][j])
else:
if j != 0:
dp[j][k] = max(dp[j-1][k], dp[j-1][k-1] + item[i][j])
else:
dp[j][k] = max(0, 0 + item[i][j])
#print(dp)
preview = dp
print((max(dp[C-1]))) | p02586 |
def main():
import sys
from copy import deepcopy
input = sys.stdin.readline
R, C, K = [int(x) for x in input().strip().split()]
G = [[0] * (C+1) for r in range(R+1)]
for k in range(K):
r, c, v = [int(x) for x in input().strip().split()]
G[r][c] = v
# for r in range(R+1):
# print(G[r])
ans = [[[0] * 4 for _ in range(C+1)] for _ in range(R+1)]
for r in range(1, R+1):
for c in range(1, C+1):
ans[r][c][0] = max(ans[r-1][c][-1], ans[r][c-1][0])
for i in range(1, 4):
ans[r][c][i] = max(ans[r-1][c][3], ans[r][c-1][i], ans[r-1][c][3]+G[r][c], ans[r][c-1][i-1]+G[r][c])
print((max(ans[-1][-1])))
if __name__ == '__main__':
main()
| def main():
import sys
from copy import deepcopy
input = sys.stdin.readline
R, C, K = [int(x) for x in input().strip().split()]
G = [[0] * (C+1) for r in range(R+1)]
for k in range(K):
r, c, v = [int(x) for x in input().strip().split()]
G[r][c] = v
# for r in range(R+1):
# print(G[r])
ans = [[[0] * 4 for _ in range(C+1)] for _ in range(2)]
for r in range(1, R+1):
for c in range(1, C+1):
ans[r%2][c][0] = max(ans[(r-1)%2][c][-1], ans[r%2][c-1][0])
for i in range(1, 4):
ans[r%2][c][i] = max(ans[(r-1)%2][c][3], ans[r%2][c-1][i], ans[(r-1)%2][c][3]+G[r][c], ans[r%2][c-1][i-1]+G[r][c])
print((max(ans[R%2][-1])))
if __name__ == '__main__':
main()
| p02586 |
R,C,K = list(map(int,input().split()))
board = [[0 for _ in range(C)] for __ in range(R)]
for _ in range(K):
r,c,v = list(map(int,input().split()))
board[r-1][c-1] = v
dp = [[[0 for _ in range(C)] for __ in range(R)] for ___ in range(4)]
ans = 0
for i in range(R):
for j in range(C):
dp[1][i][j] = max(dp[1][i][j],dp[0][i][j]+board[i][j])
for k in range(4):
if j>0:
dp[k][i][j] = max(dp[k][i][j],dp[k][i][j-1])
if j>0 and k>0:
dp[k][i][j] = max(dp[k][i][j],dp[k-1][i][j-1]+board[i][j])
if i>0:
dp[0][i][j] = max(dp[0][i][j],dp[k][i-1][j])
dp[1][i][j] = max(dp[1][i][j],dp[k][i-1][j]+board[i][j])
ans = max(ans,dp[k][i][j])
#print(*board,sep='\n')
#print(*dp,sep='\n')
print(ans) | R,C,K = list(map(int,input().split()))
board = [[0 for _ in range(C)] for __ in range(R)]
for _ in range(K):
r,c,v = list(map(int,input().split()))
board[r-1][c-1] = v
dp0 = [[0]*C for _ in range(R)]
dp1 = [[0]*C for _ in range(R)]
dp2 = [[0]*C for _ in range(R)]
dp3 = [[0]*C for _ in range(R)]
ans = 0
for i in range(R):
for j in range(C):
if dp1[i][j] < dp0[i][j]+board[i][j]:
dp1[i][j] = dp0[i][j]+board[i][j]
if j>0:
if dp0[i][j] < dp0[i][j-1]:
dp0[i][j] = dp0[i][j-1]
if dp1[i][j] < dp1[i][j-1]:
dp1[i][j] = dp1[i][j-1]
if dp2[i][j] < dp2[i][j-1]:
dp2[i][j] = dp2[i][j-1]
if dp3[i][j] < dp3[i][j-1]:
dp3[i][j] = dp3[i][j-1]
if dp1[i][j] < dp0[i][j-1]+board[i][j]:
dp1[i][j] = dp0[i][j-1]+board[i][j]
if dp2[i][j] < dp1[i][j-1]+board[i][j]:
dp2[i][j] = dp1[i][j-1]+board[i][j]
if dp3[i][j] < dp2[i][j-1]+board[i][j]:
dp3[i][j] = dp2[i][j-1]+board[i][j]
if i>0:
if dp0[i][j] < dp0[i-1][j]:
dp0[i][j] = dp0[i-1][j]
if dp0[i][j] < dp1[i-1][j]:
dp0[i][j] = dp1[i-1][j]
if dp0[i][j] < dp2[i-1][j]:
dp0[i][j] = dp2[i-1][j]
if dp0[i][j] < dp3[i-1][j]:
dp0[i][j] = dp3[i-1][j]
if dp1[i][j] < dp0[i-1][j]+board[i][j]:
dp1[i][j] = dp0[i-1][j]+board[i][j]
if dp1[i][j] < dp1[i-1][j]+board[i][j]:
dp1[i][j] = dp1[i-1][j]+board[i][j]
if dp1[i][j] < dp2[i-1][j]+board[i][j]:
dp1[i][j] = dp2[i-1][j]+board[i][j]
if dp1[i][j] < dp3[i-1][j]+board[i][j]:
dp1[i][j] = dp3[i-1][j]+board[i][j]
print((max(dp0[-1][-1],dp1[-1][-1],dp2[-1][-1],dp3[-1][-1]))) | p02586 |
R,C,K = list(map(int,input().split()))
board = [[0 for _ in range(C)] for __ in range(R)]
for _ in range(K):
r,c,v = list(map(int,input().split()))
board[r-1][c-1] = v
dp0 = [[0]*C for _ in range(R)]
dp1 = [[0]*C for _ in range(R)]
dp2 = [[0]*C for _ in range(R)]
dp3 = [[0]*C for _ in range(R)]
ans = 0
for i in range(R):
for j in range(C):
if dp1[i][j] < dp0[i][j]+board[i][j]:
dp1[i][j] = dp0[i][j]+board[i][j]
if j>0:
if dp0[i][j] < dp0[i][j-1]:
dp0[i][j] = dp0[i][j-1]
if dp1[i][j] < dp1[i][j-1]:
dp1[i][j] = dp1[i][j-1]
if dp2[i][j] < dp2[i][j-1]:
dp2[i][j] = dp2[i][j-1]
if dp3[i][j] < dp3[i][j-1]:
dp3[i][j] = dp3[i][j-1]
if dp1[i][j] < dp0[i][j-1]+board[i][j]:
dp1[i][j] = dp0[i][j-1]+board[i][j]
if dp2[i][j] < dp1[i][j-1]+board[i][j]:
dp2[i][j] = dp1[i][j-1]+board[i][j]
if dp3[i][j] < dp2[i][j-1]+board[i][j]:
dp3[i][j] = dp2[i][j-1]+board[i][j]
if i>0:
if dp0[i][j] < dp0[i-1][j]:
dp0[i][j] = dp0[i-1][j]
if dp0[i][j] < dp1[i-1][j]:
dp0[i][j] = dp1[i-1][j]
if dp0[i][j] < dp2[i-1][j]:
dp0[i][j] = dp2[i-1][j]
if dp0[i][j] < dp3[i-1][j]:
dp0[i][j] = dp3[i-1][j]
if dp1[i][j] < dp0[i-1][j]+board[i][j]:
dp1[i][j] = dp0[i-1][j]+board[i][j]
if dp1[i][j] < dp1[i-1][j]+board[i][j]:
dp1[i][j] = dp1[i-1][j]+board[i][j]
if dp1[i][j] < dp2[i-1][j]+board[i][j]:
dp1[i][j] = dp2[i-1][j]+board[i][j]
if dp1[i][j] < dp3[i-1][j]+board[i][j]:
dp1[i][j] = dp3[i-1][j]+board[i][j]
print((max(dp0[-1][-1],dp1[-1][-1],dp2[-1][-1],dp3[-1][-1]))) | import sys
read = sys.stdin.read
readline = sys.stdin.readline
R,C,K = list(map(int,readline().split()))
board = [[0]*C for _ in range(R)]
for _ in range(K):
r,c,v = list(map(int,readline().split()))
board[r-1][c-1] = v
dp0 = [[0]*C for _ in range(R)]
dp1 = [[0]*C for _ in range(R)]
dp2 = [[0]*C for _ in range(R)]
dp3 = [[0]*C for _ in range(R)]
for i in range(R):
for j in range(C):
if dp1[i][j] < dp0[i][j]+board[i][j]:
dp1[i][j] = dp0[i][j]+board[i][j]
if j>0:
if dp0[i][j] < dp0[i][j-1]:
dp0[i][j] = dp0[i][j-1]
if dp1[i][j] < dp1[i][j-1]:
dp1[i][j] = dp1[i][j-1]
if dp2[i][j] < dp2[i][j-1]:
dp2[i][j] = dp2[i][j-1]
if dp3[i][j] < dp3[i][j-1]:
dp3[i][j] = dp3[i][j-1]
if dp1[i][j] < dp0[i][j-1]+board[i][j]:
dp1[i][j] = dp0[i][j-1]+board[i][j]
if dp2[i][j] < dp1[i][j-1]+board[i][j]:
dp2[i][j] = dp1[i][j-1]+board[i][j]
if dp3[i][j] < dp2[i][j-1]+board[i][j]:
dp3[i][j] = dp2[i][j-1]+board[i][j]
if i>0:
if dp0[i][j] < dp0[i-1][j]:
dp0[i][j] = dp0[i-1][j]
if dp0[i][j] < dp1[i-1][j]:
dp0[i][j] = dp1[i-1][j]
if dp0[i][j] < dp2[i-1][j]:
dp0[i][j] = dp2[i-1][j]
if dp0[i][j] < dp3[i-1][j]:
dp0[i][j] = dp3[i-1][j]
if dp1[i][j] < dp0[i-1][j]+board[i][j]:
dp1[i][j] = dp0[i-1][j]+board[i][j]
if dp1[i][j] < dp1[i-1][j]+board[i][j]:
dp1[i][j] = dp1[i-1][j]+board[i][j]
if dp1[i][j] < dp2[i-1][j]+board[i][j]:
dp1[i][j] = dp2[i-1][j]+board[i][j]
if dp1[i][j] < dp3[i-1][j]+board[i][j]:
dp1[i][j] = dp3[i-1][j]+board[i][j]
print((max(dp0[-1][-1],dp1[-1][-1],dp2[-1][-1],dp3[-1][-1]))) | p02586 |
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque, defaultdict
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations,product#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
from functools import reduce,lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("## ",*x,file=sys.stderr)
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def binr(x): return bin(x)[2:]
def bitcount(x): #xは64bit整数
x= x - ((x >> 1) & 0x5555555555555555)
x= (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x= (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x+= (x >> 8); x+= (x >> 16); x+= (x >> 32)
return x & 0x7f
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reverse=True) #二個目の要素で降順並び替え
#N = int(input())
R,C,K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
base=5000
S=[]
for i in range(K):
r,c,v = map(int, input().split())
r-=1
c-=1
S.append((r*base+c,v))
S.sort(key=itemgetter(0))
dp=[[[0]*4 for _ in range(C)] for _ in range(R)]
p=0
for i in range(R):
dpi=dp[i]
for j in range(C):
cv=0
if p<K and i*base+j==S[p][0]:
cv=S[p][1]
p+=1
if j>0:
dpi[j]=copy(dpi[j-1])
if i>0:
dpi[j][0]=max(max(dp[i-1][j]),dpi[j][0])
if cv!=0:
for k in range(2,-1,-1):
dpi[j][k+1]=max(dpi[j][k]+cv,dpi[j][k+1])
#printe(dp)
print(max(dp[-1][-1]))
if __name__ == "__main__":
main()
| import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque, defaultdict
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations,product#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
from functools import reduce,lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("## ",*x,file=sys.stderr)
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def binr(x): return bin(x)[2:]
def bitcount(x): #xは64bit整数
x= x - ((x >> 1) & 0x5555555555555555)
x= (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x= (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x+= (x >> 8); x+= (x >> 16); x+= (x >> 32)
return x & 0x7f
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reverse=True) #二個目の要素で降順並び替え
#N = int(input())
R,C,K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
base=5000
S=[]
for i in range(K):
r,c,v = map(int, input().split())
r-=1
c-=1
S.append((r*base+c,v))
S.sort(key=itemgetter(0))
p=0
dp=[0]*C
for i in range(R):
dpi=[[0] * 4 for _ in range(C)]
for j in range(C):
cv=0
if p<K and i*base+j==S[p][0]:
cv=S[p][1]
p+=1
if j>0:
dpi[j]=copy(dpi[j-1])
if i>0:
dpi[j][0]=max(dp[j],dpi[j][0])
if cv!=0:
for k in range(2,-1,-1):
dpi[j][k+1]=max(dpi[j][k]+cv,dpi[j][k+1])
#printe(dp)
dp[j]=max(dpi[j])
print(dp[-1])
if __name__ == "__main__":
main()
| p02586 |
R,C,K=list(map(int,input().split()))
value=[[0]*(C+1) for i in range(R+1)]
for i in range(K):
r,c,v=list(map(int,input().split()))
value[r][c]=v
DP0=[[0]*(C+1) for i in range(R+1)]
DP1=[[0]*(C+1) for i in range(R+1)]
DP2=[[0]*(C+1) for i in range(R+1)]
DP3=[[0]*(C+1) for i in range(R+1)]
for i in range(1,R+1):
for j in range(1,C+1):
v=value[i][j]
DP0[i][j]=max(DP0[i][j-1],DP1[i-1][j],DP2[i-1][j],DP3[i-1][j])
DP1[i][j]=max(DP0[i-1][j]+v,DP1[i-1][j]+v,DP2[i-1][j]+v,
DP3[i-1][j]+v,DP1[i][j-1],DP0[i][j-1]+v)
DP2[i][j]=max(DP1[i][j-1]+v,DP2[i][j-1])
DP3[i][j]=max(DP2[i][j-1]+v,DP3[i][j-1])
print((max(DP0[R][C],DP1[R][C],DP2[R][C],DP3[R][C]))) | R,C,K=list(map(int,input().split()))
value=[[0]*(C+1) for i in range(R+1)]
for i in range(K):
r,c,v=list(map(int,input().split()))
value[r][c]=v
DP0=[[0]*(C+1) for i in range(R+1)]
DP1=[[0]*(C+1) for i in range(R+1)]
DP2=[[0]*(C+1) for i in range(R+1)]
DP3=[[0]*(C+1) for i in range(R+1)]
for i in range(1,R+1):
for j in range(1,C+1):
v=value[i][j]
a=DP0[i][j-1]
b=DP1[i][j-1]
c=DP1[i-1][j]
d=DP2[i-1][j]
e=DP3[i-1][j]
f=DP2[i][j-1]
DP0[i][j]=max(a,c,d,e)
DP1[i][j]=max(DP0[i-1][j]+v,c+v,d+v,e+v,b,a+v)
DP2[i][j]=max(b+v,f)
DP3[i][j]=max(f+v,DP3[i][j-1])
print((max(DP0[R][C],DP1[R][C],DP2[R][C],DP3[R][C]))) | p02586 |
r,c,k=list(map(int,input().split()))
P=[[0 for i in range(c+1)] for q in range(r+1)]
for i in range(k):
nr,nc,nv=list(map(int,input().split()))
#nr,nc,nv=map(int,inp[i].split())
#T[nr].append((nc,nv))
P[nr][nc]=nv
dp=[[[0,0,0,0] for i in range(c+1)] for q in range(r+1)]
for i in range(1,r+1):
head=0
for q in range(1,c+1):
pri=P[i][q]
dp[i][q][0]=max(max(dp[i-1][q]),dp[i][q-1][0])
dp[i][q][1]=dp[i][q][0]+pri
dp[i][q][3]=max(dp[i][q-1][3],dp[i][q-1][2]+pri)
dp[i][q][2]=max(dp[i][q-1][2],dp[i][q-1][1]+pri)
dp[i][q][1]=max(dp[i][q-1][1],dp[i][q-1][0]+pri,dp[i][q][1])
print((max(dp[-1][-1])))
| r,c,k=list(map(int,input().split()))
P=[[0 for i in range(c+1)] for q in range(r+1)]
for i in range(k):
nr,nc,nv=list(map(int,input().split()))
#nr,nc,nv=map(int,inp[i].split())
#T[nr].append((nc,nv))
P[nr][nc]=nv
dp=[[[0,0,0,0] for i in range(c+1)] for q in range(r+1)]
for i in range(1,r+1):
for q in range(1,c+1):
pri=P[i][q]
dp[i][q][0]=max(dp[i-1][q][3],dp[i][q-1][0])
dp[i][q][1]=max(dp[i][q-1][1],dp[i][q-1][0]+pri,dp[i][q][0]+pri)
dp[i][q][2]=max(dp[i][q-1][2],dp[i][q-1][1]+pri,dp[i][q][1])
dp[i][q][3]=max(dp[i][q-1][3],dp[i][q-1][2]+pri,dp[i][q][2])
print((max(dp[-1][-1])))
| p02586 |
import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return input().rstrip().decode()
def II(): return int(eval(input()))
def FI(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()
def main():
r,c,k=MI()
G=[[0]*(c+1) for _ in range(r+1)]
dp=[[[0]*5 for i in range(c+1)] for j in range(r+1)]
for _ in range(k):
rrr,ccc,v=MI()
G[rrr][ccc]=v
#print(G)
#print(dp)
for rr in range(1,r+1):
for cc in range(1,c+1):
if G[rr][cc]==0:
dp[rr][cc][1]=dp[rr][cc-1][1]
dp[rr][cc][2]=dp[rr][cc-1][2]
dp[rr][cc][3]=dp[rr][cc-1][3]
dp[rr][cc][4]=max(dp[rr][cc-1][4],dp[rr-1][cc][4])
else:
dp[rr][cc][1]=max(dp[rr-1][cc][4]+G[rr][cc],dp[rr][cc-1][1])
dp[rr][cc][2]=max(dp[rr][cc-1][1]+G[rr][cc],dp[rr][cc-1][2])
dp[rr][cc][3]=max(dp[rr][cc-1][2]+G[rr][cc],dp[rr][cc-1][3])
dp[rr][cc][4]=max(dp[rr][cc][1:4])
#print(dp)
print((dp[-1][-1][-1]))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return input().rstrip().decode()
def II(): return int(eval(input()))
def FI(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()
def main():
r,c,k=MI()
G=[[0]*(c+1) for _ in range(r+1)]
dp=[[[0]*4 for i in range(c+1)] for j in range(r+1)]
for _ in range(k):
rrr,ccc,v=MI()
G[rrr][ccc]=v
#print(G)
#print(dp)
for rr in range(1,r+1):
for cc in range(1,c+1):
if G[rr][cc]==0:
for i in range(4):
dp[rr][cc][i]=max(dp[rr][cc-1][i],dp[rr-1][cc][3])
else:
dp[rr][cc][0]=max(dp[rr-1][cc][3],dp[rr][cc-1][0])
dp[rr][cc][1]=max(dp[rr][cc][0]+G[rr][cc],dp[rr][cc-1][1])
dp[rr][cc][2]=max(dp[rr][cc-1][1]+G[rr][cc],dp[rr][cc-1][2],dp[rr][cc][1])
dp[rr][cc][3]=max(dp[rr][cc-1][2]+G[rr][cc],dp[rr][cc-1][3],dp[rr][cc][2])
#print(dp)
print((dp[-1][-1][-1]))
if __name__ == "__main__":
main()
| p02586 |
import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return input().rstrip().decode()
def II(): return int(eval(input()))
def FI(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()
def main():
r,c,k=MI()
G=[[0]*(c+1) for _ in range(r+1)]
dp=[[[0]*(c+1) for i in range(r+1)] for j in range(4)]
for _ in range(k):
rrr,ccc,v=MI()
G[rrr][ccc]=v
#print(G)
#print(dp)
for rr in range(1,r+1):
for cc in range(1,c+1):
if G[rr][cc]==0:
for i in range(4):
dp[i][rr][cc]=max(dp[i][rr][cc-1],dp[3][rr-1][cc])
else:
dp[0][rr][cc]=max(dp[3][rr-1][cc],dp[0][rr][cc-1])
dp[1][rr][cc]=max(dp[0][rr][cc]+G[rr][cc],dp[1][rr][cc-1])
dp[2][rr][cc]=max(dp[1][rr][cc-1]+G[rr][cc],dp[2][rr][cc-1],dp[1][rr][cc])
dp[3][rr][cc]=max(dp[2][rr][cc-1]+G[rr][cc],dp[3][rr][cc-1],dp[2][rr][cc])
#print(dp)
print((dp[-1][-1][-1]))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return input().rstrip().decode()
def II(): return int(eval(input()))
def FI(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()
def main():
r,c,k=MI()
G=[[0]*(c+1) for _ in range(r+1)]
dp=[[0]*(c+1) for j in range(4)]
for _ in range(k):
rrr,ccc,v=MI()
G[rrr][ccc]=v
#print(G)
#print(dp)
for rr in range(1,r+1):
for cc in range(1,c+1):
if G[rr][cc]==0:
for i in range(4):
dp[i][cc]=max(dp[i][cc-1],dp[3][cc])
else:
dp[0][cc]=max(dp[3][cc],dp[0][cc-1])
dp[1][cc]=max(dp[0][cc]+G[rr][cc],dp[1][cc-1])
dp[2][cc]=max(dp[1][cc-1]+G[rr][cc],dp[2][cc-1],dp[1][cc])
dp[3][cc]=max(dp[2][cc-1]+G[rr][cc],dp[3][cc-1],dp[2][cc])
#print(dp)
print((dp[-1][-1]))
if __name__ == "__main__":
main()
| p02586 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // math.factorial(r) // math.factorial(n-r)
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007
INF = float("inf")
def main():
R, C, K = LI()
rcv = LIR1(K)
dp = make_list(R+1, C+1, 4)
table = make_list(R, C)
for r, c, v in rcv: table[r][c] = v + 1
for r in range(R):
for c in range(C):
dp[r][c][0] = max(dp[r - 1][c])
for i in range(1, 4)[::-1]:
dp[r][c][i] = max(dp[r][c][i], dp[r][c][i - 1] + table[r][c])
for i in range(4):
dp[r][c+1][i] = max(dp[r][c+1][i], dp[r][c][i])
print((max(dp[R-1][C-1])))
if __name__ == '__main__':
main() | #!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // math.factorial(r) // math.factorial(n-r)
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007
INF = float("inf")
def main():
R, C, K = LI()
rcv = LIR1(K)
# dp = make_list(R+1, C+1, 4)
dp = make_list(C+1, 4)
table = make_list(R, C)
for r, c, v in rcv: table[r][c] = v + 1
for r in range(R):
newdp = [[max(p), 0, 0, 0] for p in dp]
for c in range(C):
for i in range(1, 4)[::-1]:
newdp[c][i] = max(newdp[c][i], newdp[c][i - 1] + table[r][c])
newdp[c + 1][i] = max(newdp[c + 1][i], newdp[c][i])
newdp[c + 1][0] = max(newdp[c + 1][0], newdp[c][0])
dp = newdp
print((max(dp[C-1])))
if __name__ == '__main__':
main() | p02586 |
import sys
input=sys.stdin.readline
R,C,K=list(map(int,input().split()))
item={}
for i in range(K):
r,c,v=list(map(int,input().split()))
item[r-1,c-1]=0
item[r-1,c-1]=v
dp=[[0 for i in range(3)] for j in range(C)]
if (R-1,C-1) in item:
dp[C-1][0]=item[R-1,C-1]
dp[C-1][1]=item[R-1,C-1]
dp[C-1][2]=item[R-1,C-1]
for j in range(C-2,-1,-1):
if (R-1,j) in item:
dp[j][0]=max(dp[j+1][1]+item[R-1,j],dp[j+1][0])
dp[j][1]=max(dp[j+1][2]+item[R-1,j],dp[j+1][1])
dp[j][2]=max(item[R-1,j],dp[j+1][2])
else:
dp[j][0]=dp[j+1][0]
dp[j][1]=dp[j+1][1]
dp[j][2]=dp[j+1][2]
for i in range(R-2,-1,-1):
ndp=[[0 for i in range(3)] for j in range(C)]
if (i,C-1) in item:
ndp[C-1][0]=dp[C-1][0]+item[i,C-1]
ndp[C-1][1]=dp[C-1][0]+item[i,C-1]
ndp[C-1][2]=dp[C-1][0]+item[i,C-1]
else:
ndp[C-1][0]=dp[C-1][0]
ndp[C-1][1]=dp[C-1][0]
ndp[C-1][2]=dp[C-1][0]
for j in range(C-2,-1,-1):
if (i,j) in item:
ndp[j][0]=max(max(dp[j][0],ndp[j+1][1])+item[i,j],ndp[j+1][0])
ndp[j][1]=max(max(dp[j][0],ndp[j+1][2])+item[i,j],ndp[j+1][1])
ndp[j][2]=max(dp[j][0]+item[i,j],ndp[j+1][2])
else:
ndp[j][0]=max(dp[j][0],ndp[j+1][0])
ndp[j][1]=max(dp[j][0],ndp[j+1][1])
ndp[j][2]=max(dp[j][0],ndp[j+1][2])
dp=ndp
print((dp[0][0]))
| import sys
input=sys.stdin.readline
R,C,K=list(map(int,input().split()))
item=[[0 for i in range(C)] for j in range(R)]
for i in range(K):
r,c,v=list(map(int,input().split()))
item[r-1][c-1]=v
dp=[[0 for i in range(3)] for j in range(C)]
dp[C-1][0]=item[R-1][C-1]
dp[C-1][1]=item[R-1][C-1]
dp[C-1][2]=item[R-1][C-1]
for j in range(C-2,-1,-1):
dp[j][0]=max(dp[j+1][1]+item[R-1][j],dp[j+1][0])
dp[j][1]=max(dp[j+1][2]+item[R-1][j],dp[j+1][1])
dp[j][2]=max(item[R-1][j],dp[j+1][2])
for i in range(R-2,-1,-1):
ndp=[[0 for i in range(3)] for j in range(C)]
ndp[C-1][0]=dp[C-1][0]+item[i][C-1]
ndp[C-1][1]=dp[C-1][0]+item[i][C-1]
ndp[C-1][2]=dp[C-1][0]+item[i][C-1]
for j in range(C-2,-1,-1):
ndp[j][0]=max(max(dp[j][0],ndp[j+1][1])+item[i][j],ndp[j+1][0])
ndp[j][1]=max(max(dp[j][0],ndp[j+1][2])+item[i][j],ndp[j+1][1])
ndp[j][2]=max(dp[j][0]+item[i][j],ndp[j+1][2])
dp=ndp
print((dp[0][0]))
| p02586 |
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
base = 3*3000*10**10
@lru_cache(maxsize=None)
def decode(x):
a = x%base
x //= base
b = x%base
x //= base
c = x%base
x //= base
d = x%base
return [a,b,c,d]
R,C,K = IL()
data = [[0 for i in range(C)] for j in range(R)]
for _ in range(K):
j,i,v = IL()
data[j-1][i-1] = v
dp = [0 for i in range(C+1)]
for j in range(R):
dpprev = dp[:]
dp = [0 for i in range(C+1)]
for i in range(C):
v = data[j][i]
if v == 0:
dp[i+1] += max(decode(dp[i])[0],max(decode(dpprev[i+1])))
dp[i+1] += max(decode(dp[i])[1],max(decode(dpprev[i+1])))*base
dp[i+1] += max(decode(dp[i])[2],max(decode(dpprev[i+1])))*base**2
dp[i+1] += max(decode(dp[i])[3],max(decode(dpprev[i+1])))*base**3
else:
dp[i+1] += max(decode(dp[i])[0],max(decode(dpprev[i+1])))
dp[i+1] += max(decode(dp[i])[1],decode(dp[i])[0]+v,max(decode(dpprev[i+1]))+v)*base
dp[i+1] += max(decode(dp[i])[2],decode(dp[i])[1]+v,max(decode(dpprev[i+1]))+v)*base**2
dp[i+1] += max(decode(dp[i])[3],decode(dp[i])[2]+v,max(decode(dpprev[i+1]))+v)*base**3
print((max(decode(dp[-1])))) | # -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
R,C,K = IL()
data = [[0 for i in range(C)] for j in range(R)]
for _ in range(K):
j,i,v = IL()
data[j-1][i-1] = v
dp = [[0,0,0,0] for i in range(C+1)]
for j in range(R):
dpprev = dp[:]
for i in range(C):
v = data[j][i]
if v == 0:
dp[i+1][0] = max(dp[i][0],max(dpprev[i+1]))
dp[i+1][1] = max(dp[i][1],max(dpprev[i+1]))
dp[i+1][2] = max(dp[i][2],max(dpprev[i+1]))
dp[i+1][3] = max(dp[i][3],max(dpprev[i+1]))
else:
dp[i+1][0] = max(dp[i][0],max(dpprev[i+1]))
dp[i+1][1] = max(dp[i][1],dp[i][0]+v,max(dpprev[i+1])+v)
dp[i+1][2] = max(dp[i][2],dp[i][1]+v)
dp[i+1][3] = max(dp[i][3],dp[i][2]+v)
print((max(dp[-1]))) | p02586 |
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
R,C,K = IL()
data = [[0 for i in range(C)] for j in range(R)]
for _ in range(K):
j,i,v = IL()
data[j-1][i-1] = v
dp = [[0,0,0,0] for i in range(C+1)]
for j in range(R):
dpprev = dp[:]
for i in range(C):
v = data[j][i]
if v == 0:
dp[i+1][0] = max(dp[i][0],max(dpprev[i+1]))
dp[i+1][1] = max(dp[i][1],max(dpprev[i+1]))
dp[i+1][2] = max(dp[i][2],max(dpprev[i+1]))
dp[i+1][3] = max(dp[i][3],max(dpprev[i+1]))
else:
dp[i+1][0] = max(dp[i][0],max(dpprev[i+1]))
dp[i+1][1] = max(dp[i][1],dp[i][0]+v,max(dpprev[i+1])+v)
dp[i+1][2] = max(dp[i][2],dp[i][1]+v)
dp[i+1][3] = max(dp[i][3],dp[i][2]+v)
print((max(dp[-1]))) | # -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
R,C,K = IL()
data = [[0 for i in range(C)] for j in range(R)]
for _ in range(K):
j,i,v = IL()
data[j-1][i-1] = v
dp = [[0,0,0,0] for i in range(C+1)]
for j in range(R):
dpprev = dp[:]
for i in range(C):
v = data[j][i]
m = max(dpprev[i+1])
if v == 0:
dp[i+1][0] = max(dp[i][0],m)
dp[i+1][1] = max(dp[i][1],m)
dp[i+1][2] = max(dp[i][2],m)
dp[i+1][3] = max(dp[i][3],m)
else:
dp[i+1][0] = max(dp[i][0],m)
dp[i+1][1] = max(dp[i][1],dp[i][0]+v,m+v)
dp[i+1][2] = max(dp[i][2],dp[i][1]+v)
dp[i+1][3] = max(dp[i][3],dp[i][2]+v)
print((max(dp[-1]))) | p02586 |
import sys
input = sys.stdin.readline
def main():
r,c,k = list(map(int, input().split()))
rcv = [ [0]*c for _ in range(r) ]
for _ in range(k):
ri,ci,vi = list(map(int, input().split()))
rcv[ri-1][ci-1] = vi
# dp[0] = [ [0]*c for _ in range(r) ]
# dp1 = [ [0]*c for _ in range(r) ]
# dp2 = [ [0]*c for _ in range(r) ]
# dp[3] = [ [0]*c for _ in range(r) ]
dp = [ [ [0]*c for _ in range(r) ] for _ in range(4) ]
dp[1][0][0] = rcv[0][0]
for i in range(r):
for j in range(c):
if i+1 < r:
dp[0][i+1][j] = max(dp[0][i][j], dp[1][i][j], dp[2][i][j], dp[3][i][j], dp[0][i+1][j])
if rcv[i+1][j] > 0:
dp[1][i+1][j] = max(dp[1][i+1][j], max(dp[0][i][j], dp[1][i][j], dp[2][i][j], dp[3][i][j])+rcv[i+1][j])
if j+1 < c:
dp[0][i][j+1] = max(dp[0][i][j], dp[0][i][j+1])
dp[1][i][j+1] = max(dp[1][i][j], dp[1][i][j+1])
dp[2][i][j+1] = max(dp[2][i][j], dp[2][i][j+1])
dp[3][i][j+1] = max(dp[3][i][j], dp[3][i][j+1])
if rcv[i][j+1] > 0:
dp[1][i][j+1] = max(dp[1][i][j+1], dp[0][i][j]+rcv[i][j+1])
dp[2][i][j+1] = max(dp[2][i][j+1], dp[1][i][j]+rcv[i][j+1])
dp[3][i][j+1] = max(dp[3][i][j+1], dp[2][i][j]+rcv[i][j+1])
ans = max(dp[0][r-1][c-1], dp[1][r-1][c-1], dp[2][r-1][c-1], dp[3][r-1][c-1])
print(ans)
if __name__ == "__main__":
main() | r,c,k = list(map(int, input().split()))
rckl = [ [0]*c for _ in range(r) ]
for _ in range(k):
r_,c_,v_ = list(map(int, input().split()))
rckl[r_-1][c_-1] = v_
dp0 = [ [0]*c for _ in range(r) ]
dp1 = [ [0]*c for _ in range(r) ]
dp2 = [ [0]*c for _ in range(r) ]
dp3 = [ [0]*c for _ in range(r) ]
dp1[0][0] = rckl[0][0]
for i in range(r):
for j in range(c):
if j+1 < c:
dp0[i][j+1] = max(dp0[i][j], dp0[i][j+1])
dp1[i][j+1] = max(dp1[i][j], dp1[i][j+1])
dp2[i][j+1] = max(dp2[i][j], dp2[i][j+1])
dp3[i][j+1] = max(dp3[i][j], dp3[i][j+1])
if rckl[i][j+1] > 0:
v = rckl[i][j+1]
dp1[i][j+1] = max(dp1[i][j+1], dp0[i][j] + v)
dp2[i][j+1] = max(dp2[i][j+1], dp1[i][j] + v)
dp3[i][j+1] = max(dp3[i][j+1], dp2[i][j] + v)
if i+1 < r:
dp0[i+1][j] = max(dp0[i][j], dp1[i][j], dp2[i][j], dp3[i][j], dp0[i+1][j])
if rckl[i+1][j] > 0:
v = rckl[i+1][j]
dp1[i+1][j] = max(dp1[i+1][j], dp0[i][j]+v, dp1[i][j]+v, dp2[i][j]+v, dp3[i][j]+v)
ans = max(dp0[-1][-1], dp1[-1][-1], dp2[-1][-1], dp3[-1][-1])
print(ans)
| p02586 |
import sys
input = lambda: sys.stdin.readline().rstrip()
r, c, k = list(map(int, input().split()))
dp = [[[0 for _ in range(3)] for _ in range(c + 5)] for _ in range(r + 5)]
pt = [[0 for _ in range(c + 5)] for _ in range(r + 5)]
for i in range(k):
r1, c1, v = list(map(int, input().split()))
dp[r1][c1][0] = v
pt[r1][c1] = v
for i in range(1, r + 1):
for j in range(1, c + 1):
for k in range(3):
if k == 0:
dp[i][j][k] = max(dp[i - 1][j][2] + pt[i][j], dp[i][j - 1][0])
elif k == 1:
dp[i][j][k] = max(dp[i][j - 1][0] + pt[i][j],
max(dp[i][j - 1][1], dp[i][j][0]))
else:
dp[i][j][k] = max(dp[i][j - 1][1] + pt[i][j],
max(dp[i][j - 1][2], dp[i][j][1]))
print((dp[r][c][2]))
# デバッグ用
# for i in dp:
# print(i)
| import sys
# import time
input = lambda: sys.stdin.readline().rstrip()
r, c, k = list(map(int, input().split()))
# dp = [[[0] * 3 for _ in range(c + 5)] for _ in range(r + 5)]
pt = [[0 for _ in range(c + 5)] for _ in range(r + 5)]
for i in range(k):
r1, c1, v = list(map(int, input().split()))
# dp[r1][c1][0] = v
pt[r1][c1] = v
# start = time.time()
a = 0
def solve():
memo = [[0] * 4 for _ in range(c + 1)]
prev = [[0] * 4 for _ in range(c + 1)]
for i in range(1, r + 1):
memo, prev = prev, memo
for j in range(1, c + 1):
V = pt[i][j]
memo[j][0] = max(prev[j][3], memo[j - 1][0])
memo[j][1] = max(memo[j][0] + V, memo[j - 1][1])
memo[j][2] = max(memo[j][1], memo[j - 1][1] + V, memo[j - 1][2])
memo[j][3] = max(memo[j][2], memo[j - 1][2] + V, memo[j - 1][3])
# dp[i][j][0] = max(dp[i - 1][j][2] + V, dp[i][j - 1][0])
# dp[i][j][1] = max(dp[i][j - 1][0] + V, dp[i][j - 1][1],
# dp[i][j][0])
# dp[i][j][2] = max(dp[i][j - 1][1] + V, dp[i][j - 1][2],
# dp[i][j][1])
# process_time = time.time() - start
# print(process_time)
# print(dp[r][c][2])
return memo[-1][3]
if __name__ == '__main__':
print((solve()))
| p02586 |
# -*- coding: utf-8 -*-
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
R, C, K = list(map(int, readline().split()))
data = [[0]*(C+1) for _ in range(R+1)]
for i in range(K):
r,c,v = list(map(int,readline().split()))
data[r][c] = v
dp = [[[0]*4 for _ in range(C+1)] for _ in range(R+1)]
dp[1][1][1] = data[1][1]
for i in range(1,R+1):
for j in range(1,C+1):
for k in range(4):
if i+1 < R+1:
dp[i+1][j][0] = max(dp[i+1][j][0],dp[i][j][k])
dp[i+1][j][1] = max(dp[i+1][j][1],dp[i][j][k]+data[i+1][j])
if j+1 < C+1:
dp[i][j+1][k] = max(dp[i][j][k],dp[i][j+1][k])
if k+1 <= 3:
dp[i][j+1][k+1] = max(dp[i][j+1][k+1],dp[i][j][k]+data[i][j+1])
print((max(dp[i][j]))) | # -*- coding: utf-8 -*-
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
R, C, K = list(map(int, readline().split()))
V = [[0]*(C+1) for _ in range(R+1)]
for i in range(K):
r,c,v = list(map(int,readline().split()))
V[r][c] = v
dp = [0] * (C+1)
dp[0] = 0
for i in range(1,R+1):
ndp = [0] * (C+1)
row = V[i]
ldp = [0] * 4
for j in range(1,C+1):
# ldp[0] = max(ldp[0], dp[j])
ldp[0] = dp[j]
for k in range(2,-1,-1):
ldp[k+1] = max(ldp[k+1], ldp[k] + row[j]) # 取る場合と取らない場合
ndp[j] = max(ldp)
dp = ndp
print((dp[C])) | p02586 |
R, C, K = list(map(int, input().split()))
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[r][c] = v
# print(*V,sep='\n',end='\n\n')
dp = [[[0]*(3+1) for _ in range(C+1)] for _ in range(R+1)]
# for r in dp:
# for c in r:
# print('[',end='')
# for x in c:
# print(x,end=' ')
# print(']',end='')
# print()
# print()
for i in range(R+1):
for j in range(C+1):
for k in range(3+1):
if i-1 >= 0:
dp[i][j][0] = max(dp[i][j][0], dp[i-1][j][k])
dp[i][j][1] = max(dp[i][j][1], dp[i-1][j][k] + V[i][j])
if j-1 >= 0:
dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k])
if k-1 >= 0:
dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k-1] + V[i][j])
# for r in dp:
# for c in r:
# print('[',end='')
# for x in c:
# print(x,end=' ')
# print(']',end='')
# print()
# print()
print((max(dp[R][C])))
| R, C, K = list(map(int, input().split()))
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[r][c] = v
pre = [[0]*(3+1) for _ in range(C+1)]
for i in range(R+1):
now = [[0]*(3+1) for _ in range(C+1)]
for j in range(C+1):
for k in range(3+1):
if i-1 >= 0:
now[j][0] = max(now[j][0], pre[j][k])
now[j][1] = max(now[j][1], pre[j][k] + V[i][j])
if j-1 >= 0:
now[j][k] = max(now[j][k], now[j-1][k])
if k-1 >= 0:
now[j][k] = max(now[j][k], now[j-1][k-1] + V[i][j])
pre = now
print((max(now[C])))
| p02586 |
R, C, K = list(map(int, input().split()))
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[r][c] = v
dp0 = [[0]*(C+1) for _ in range(R+1)]
dp1 = [[0]*(C+1) for _ in range(R+1)]
dp2 = [[0]*(C+1) for _ in range(R+1)]
dp3 = [[0]*(C+1) for _ in range(R+1)]
for i in range(R+1):
for j in range(C+1):
v = V[i][j]
a = dp0[i][j]
b = dp0[i][j]
c = dp0[i][j]
d = dp0[i][j]
pa = pb = pc = pd = 0
if i > 0:
pa = dp0[i-1][j]
pb = dp1[i-1][j]
pc = dp2[i-1][j]
pd = dp3[i-1][j]
la = lb = lc = ld = 0
if j > 0:
la = dp0[i][j-1]
lb = dp1[i][j-1]
lc = dp2[i][j-1]
ld = dp3[i][j-1]
a = max(a, pa)
b = max(b, pa+v)
a = max(a, la)
a = max(a, pb)
b = max(b, pb+v)
b = max(b, lb, la+v)
a = max(a, pc)
b = max(b, pc+v)
c = max(c, lc, lb+v)
a = max(a, pd)
b = max(b, pd+v)
d = max(d, ld, lc+v)
dp0[i][j] = a
dp1[i][j] = b
dp2[i][j] = c
dp3[i][j] = d
print((max(dp0[R][C], dp1[R][C], dp2[R][C], dp3[R][C])))
| R, C, K = list(map(int, input().split()))
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[r][c] = v
dp0 = [[0]*(C+1) for _ in range(R+1)]
dp1 = [[0]*(C+1) for _ in range(R+1)]
dp2 = [[0]*(C+1) for _ in range(R+1)]
dp3 = [[0]*(C+1) for _ in range(R+1)]
for i in range(R+1):
for j in range(C+1):
v = V[i][j]
max_p = 0
if i > 0:
max_p = max(dp0[i-1][j], dp1[i-1][j], dp2[i-1][j], dp3[i-1][j])
la = lb = lc = ld = 0
if j > 0:
la = dp0[i][j-1]
lb = dp1[i][j-1]
lc = dp2[i][j-1]
ld = dp3[i][j-1]
dp0[i][j] = max(dp0[i][j], max_p, la)
dp1[i][j] = max(dp0[i][j], max_p + v, lb, la + v)
dp2[i][j] = max(dp2[i][j], lc, lb + v)
dp3[i][j] = max(dp3[i][j], ld, lc + v)
print((max(dp0[R][C], dp1[R][C], dp2[R][C], dp3[R][C])))
| p02586 |
R, C, K = list(map(int, input().split()))
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[r][c] = v
dp0 = [[0]*(C+1) for _ in range(R+1)]
dp1 = [[0]*(C+1) for _ in range(R+1)]
dp2 = [[0]*(C+1) for _ in range(R+1)]
dp3 = [[0]*(C+1) for _ in range(R+1)]
for i in range(R+1):
for j in range(C+1):
v = V[i][j]
la = lb = lc = ld = 0
if j > 0:
la = dp0[i][j-1]
lb = dp1[i][j-1]
lc = dp2[i][j-1]
ld = dp3[i][j-1]
dp2[i][j] = max(dp2[i][j], lc, lb + v)
dp3[i][j] = max(dp3[i][j], ld, lc + v)
if i > 0:
max_p = max(dp0[i-1][j], dp1[i-1][j], dp2[i-1][j], dp3[i-1][j])
dp0[i][j] = max(dp0[i][j], max_p, la)
dp1[i][j] = max(dp0[i][j], max_p + v, lb, la + v)
print((max(dp0[R][C], dp1[R][C], dp2[R][C], dp3[R][C])))
| R, C, K = list(map(int, input().split()))
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[r][c] = v
dp0 = [[0]*(C+1) for _ in range(R+1)]
dp1 = [[0]*(C+1) for _ in range(R+1)]
dp2 = [[0]*(C+1) for _ in range(R+1)]
dp3 = [[0]*(C+1) for _ in range(R+1)]
for i in range(R+1):
for j in range(C+1):
v = V[i][j]
la = lb = lc = ld = 0
if j > 0:
la = dp0[i][j-1]
lb = dp1[i][j-1]
lc = dp2[i][j-1]
ld = dp3[i][j-1]
dp2[i][j] = max(dp2[i][j], lc, lb + v)
dp3[i][j] = max(dp3[i][j], ld, lc + v)
if i > 0:
max_p = max(dp0[i-1][j], dp1[i-1][j], dp2[i-1][j], dp3[i-1][j])
dp0[i][j] = max(dp0[i][j], max_p, la)
dp1[i][j] = max(dp1[i][j], max_p + v, lb, la + v)
print((max(dp0[R][C], dp1[R][C], dp2[R][C], dp3[R][C])))
| p02586 |
R, C, K = list(map(int, input().split()))
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[r][c] = v
pre0 = [0]*(C+1)
pre1 = [0]*(C+1)
pre2 = [0]*(C+1)
pre3 = [0]*(C+1)
for i in range(R+1):
now0 = [0]*(C+1)
now1 = [0]*(C+1)
now2 = [0]*(C+1)
now3 = [0]*(C+1)
for j in range(C+1):
v = V[i][j]
la = lb = 0
if j > 0:
la = now0[j-1]
lb = now1[j-1]
now2[j] = max(now2[j], now2[j-1], lb + v)
now3[j] = max(now3[j], now3[j-1], now2[j-1] + v)
if i > 0:
max_p = max(pre0[j], pre1[j], pre2[j], pre3[j])
now0[j] = max(now0[j], max_p, la)
now1[j] = max(now1[j], max_p + v, la + v, lb)
pre0 = now0
pre1 = now1
pre2 = now2
pre3 = now3
print((max(now0[C], now1[C], now2[C], now3[C])))
| R, C, K = list(map(int, input().split()))
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[r][c] = v
max_p = [0]*(C+1)
for i in range(R+1):
now0 = [0]*(C+1)
now1 = [0]*(C+1)
now2 = [0]*(C+1)
now3 = [0]*(C+1)
for j in range(C+1):
v = V[i][j]
la = lb = 0
if j > 0:
la = now0[j-1]
lb = now1[j-1]
now2[j] = max(now2[j], now2[j-1], lb + v)
now3[j] = max(now3[j], now3[j-1], now2[j-1] + v)
if i > 0:
now0[j] = max(now0[j], max_p[j], la)
now1[j] = max(now1[j], max_p[j] + v, la + v, lb)
max_p[j] = max(now0[j], now1[j], now2[j], now3[j])
print((max(now0[C], now1[C], now2[C], now3[C])))
| p02586 |
R, C, K = list(map(int, input().split()))
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[r][c] = v
max_p = [0]*(C+1)
for i in range(R+1):
now0 = [0]*(C+1)
now1 = [0]*(C+1)
now2 = [0]*(C+1)
now3 = [0]*(C+1)
for j in range(C+1):
v = V[i][j]
la = lb = 0
if j > 0:
la = now0[j-1]
lb = now1[j-1]
now2[j] = max(now2[j], now2[j-1], lb + v)
now3[j] = max(now3[j], now3[j-1], now2[j-1] + v)
if i > 0:
now0[j] = max(now0[j], max_p[j], la)
now1[j] = max(now1[j], max_p[j] + v, la + v, lb)
max_p[j] = max(now0[j], now1[j], now2[j], now3[j])
print((max(now0[C], now1[C], now2[C], now3[C])))
| R, C, K = list(map(int, input().split()))
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[r][c] = v
max_p = [0]*(C+1)
for i in range(R+1):
now0, now1, now2, now3 = [[0]*(C+1) for _ in range(4)]
for j in range(C+1):
v = V[i][j]
la = lb = 0
if j > 0:
la = now0[j-1]
lb = now1[j-1]
now2[j] = max(now2[j], now2[j-1], lb + v)
now3[j] = max(now3[j], now3[j-1], now2[j-1] + v)
if i > 0:
now0[j] = max(now0[j], max_p[j], la)
now1[j] = max(now1[j], max_p[j] + v, la + v, lb)
max_p[j] = max(now0[j], now1[j], now2[j], now3[j])
print((max(now0[C], now1[C], now2[C], now3[C])))
| p02586 |
def main():
r, c, k = list(map(int, input().split()))
d = [[0]*c for _ in [0]*r]
for _ in range(k):
t1, t2, t3 = list(map(int, input().split()))
d[t1-1][t2-1] = t3
dp = [[[0]*4 for _ in [0]*c] for _ in [0]*r]
dp[0][0][1] = d[0][0]
for x in range(r):
for y in range(c):
for z in range(4):
if y != c-1:
if z != 3:
dp[x][y+1][z+1] = max(dp[x][y+1]
[z+1], dp[x][y][z]+d[x][y+1])
dp[x][y+1][z] = max(dp[x][y+1][z], dp[x][y][z])
if x != r-1:
dp[x+1][y][1] = max(dp[x+1][y][1], max(dp[x][y])+d[x+1][y])
dp[x+1][y][0] = max(dp[x+1][y][0], max(dp[x][y]))
print((max(dp[r-1][c-1])))
main()
| def main():
r, c, k = list(map(int, input().split()))
d = dict()
for _ in range(k):
t1, t2, t3 = list(map(int, input().split()))
d[(t1-1, t2-1)] = t3
dp = [[0]*4 for _ in [0]*c]
if (0, 0) in d:
dp[0][1] = d[(0, 0)]
for x in range(r):
dp2 = [[0]*4 for _ in [0]*c]
for y in range(c):
for z in range(4):
if y != c-1:
if z != 3:
if (x, y+1) in d:
dp[y+1][z+1] = max(dp[y+1]
[z+1], dp[y][z]+d[(x, y+1)])
dp[y+1][z] = max(dp[y+1][z], dp[y][z])
if x != r-1:
if (x+1, y) in d:
dp2[y][1] = max(dp2[y][1],
max(dp[y])+d[(x+1, y)])
dp2[y][0] = max(dp2[y][0], max(dp[y]))
if x != r-1:
dp = dp2
print((max(dp[c-1])))
main()
| p02586 |
def main():
r, c, k = list(map(int, input().split()))
d = dict()
for _ in range(k):
t1, t2, t3 = list(map(int, input().split()))
d[(t1-1, t2-1)] = t3
dp = [[0]*4 for _ in [0]*c]
if (0, 0) in d:
dp[0][1] = d[(0, 0)]
for x in range(r):
dp2 = [[0]*4 for _ in [0]*c]
for y in range(c):
for z in range(4):
if y != c-1:
if z != 3:
if (x, y+1) in d:
dp[y+1][z+1] = max(dp[y+1]
[z+1], dp[y][z]+d[(x, y+1)])
dp[y+1][z] = max(dp[y+1][z], dp[y][z])
if x != r-1:
if (x+1, y) in d:
dp2[y][1] = max(dp2[y][1],
max(dp[y])+d[(x+1, y)])
dp2[y][0] = max(dp2[y][0], max(dp[y]))
if x != r-1:
dp = dp2
print((max(dp[c-1])))
main()
| def main():
r, c, k = list(map(int, input().split()))
d = [[0]*c for _ in [0]*r]
for _ in range(k):
t1, t2, t3 = list(map(int, input().split()))
d[t1-1][t2-1] = t3
dp = [[0]*4 for _ in [0]*c]
dp[0][1] = d[0][0]
for x in range(r):
dp2 = [[0]*4 for _ in [0]*c]
for y in range(c):
for z in range(4):
if y != c-1:
if z != 3:
dp[y+1][z+1] = max(dp[y+1]
[z+1], dp[y][z]+d[x][y+1])
dp[y+1][z] = max(dp[y+1][z], dp[y][z])
if x != r-1:
dp2[y][1] = max(dp2[y][1],
max(dp[y])+d[x+1][y])
dp2[y][0] = max(dp2[y][0], max(dp[y]))
if x != r-1:
dp = dp2
print((max(dp[c-1])))
main() | p02586 |
from sys import stdin
input = stdin.readline
def main():
R, C, K = list(map(int, input().split()))
items = [[0 for _ in range(C)] for _ in range(R)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
items[r - 1][c - 1] = v
dp = [[[0 for _ in range(C)] for _ in range(R)] for _ in range(4)]
dp[1][0][0] = items[0][0]
for r in range(R):
for c in range(C):
for i in range(4):
tmp = dp[i][r][c]
# right
if c != C - 1:
# unpick
dp[i][r][c + 1] = max(dp[i][r][c+1], tmp)
# pick
if i < 3:
dp[i+1][r][c + 1] = max(dp[i+1][r]
[c + 1], tmp + items[r][c + 1])
# down
if r != R - 1:
# unpick
dp[i][r + 1][c] = max(dp[i][r + 1][c], tmp)
# pick
dp[1][r + 1][c] = max(dp[1][r + 1][c],
tmp + items[r + 1][c])
ans = 0
for i in range(4):
ans = max(ans, dp[i][-1][-1])
print(ans)
if __name__ == "__main__":
main()
| from sys import stdin
input = stdin.readline
def main():
R, C, K = list(map(int, input().split()))
items = [[0 for _ in range(C)] for _ in range(R)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
items[r - 1][c - 1] = v
dp = [[[0 for _ in range(C)] for _ in range(R)] for _ in range(4)]
dp[1][0][0] = items[0][0]
for r in range(R):
for c in range(C):
for i in range(4):
tmp = dp[i][r][c]
# right
if c != C - 1:
# unpick
dp[i][r][c + 1] = max(dp[i][r][c+1], tmp)
# pick
if i < 3:
dp[i+1][r][c + 1] = max(dp[i+1][r]
[c + 1], tmp + items[r][c + 1])
# down
if r != R - 1:
# unpick
dp[0][r + 1][c] = max(dp[0][r + 1][c], tmp)
# pick
dp[1][r + 1][c] = max(dp[1][r + 1][c],
tmp + items[r + 1][c])
ans = 0
for i in range(4):
ans = max(ans, dp[i][-1][-1])
print(ans)
if __name__ == "__main__":
main()
| p02586 |
f,g,h=range,max,input
R,C,K=list(map(int,h().split()))
G=[[0]*-~C for i in f(R+1)]
for i in'_'*K:r,c,v=list(map(int,h().split()));G[r][c]=v
F=[[[0]*-~C for i in f(R+1)]for i in f(4)]
for r in f(1,R+1):
for x in f(1,4):
for c in f(1,C+1):F[x][r][c]=g(F[x-1][r][c],F[x-1][r][c-1]+G[r][c],F[x][r][c-1],(x<2)*(G[r][c]+g(F[1][r-1][c],F[2][r-1][c],F[3][r-1][c])))
print((F[3][R][C])) | f,g,h=range,max,input
R,C,K=list(map(int,h().split()))
G=[[0]*-~C for i in f(R+1)]
for i in'_'*K:r,c,v=list(map(int,h().split()));G[r][c]=v
F=[[[0]*-~C for i in f(R+1)]for i in f(4)]
for r in f(1,R+1):
for x in f(1,4):
for c in f(1,C+1):F[x][r][c]=g(F[x-1][r][c],F[x-1][r][c-1]+G[r][c],F[x][r][c-1],(x<2)*(G[r][c]+F[3][r-1][c]))
print((F[3][R][C])) | p02586 |
f,h=range,input
R,C,K=list(map(int,h().split()))
G=[-~C*[0]for i in f(R+1)]
for i in'_'*K:r,c,v=list(map(int,h().split()));G[r][c]=v
F=[[-~C*[0]for i in f(R+1)]for i in f(4)]
for r in f(1,R+1):
for x in f(1,4):
for c in f(1,C+1):F[x][r][c]=max(F[x-1][r][c],max(F[x-1][r][c-1],(x<2)*F[3][r-1][c])+G[r][c],F[x][r][c-1])
print((F[3][R][C])) | f,h=range,input
R,C,K=list(map(int,h().split()))
l=lambda:[-~C*[0]for i in f(R+1)]
G=l()
for i in'_'*K:r,c,v=list(map(int,h().split()));G[r][c]=v
F=[l()for i in f(4)]
for r in f(1,R+1):
for x in f(1,4):
for c in f(1,C+1):F[x][r][c]=max(F[x-1][r][c],max(F[x-1][r][c-1],(x<2)*F[3][r-1][c])+G[r][c],F[x][r][c-1])
print((F[3][R][C])) | p02586 |
H,W,k = list(map(int, input().split()))
# アイテムが何処に何個あるか
fs = [[0]*(W+1) for i in range(H+1)]
for i in range(k):
h, w, v = list(map(int, input().split()))
h -= 1
w -= 1
fs[h][w] = v
mvs = [(0,1),(1,0)]
dp = [[[-1<<50 for i in range(W+1)] for j in range(H+1)] for k in range(4)]
# dp[n][i][j] n個取ったときの、i,jにおけるアイテム価値の最大値
from collections import deque
q = deque([])
q.append((0,0))
dp[0][0][0] = 0
dp[1][0][0] = fs[0][0]
for h in range(H):
for w in range(W):
dp[0][h][w+1] = max(dp[0][h][w+1], dp[0][h][w])
dp[1][h][w+1] = max(dp[1][h][w+1], dp[1][h][w], dp[0][h][w] + fs[h][w+1])
dp[2][h][w+1] = max(dp[2][h][w+1], dp[2][h][w], dp[1][h][w] + fs[h][w+1])
dp[3][h][w+1] = max(dp[3][h][w+1], dp[3][h][w], dp[2][h][w] + fs[h][w+1])
for w in range(W):
mx = 0
for i in range(4):
# print("fe",i,h,w,"dp",dp[i][h][w])
mx = max(mx,dp[i][h][w])
dp[0][h+1][w] = mx
dp[1][h+1][w] = mx + fs[h+1][w]
H -= 1
W -= 1
ans0 = dp[0][H][W]
ans1 = dp[1][H][W]
ans2 = dp[2][H][W]
ans3 = dp[3][H][W]
# print(fs)
# for i in range(3):
# d = dp[i]
# for r in d:
# print(*r)
# print("----------")
print((max(ans1,ans2,ans3))) | H, W, k = list(map(int, input().split()))
"""
dp[k][i][j]
i行目、j番目まで来た時に、k個アイテムをとったときの価値の最大値
"""
fs = [[0]*(W+1) for i in range(H+1)]
dp = [[[-1]*(W+1) for i in range(H+1)] for j in range(4)]
# 価値を受け取る
for i in range(k):
h, w, v = list(map(int, input().split()))
fs[h-1][w-1] += v
# initialize
dp[0][0][0] = 0
dp[1][0][0] = fs[0][0]
for h in range(H):
for w in range(W):
for i in range(4):
if i == 0:
dp[i][h][w+1] = max(dp[0][h][w], dp[0][h][w+1])
else:
dp[i][h][w+1] = max(dp[i][h][w], dp[i][h][w+1], dp[i-1][h][w]+fs[h][w+1])
for w in range(W):
dp[0][h+1][w] = max(dp[0][h][w],dp[1][h][w],dp[2][h][w],dp[3][h][w],0)
dp[1][h+1][w] = dp[0][h+1][w] + fs[h+1][w]
mx = 0
for i in range(4):
mx = max(dp[i][H-1][W-1],mx)
print(mx) | p02586 |
def main():
import sys
input = sys.stdin.readline
R, C, K = list(map(int, input().split()))
G = [[0] * C for _ in range(R)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
r -= 1
c -= 1
G[r][c] = v
dp = [[[0] * 4 for _ in range(C + 1)] for _ in range(R + 1)]
for r in range(R):
for c in range(C):
dp[r][c][0] = max(
dp[r - 1][c][0],
dp[r - 1][c][1],
dp[r - 1][c][2],
dp[r - 1][c][3],
dp[r][c - 1][0]
)
for i in range(1, 4):
dp[r][c][i] = max(dp[r][c][i], dp[r][c - 1][i])
for i in range(2, -1, -1):
dp[r][c][i + 1] = max(dp[r][c][i + 1], dp[r][c][i] + G[r][c])
# print(f'{dp=}')
ans = max(dp[-2][-2])
print(ans)
if __name__ == '__main__':
main()
# def binary_search(*, ok, ng, func):
# while abs(ok - ng) > 1:
# mid = (ok + ng) // 2
# if func(mid):
# ok = mid
# else:
# ng = mid
# return ok
| def main():
import sys
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
G = [[0] * W for _ in range(H)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
G[r - 1][c - 1] = v
dp = [[[0] * 4 for _ in range(W + 1)] for _ in range(H + 1)]
for r in range(H):
for c in range(W):
cell = dp[r][c]
up = dp[r - 1][c]
left = dp[r][c - 1]
for k in range(4):
cell[0] = max(cell[0], up[k])
cell[k] = max(cell[k], left[k])
for k in range(2, -1, -1):
cell[k + 1] = max(
cell[k + 1],
cell[k] + G[r][c])
# for k in range(4):
# for row in range(H):
# for col in range(W):
# print(dp[row][col][k], end=' ')
# print()
# print()
# print(*G, sep='\n')
ans = max(dp[-2][-2])
print(ans)
if __name__ == '__main__':
main()
| p02586 |
def main():
import sys
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
G = [[0] * W for _ in range(H)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
G[r - 1][c - 1] = v
dp = [[[0] * 4 for _ in range(W + 1)] for _ in range(H + 1)]
for r in range(H):
for c in range(W):
cell = dp[r][c]
up = dp[r - 1][c]
left = dp[r][c - 1]
for k in range(4):
cell[0] = max(cell[0], up[k])
cell[k] = max(cell[k], left[k])
for k in range(2, -1, -1):
cell[k + 1] = max(
cell[k + 1],
cell[k] + G[r][c])
# for k in range(4):
# for row in range(H):
# for col in range(W):
# print(dp[row][col][k], end=' ')
# print()
# print()
# print(*G, sep='\n')
ans = max(dp[-2][-2])
print(ans)
if __name__ == '__main__':
main()
| def main():
import sys
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
G = [[0] * W for _ in range(H)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
G[r - 1][c - 1] = v
pdp = [[0] * 4 for _ in range(W)]
for r in range(H):
dp = [[0] * 4 for _ in range(W)]
left = [0] * 4
for c in range(W):
cell = dp[c]
for k in range(4):
cell[k] = left[k]
up = max(pdp[c])
if cell[0] < up:
cell[0] = up
for k in range(2, -1, -1):
cell[k + 1] = max(
cell[k + 1],
cell[k] + G[r][c])
left = cell
pdp = dp
# for k in range(4):
# for row in range(H):
# for col in range(W):
# print(dp[row][col][k], end=' ')
# print()
# print()
# print(*G, sep='\n')
ans = max(dp[-1])
print(ans)
if __name__ == '__main__':
main()
| p02586 |
def main():
import sys
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
G = [[0] * W for _ in range(H)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
G[r - 1][c - 1] = v
pdp = [[0] * 4 for _ in range(W)]
for r in range(H):
dp = [[0] * 4 for _ in range(W)]
left = [0] * 4
for c in range(W):
cell = dp[c]
for k in range(4):
cell[k] = left[k]
up = max(pdp[c])
if cell[0] < up:
cell[0] = up
for k in range(2, -1, -1):
cell[k + 1] = max(
cell[k + 1],
cell[k] + G[r][c])
left = cell
pdp = dp
# for k in range(4):
# for row in range(H):
# for col in range(W):
# print(dp[row][col][k], end=' ')
# print()
# print()
# print(*G, sep='\n')
ans = max(dp[-1])
print(ans)
if __name__ == '__main__':
main()
| # https://atcoder.jp/contests/abc175/submissions/15965930
def main():
import sys
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
G = [[0] * W for _ in range(H)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
G[r - 1][c - 1] = v
dp0 = [0] * (W + 1)
dp1 = [0] * (W + 1)
dp2 = [0] * (W + 1)
dp3 = [0] * (W + 1)
# dpx:=行内取得x個以下の最大値
# <cは更新済の同じ行の値
# c<=は前の行の値
for r in range(H):
for c in range(W):
v = G[r][c]
dp0[c] = max(dp0[c], dp3[c])
up = dp0[c] + v
dp3[c] = max(dp3[c - 1], dp2[c - 1] + v, up)
dp2[c] = max(dp2[c - 1], dp1[c - 1] + v, up)
dp1[c] = max(dp1[c - 1], dp0[c - 1] + v, up)
# 左から来て取らない
# 左から来て取る
# 上から来て取らない:=dp0
# 上から来て取る:=dpx(x>0)
# print(f'{dp0=}')
# print(f'{dp1=}')
# print(f'{dp2=}')
# print(f'{dp3=}')
# print('*******************')
print((dp3[-2]))
if __name__ == '__main__':
main()
| p02586 |
R,C,K=list(map(int, input().split()))
M=[[0 for i in range(C)]for i in range(R)]
for i in range(K):
r,c,v=list(map(int, input().split()))
r-=1
c-=1
M[r][c]=v
dp0=[[0 for j in range(C)] for i in range(R)]
dp1=[[0 for j in range(C)] for i in range(R)]
dp2=[[0 for j in range(C)] for i in range(R)]
dp3=[[0 for j in range(C)] for i in range(R)]
dp1[0][0]+=M[0][0]
for r in range(R):
for c in range(C):
if 0<r:
dp1[r][c]=max(max(dp1[r-1][c],dp2[r-1][c],dp3[r-1][c])+M[r][c],dp1[r][c])
dp0[r][c]=max(max(dp1[r-1][c],dp2[r-1][c],dp3[r-1][c]),dp0[r][c])
if 0<c:
dp3[r][c]=max(dp2[r][c-1]+M[r][c],dp3[r][c],dp3[r][c-1])
dp2[r][c]=max(dp1[r][c-1]+M[r][c],dp2[r][c],dp2[r][c-1])
dp1[r][c]=max(dp0[r][c-1]+M[r][c],dp1[r][c],dp1[r][c-1])
dp0[r][c]=max(dp0[r][c-1],dp0[r][c])
ans=0
for i in range(R):
for j in range(C):
ans=max(ans,dp1[i][j],dp2[i][j],dp3[i][j])
print(ans) | R,C,K=list(map(int, input().split()))
M=[[0 for i in range(C)]for i in range(R)]
for i in range(K):
r,c,v=list(map(int, input().split()))
r-=1
c-=1
M[r][c]=v
dp0=[[0 for j in range(C)] for i in range(R)]
dp1=[[0 for j in range(C)] for i in range(R)]
dp2=[[0 for j in range(C)] for i in range(R)]
dp3=[[0 for j in range(C)] for i in range(R)]
dp1[0][0]+=M[0][0]
for r in range(R):
for c in range(C):
if 0<r:
dp1[r][c]=max(max(dp1[r-1][c],dp2[r-1][c],dp3[r-1][c])+M[r][c],dp1[r][c])
dp0[r][c]=max(max(dp1[r-1][c],dp2[r-1][c],dp3[r-1][c]),dp0[r][c])
if 0<c:
dp3[r][c]=max(dp2[r][c-1]+M[r][c],dp3[r][c],dp3[r][c-1])
dp2[r][c]=max(dp1[r][c-1]+M[r][c],dp2[r][c],dp2[r][c-1])
dp1[r][c]=max(dp0[r][c-1]+M[r][c],dp1[r][c],dp1[r][c-1])
dp0[r][c]=max(dp0[r][c-1],dp0[r][c])
print((max(dp1[-1][-1],dp2[-1][-1],dp3[-1][-1]))) | p02586 |
def resolve():
R, C, K = list(map(int, input().split()))
G = [[0] * (C) for _ in range(R)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
G[r - 1][c - 1] = v
dp = [[[0] * 4 for _ in range(C+1)] for _ in range(R+1)]
for i in range(R):
for j in range(C):
for k in range(2, -1, -1):
dp[i][j][k + 1] = max(dp[i][j][k + 1], dp[i][j][k] + G[i][j])
for k in range(4):
dp[i + 1][j][0] = max(dp[i + 1][j][0], dp[i][j][k])
dp[i][j + 1][k] = max(dp[i][j + 1][k], dp[i][j][k])
ans = 0
for k in range(4):
ans = max(ans, dp[R-1][C-1][k])
print(ans)
if __name__ == "__main__":
resolve() |
def resolve():
R, C, K = list(map(int, input().split()))
G = [[0] * (C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
G[r][c] = v
DP1 = [0 for _ in range(C + 1)] # c列目までとったとき、最新の行で1個以下とったという条件のもとの最大
DP2 = [0 for _ in range(C + 1)] # c列目までとったとき、最新の行で2個以下とったという条件のもとの最大
DP3 = [0 for _ in range(C + 1)] # c列目までとったとき、最新の行で3個以下とったという条件のもとの最大
for r in range(1, R+1):
for c in range(1, C+1):
# 更新の順番に注意
# mid = max(DP1[c], DP2[c], DP3[c]) + I[r][c]
mid = DP3[c] + G[r][c]
DP3[c] = max(DP3[c - 1], mid, DP2[c - 1] + G[r][c]) # 3個
DP2[c] = max(DP2[c - 1], mid, DP1[c - 1] + G[r][c]) # 2個
DP1[c] = max(DP1[c - 1], mid) # 1個
print((DP3[C]))
if __name__ == "__main__":
resolve() | p02586 |
import sys
sys.setrecursionlimit(10 ** 7)
read = sys.stdin.buffer.read
inp = sys.stdin.buffer.readline
def inpS(): return inp().rstrip().decode()
def resolve():
R, C, K = list(map(int, inpS().split()))
G = [[0] * (C + 1) for _ in range(R + 1)]
for _ in range(K):
r, c, v = list(map(int, inpS().split()))
G[r][c] = v
dp = [[[0] * 4 for _ in range(C + 1)] for _ in range(R + 1)]
for i in range(R + 1):
for j in range(C + 1):
for k in range(4):
# 次の行に移動する場合
if i + 1 <= R:
# 移動先のアイテムを取らない場合
dp[i + 1][j][0] = max(dp[i + 1][j][0], dp[i][j][k])
# 移動先のアイテムを取る場合
dp[i + 1][j][1] = max(dp[i + 1][j][1], dp[i][j][k] + G[i + 1][j])
# 次の列に移動する場合
if j + 1 <= C:
# 移動先のアイテムを取らない場合
dp[i][j + 1][k] = max(dp[i][j + 1][k], dp[i][j][k])
# 現在のkが3未満のときのみ, 移動先のアイテムを取ることが可能
if k < 3:
dp[i][j + 1][k + 1] = max(dp[i][j + 1][k + 1], dp[i][j][k] + G[i][j + 1])
ans = 0
for k in range(4):
ans = max(ans, dp[-1][-1][k])
print(ans)
if __name__ == "__main__":
resolve()
|
def resolve():
R, C, K = list(map(int, input().split()))
G = [[0] * (C + 1) for _ in range(R + 1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
G[r][c] = v
dp = [[[0] * (C + 1) for _ in range(R + 1)] for _ in range(4)]
for i in range(R + 1):
for j in range(C + 1):
for k in range(4):
here = dp[k][i][j]
# 次の行に移動する場合
if i + 1 <= R:
# 移動先のアイテムを取らない場合
dp[0][i + 1][j] = max(dp[0][i + 1][j], here)
# 移動先のアイテムを取る場合
dp[1][i + 1][j] = max(dp[1][i + 1][j], here + G[i + 1][j])
# 次の列に移動する場合
if j + 1 <= C:
# 移動先のアイテムを取らない場合
dp[k][i][j + 1] = max(dp[k][i][j + 1], here)
# 現在のkが3未満のときのみ, 移動先のアイテムを取ることが可能
if k < 3:
dp[k + 1][i][j + 1] = max(dp[k + 1][i][j + 1], here + G[i][j + 1])
ans = 0
for k in range(4):
ans = max(ans, dp[k][-1][-1])
print(ans)
if __name__ == "__main__":
resolve() | p02586 |
r,c,k=list(map(int,input().split()))
fuck=[list(map(int,input().split())) for _ in range(k)]
rck=[[0]*c for _ in range(r)]
for [rr,cc,kk] in fuck:
rck[rr-1][cc-1]=kk
#dp[y][x][cnt]
dp=[[[0]*4 for _ in range(c)] for _ in range(r)]
#print(dp)
for y in range(r):
for x in range(c):
#1行目
if y == 0:
if x==0:
dp[y][x][1]=rck[y][x]
if x>=1:
dp[y][x][1]=max(dp[y][x-1][1],rck[y][x])
dp[y][x][2]=max(dp[y][x-1][2],dp[y][x-1][1]+rck[y][x])
if x>=2:
dp[y][x][3]=max(dp[y][x-1][3],dp[y][x-1][2]+rck[y][x])
else:
#1は、上0+1 or 左0+1 or 上1 or 左1
#count1ケース
for i in range(1,4):
if i==1:
uemax=max([max(dp[y-1][x][1],dp[y-1][x][2],dp[y-1][x][3])])
dp[y][x][i]=uemax+rck[y][x]
if x>0:
dp[y][x][i]=max(dp[y][x][i],dp[y][x-1][i])
elif i>=2:
if x>=1:
dp[y][x][i]=max(dp[y][x-1][i],dp[y][x-1][i-1]+rck[y][x])
print((max(dp[-1][-1])))
| def pri(x):
for item in x:
print(item)
r,c,k=list(map(int,input().split()))
fuck=[list(map(int,input().split())) for _ in range(k)]
rck=[[0]*(c+1) for _ in range(r+1)]
for [rr,cc,kk] in fuck:
rck[rr][cc]=kk
#pri(rck)
#dp[y][x][cnt]
dp=[[0]*4 for _ in range(c+1)]
#print(dp)
for y in range(1,r+1):
for x in range(1,c+1):
dp[x][0]=max(dp[x-1][0],dp[x][0],dp[x][1],dp[x][2],dp[x][3])
dp[x][1]=max(dp[x][0]+rck[y][x],dp[x][1],dp[x-1][1])
dp[x][2]=max(dp[x-1][1]+rck[y][x],dp[x][2],dp[x-1][2],dp[x][1])
dp[x][3]=max(dp[x-1][2]+rck[y][x],dp[x][3],dp[x-1][3],dp[x][2])
#print(y,x,dp)
print((max(dp[-1])))
| p02586 |
import sys
import math
from collections import defaultdict, deque
from copy import deepcopy
input = sys.stdin.readline
def RD(): return input().rstrip()
def F(): return float(input().rstrip())
def I(): return int(input().rstrip())
def MI(): return list(map(int, input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def Init(H, W, num): return [[num for i in range(W)] for j in range(H)]
def end_of_loop():raise StopIteration
def main():
R, C, K = MI()
mylist = [[0 for i in range(C)] for j in range(R)]
for i in range(K):
a, b, c = MI()
mylist[a-1][b-1] = c
d = [[defaultdict(lambda:-float('inf')) for i in range(C)] for j in range(R)]
for i in range(R):
if i == 0:
#初期化
if mylist[0][0] != 0:
d[0][0][0] = 0
d[0][0][1] = mylist[0][0]
else:
d[0][0][0] = mylist[0][0]
for j in range(1,C):
if mylist[i][j] != 0:
d[i][j][0] = d[i][j-1][0]
for k in range(1,4):
d[i][j][k] = max(d[i][j-1][k], d[i][j-1][k-1]+mylist[i][j])
else:
d[i][j] = d[i][j-1]
else:
#初期化
if mylist[i][0] != 0:
d[i][0][0] = max(d[i-1][0].values())
d[i][0][1] = d[i][0][0]+mylist[i][0]
else:
d[i][0][0] = max(d[i-1][0].values())
for j in range(1,C):
if mylist[i][j] != 0:
#0個の場合
d[i][j][0] = max(d[i][j-1][0], max(d[i-1][j].values()))
#1個の場合
d[i][j][1] = max(d[i][j-1][1], d[i][j-1][0]+mylist[i][j], max(d[i-1][j].values())+mylist[i][j])
#2個の場合
d[i][j][2] = max(d[i][j-1][2], d[i][j-1][1]+mylist[i][j])
#3個の場合
d[i][j][3] = max(d[i][j-1][3], d[i][j-1][2]+mylist[i][j])
else:
#0個の場合
d[i][j][0] = max(d[i][j-1][0], max(d[i-1][j].values()))
#1個以上の場合
for k in range(1,4):
d[i][j][k] = d[i][j-1][k]
print((max(d[R-1][C-1].values())))
if __name__ == "__main__":
main() | import sys
import math
from collections import defaultdict, deque
from copy import deepcopy
input = sys.stdin.readline
def RD(): return input().rstrip()
def F(): return float(input().rstrip())
def I(): return int(input().rstrip())
def MI(): return list(map(int, input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def Init(H, W, num): return [[num for i in range(W)] for j in range(H)]
def end_of_loop():raise StopIteration
def main():
R, C, K = MI()
mylist = [[0 for i in range(C)] for j in range(R)]
for i in range(K):
a, b, c = MI()
mylist[a-1][b-1] = c
d = [[[0] * 4 for i in range(C)] for j in range(R)]
for i in range(R):
if i == 0:
#初期化
d[0][0][1] = mylist[0][0]
for k in range(1,4):
d[0][0][k] = max(d[0][0][k], d[0][0][k-1])
for j in range(1,C):
temp = mylist[i][j]
if temp != 0:
d[i][j][0] = d[i][j-1][0]
for k in range(1,4):
d[i][j][k] = max(d[i][j][k], d[i][j-1][k], d[i][j-1][k-1]+temp, d[i][j][k-1])
else:
d[i][j] = d[i][j-1]
else:
#初期化
d[i][0][0] = d[i-1][0][3]
temp = mylist[i][0]
for k in range(1,4):
d[i][0][k] = d[i][0][0]+temp
for j in range(1,C):
temp = mylist[i][j]
add = d[i-1][j][3]
#0の場合
d[i][j][0] = max(d[i][j-1][0], add)
if temp != 0:
#1個の場合
d[i][j][1] = max(d[i][j-1][1], d[i][j-1][0]+temp, add+temp)
#2個の場合
d[i][j][2] = max(d[i][j-1][2], d[i][j-1][1]+temp)
#3個の場合
d[i][j][3] = max(d[i][j-1][3], d[i][j-1][2]+temp)
for k in range(1,4):
d[i][j][k] = max(d[i][j][k], d[i][j][k-1])
else:
#1個以上の場合
for k in range(1,4):
d[i][j][k] = max(d[i][j-1][k], d[i][j][k-1])
print((d[R-1][C-1][3]))
if __name__ == "__main__":
main() | p02586 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.