input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
R, C, K = rl()
I = [[0]*(C+2) for _ in range(R+2)]
for i in range(K):
r, c, v = rl()
I[r][c] = v
dp = [[[0]*4 for _ in range(C+2)] for _ in range(R+2)]
for i in range(R+1):
for j in range(C+1):
d = dp[i][j]
for ni, nj in [[i+1, j], [i, j+1]]:
nd = dp[ni][nj]
v = I[ni][nj]
for m in range(4):
if i == ni:
nd[m] = max(nd[m], d[m])
if m < 3:
nd[m+1] = max(nd[m+1], d[m]+v)
else:
nd[0] = max(nd[0], d[m])
nd[1] = max(nd[1], d[m] + v)
ans = 0
for m in range(4):
ans = max(ans, dp[R][C][m])
print(ans)
| import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
R, C, K = rl()
I = [[0]*(C+2) for _ in range(R+2)]
for i in range(K):
r, c, v = rl()
I[r][c] = 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 m in range(4):
ni, nj = i, j+1
dp[m][ni][nj] = max(dp[m][ni][nj], dp[m][i][j])
if m < 3:
dp[m+1][ni][nj] = max(dp[m+1][ni][nj], dp[m][i][j]+I[ni][nj])
ni, nj = i+1, j
dp[0][ni][nj] = max(dp[0][ni][nj], dp[m][i][j])
dp[1][ni][nj] = max(dp[1][ni][nj], dp[m][i][j]+I[ni][nj])
ans = 0
for m in range(4):
ans = max(ans, dp[m][R][C])
print(ans)
| 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 make_grid_int(h, w, num): return [[int(num)] * w for _ in range(h)]
def main():
R, C, K = NMI()
grid = make_grid_int(R, C, 0)
for i in range(K):
r, c, v = NMI()
grid[r-1][c-1] = v
dp0 = [[0 for _ in range(C + 2)] for _ in range(R + 2)]
dp1 = [[0 for _ in range(C + 2)] for _ in range(R + 2)]
dp2 = [[0 for _ in range(C + 2)] for _ in range(R + 2)]
dp3 = [[0 for _ in range(C + 2)] for _ in range(R + 2)]
for r in range(R+1):
for c in range(C+1):
for i in range(4):
now0 = dp0[r][c]
now1 = dp1[r][c]
now2 = dp2[r][c]
now3 = dp3[r][c]
try:
val = grid[r][c]
except:
val = 0
dp0[r+1][c] = max(now3, dp0[r+1][c])
# 取って下
dp0[r+1][c] = max(now0 + val, now1 + val, now2 + val, dp0[r+1][c])
# 取らずに下
dp0[r+1][c] = max(now0, now1, now2, now3, dp0[r+1][c])
# 取って横
dp1[r][c+1] = max(now0 + val, dp1[r][c+1])
dp2[r][c+1] = max(now1 + val, dp2[r][c+1])
dp3[r][c+1] = max(now2 + val, dp3[r][c+1])
# 取らずに横
dp1[r][c+1] = max(now1, dp1[r][c+1])
dp2[r][c+1] = max(now2, dp2[r][c+1])
dp0[r][c+1] = max(now0, dp0[r][c+1])
print((max(dp0[R][C], dp1[R][C], dp2[R][C], dp3[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 make_grid_int(h, w, num): return [[int(num)] * w for _ in range(h)]
def main():
R, C, K = NMI()
grid = make_grid_int(R, C, 0)
for i in range(K):
r, c, v = NMI()
grid[r-1][c-1] = v
dp0 = [[0 for _ in range(C + 2)] for _ in range(R + 2)]
dp1 = [[0 for _ in range(C + 2)] for _ in range(R + 2)]
dp2 = [[0 for _ in range(C + 2)] for _ in range(R + 2)]
dp3 = [[0 for _ in range(C + 2)] for _ in range(R + 2)]
for r in range(R+1):
for c in range(C+1):
now0 = dp0[r][c]
now1 = dp1[r][c]
now2 = dp2[r][c]
now3 = dp3[r][c]
try:
val = grid[r][c]
except:
val = 0
dp0[r+1][c] = max(now3, dp0[r+1][c])
# 取って下
dp0[r+1][c] = max(now0 + val, now1 + val, now2 + val, dp0[r+1][c])
# 取らずに下
dp0[r+1][c] = max(now0, now1, now2, now3, dp0[r+1][c])
# 取って横
dp1[r][c+1] = max(now0 + val, dp1[r][c+1])
dp2[r][c+1] = max(now1 + val, dp2[r][c+1])
dp3[r][c+1] = max(now2 + val, dp3[r][c+1])
# 取らずに横
dp1[r][c+1] = max(now1, dp1[r][c+1])
dp2[r][c+1] = max(now2, dp2[r][c+1])
dp0[r][c+1] = max(now0, dp0[r][c+1])
print((max(dp0[R][C], dp1[R][C], dp2[R][C], dp3[R][C])))
if __name__ == "__main__":
main()
| p02586 |
# -*- coding: utf-8 -*-
import sys
from collections import defaultdict
R,C,K=list(map(int, sys.stdin.readline().split()))
value=defaultdict(lambda: 0)
value=[ [0 for _ in range(C+1)] for __ in range(R+1) ]
for _ in range(K):
r,c,v=list(map(int, sys.stdin.readline().split()))
value[r][c]=v
dp0=[0]*(C+1)
dp1=[0]*(C+1)
dp2=[0]*(C+1)
dp3=[0]*(C+1)
for r in range(1,R+1):
for c in range(1,C+1):
#今のマスにアイテムがある場合
if 0<value[r][c]:
dp3[c]=max( dp3[c-1], dp2[c-1]+value[r][c] )
dp2[c]=max( dp2[c-1], dp1[c-1]+value[r][c] )
dp1[c]=max( dp1[c-1], dp0[c-1]+value[r][c], dp0[c]+value[r][c] )
dp0[c]=max( dp0[c-1], dp0[c] )
#今のマスにアイテムがない場合
else:
#dp0[c]=max( dp0[c-1], dp0[c] )
#dp1[c]=max( dp1[c-1], dp1[c] )
#dp2[c]=max( dp2[c-1], dp2[c] )
#dp3[c]=max( dp3[c-1], dp3[c] )
dp0[c]=dp0[c]
dp1[c]=dp1[c-1]
dp2[c]=dp2[c-1]
dp3[c]=dp3[c-1]
#上の行にアイテムをコピー
for c in range(1,C+1):
dp0[c]=max( dp0[c], dp1[c], dp2[c], dp3[c] )
dp1=[0]*(C+1)
dp2=[0]*(C+1)
dp3=[0]*(C+1)
print(dp0[C])
| # -*- coding: utf-8 -*-
import sys
from collections import defaultdict
R,C,K=list(map(int, sys.stdin.readline().split()))
value=defaultdict(lambda: 0)
value=[ [0 for _ in range(C+1)] for __ in range(R+1) ]
for _ in range(K):
r,c,v=list(map(int, sys.stdin.readline().split()))
value[r][c]=v
dp0=[0]*(C+1)
dp1=[0]*(C+1)
dp2=[0]*(C+1)
dp3=[0]*(C+1)
for r in range(1,R+1):
for c in range(1,C+1):
#今のマスにアイテムがある場合
if 0<value[r][c]:
dp3[c]=max( dp3[c-1], dp2[c-1]+value[r][c] )
dp2[c]=max( dp2[c-1], dp1[c-1]+value[r][c] )
#dp1[c]=max( dp1[c-1], dp0[c-1]+value[r][c], dp0[c]+value[r][c] )
dp1[c]=max( dp1[c-1], dp0[c]+value[r][c] )
#dp0[c]=max( dp0[c-1], dp0[c] )
dp0[c]=dp0[c]
#今のマスにアイテムがない場合
else:
#dp0[c]=max( dp0[c-1], dp0[c] )
#dp1[c]=max( dp1[c-1], dp1[c] )
#dp2[c]=max( dp2[c-1], dp2[c] )
#dp3[c]=max( dp3[c-1], dp3[c] )
dp0[c]=dp0[c]
dp1[c]=dp1[c-1]
dp2[c]=dp2[c-1]
dp3[c]=dp3[c-1]
#上の行にアイテムをコピー
for c in range(1,C+1):
dp0[c]=max( dp0[c], dp1[c], dp2[c], dp3[c] )
dp1=[0]*(C+1)
dp2=[0]*(C+1)
dp3=[0]*(C+1)
print(dp0[C])
| p02586 |
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]*4 for _ in range(W+1)]
for i in range(1, H+1):
for j in range(1, W+1):
if (i, j) in B:
v = B[(i, j)]
dp[j][0] = max(dp[j-1][0], dp[j][0], dp[j][1], dp[j][2], dp[j][3])
dp[j][1] = max(dp[j-1][1], dp[j][0]+v)
dp[j][2] = max(dp[j-1][2], dp[j-1][1]+v)
dp[j][3] = max(dp[j-1][3], dp[j-1][2]+v)
else:
dp[j][0] = max(dp[j-1][0], dp[j][0], dp[j][1], dp[j][2], dp[j][3])
dp[j][1] = dp[j-1][1]
dp[j][2] = dp[j-1][2]
dp[j][3] = dp[j-1][3]
print((max(dp[-1])))
| R, C, K = list(map(int, input().split()))
# = int(input())
p = []
for k in range(K):
p.append(list(map(int, input().split())))
maps = [[0 for _ in range(C)] for _ in range(R)]
for k in range(K):
maps[p[k][0]-1][p[k][1]-1] += p[k][2]
point = [[[0, 0, 0] for _ in range(C)] for _ in range(R)]
point[0][0][0] = maps[0][0]
for r in range(R):
for c in range(C):
a, b, d = point[r][c][0], point[r][c][1], point[r][c][2]
if c < C - 1:
x = maps[r][c+1]
y = point[r][c+1]
y[0] = max(y[0], x, a)
y[1] = max(y[1], a + x, b)
y[2] = max(y[2], b + x, d)
point[r][c+1] = y
if r < R - 1:
point[r+1][c][0] = max(point[r+1][c][0], maps[r+1][c] + max(a, b, d))
print((max(point[-1][-1][0:3]))) | p02586 |
R, C, K = list(map(int, input().split()))
# = int(input())
p = []
for k in range(K):
p.append(list(map(int, input().split())))
maps = [[0 for _ in range(C)] for _ in range(R)]
for k in range(K):
maps[p[k][0]-1][p[k][1]-1] += p[k][2]
point = [[[0, 0, 0] for _ in range(C)] for _ in range(R)]
point[0][0][0] = maps[0][0]
for r in range(R):
for c in range(C):
a, b, d = point[r][c][0], point[r][c][1], point[r][c][2]
if c < C - 1:
x = maps[r][c+1]
y = point[r][c+1]
y[0] = max(y[0], x, a)
y[1] = max(y[1], a + x, b)
y[2] = max(y[2], b + x, d)
point[r][c+1] = y
if r < R - 1:
point[r+1][c][0] = max(point[r+1][c][0], maps[r+1][c] + max(a, b, d))
print((max(point[-1][-1][0:3]))) | R, C, K = list(map(int, input().split()))
# = int(input())
p = []
for k in range(K):
p.append(list(map(int, input().split())))
maps = [[0 for _ in range(C)] for _ in range(R)]
for k in range(K):
maps[p[k][0]-1][p[k][1]-1] += p[k][2]
point1 = [[0 for _ in range(C)] for _ in range(R)]
point2 = [[0 for _ in range(C)] for _ in range(R)]
point3 = [[0 for _ in range(C)] for _ in range(R)]
point1[0][0] = maps[0][0]
for r in range(R):
for c in range(C):
a, b, d = point1[r][c], point2[r][c], point3[r][c]
if c < C - 1:
x = maps[r][c+1]
point1[r][c+1] = max(point1[r][c+1], x, a)
point2[r][c+1] = max(point2[r][c+1], a + x, b)
point3[r][c+1] = max(point3[r][c+1], b + x, d)
if r < R - 1:
point1[r+1][c] = maps[r+1][c] + max(a, b, d)
print((max(point1[-1][-1], point2[-1][-1], point3[-1][-1]))) | p02586 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,m,k = inpl()
value = [[0 for _ in range(m)] for i in range(n)]
for _ in range(k):
a,b,c = inpl()
value[a-1][b-1] = c
dp = [[[0 for _ in range(4)] for i in range(m+5)] for j in range(n+5)]
for i in range(n):
for j in range(m):
for k in range(3)[::-1]:
dp[i][j][k+1] = max(dp[i][j][k+1], dp[i][j][k] + value[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])
print((max(dp[n-1][m-1]))) | from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,m,k = inpl()
value = [[0 for _ in range(m)] for i in range(n)]
for _ in range(k):
a,b,c = inpl()
value[a-1][b-1] = c
dp = [0] * (4*(m+1)*(n+1))
def ind(i,j,k):
return 4*(m+1)*i + 4*j + k
for i in range(n):
for j in range(m):
for k in range(3)[::-1]:
dp[ind(i,j,k+1)] = max(dp[ind(i,j,k+1)], dp[ind(i,j,k)] + value[i][j])
for k in range(4):
dp[ind(i+1,j,0)] = max(dp[ind(i+1,j,0)], dp[ind(i,j,k)])
dp[ind(i,j+1,k)] = max(dp[ind(i,j+1,k)], dp[ind(i,j,k)])
# print(dp)
mx = 0
for k in range(4):
mx = max(mx, dp[ind(n-1,m-1,k)])
print(mx) | p02586 |
import bisect, copy, heapq, math, sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
def celi(a,b):
return -(-a//b)
sys.setrecursionlimit(5000000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
def main():
r,c,k=list(map(int,input().split()))
rcv=[list(map(int,input().split())) for i in range(k)]
dpm=[[0]*4 for i in range(c+1)]
dpn=[[0]*4 for i in range(c+1)]
dic={}
for i in range(k):
r1,c1,v=rcv[i]
dic[(r1,c1)]=v
for i in range(r):
for j in range(c):
dpn[j+1][0]=max(dpn[j+1][0],max(dpm[j+1]))
if (i+1,j+1) in dic:
for k in range(3)[::-1]:
dpn[j+1][k+1]=max(dpn[j+1][k]+dic[(i+1,j+1)],dpn[j][k]+dic[(i+1,j+1)])
for k in range(4):
dpn[j+1][k]=max(dpn[j+1][k],dpn[j][k])
# print(dpn)
dpm=copy.deepcopy(dpn)
dpn=[[0]*4 for i in range(c+1)]
print((max(dpm[-1])))
main() | import bisect, copy, heapq, math, sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
def celi(a,b):
return -(-a//b)
sys.setrecursionlimit(5000000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
def main():
r,c,k=list(map(int,input().split()))
rcv=[list(map(int,input().split())) for i in range(k)]
dpn=[[0]*4 for i in range(c+1)]
dic={}
for i in range(k):
r1,c1,v=rcv[i]
dic[(r1,c1)]=v
for i in range(r):
for j in range(c):
dpn[j+1][0]=max(dpn[j+1][0],max(dpn[j+1]))
if (i+1,j+1) in dic:
for k in range(3)[::-1]:
dpn[j+1][k+1]=max(dpn[j+1][k]+dic[(i+1,j+1)],dpn[j][k]+dic[(i+1,j+1)])
for k in range(4):
dpn[j+1][k]=max(dpn[j+1][k],dpn[j][k])
# print(dpn)
print((max(dpn[-1])))
main() | p02586 |
import copy
R, C, K = list(map(int,input().split()))
i = [list(map(int,input().split())) for k in range(K)]
dp0 = [[0] * (C+1) for r in range(R+1)]
dp1 = copy.deepcopy(dp0)
dp2 = copy.deepcopy(dp0)
dp3 = copy.deepcopy(dp0)
item = copy.deepcopy(dp0)
for k in range(K):
item[i[k][0]-1][i[k][1]-1] = i[k][2]
for r in range(R):
for c in range(C):
dp3[r][c] = max(dp3[r][c], dp2[r][c] + item[r][c])
dp2[r][c] = max(dp2[r][c], dp1[r][c] + item[r][c])
dp1[r][c] = max(dp1[r][c], dp0[r][c] + item[r][c])
dp1[r][c+1] = max(dp1[r][c], dp1[r][c+1])
dp2[r][c+1] = max(dp2[r][c], dp2[r][c+1])
dp3[r][c+1] = max(dp3[r][c], dp3[r][c+1])
dp0[r+1][c] = max(dp0[r+1][c], dp1[r][c])
dp0[r+1][c] = max(dp0[r+1][c], dp2[r][c])
dp0[r+1][c] = max(dp0[r+1][c], dp3[r][c])
ans = max(dp0[R-1][C-1], dp1[R-1][C-1])
ans = max(ans, dp3[R-1][C-1])
ans = max(ans, dp2[R-1][C-1])
print(ans) | import sys
import copy
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()))
r -= 1
c -= 1
item[r][c] = v
dp0 = [[0] * (C+1) for r in range(R+1)]
dp1 = [[0] * (C+1) for r in range(R+1)]
dp2 = [[0] * (C+1) for r in range(R+1)]
dp3 = [[0] * (C+1) for r in range(R+1)]
for r in range(R):
for c in range(C):
dp3[r][c] = max(dp3[r][c], dp2[r][c] + item[r][c])
dp2[r][c] = max(dp2[r][c], dp1[r][c] + item[r][c])
dp1[r][c] = max(dp1[r][c], dp0[r][c] + item[r][c])
dp1[r][c+1] = max(dp1[r][c], dp1[r][c+1])
dp2[r][c+1] = max(dp2[r][c], dp2[r][c+1])
dp3[r][c+1] = max(dp3[r][c], dp3[r][c+1])
dp0[r+1][c] = max(dp0[r+1][c], dp1[r][c])
dp0[r+1][c] = max(dp0[r+1][c], dp2[r][c])
dp0[r+1][c] = max(dp0[r+1][c], dp3[r][c])
ans = max(dp0[R-1][C-1], dp1[R-1][C-1])
ans = max(ans, dp3[R-1][C-1])
ans = max(ans, dp2[R-1][C-1])
print(ans) | p02586 |
import sys
inp = [int(x) for x in sys.stdin.read().split()]; ii = 0
rows, cols, k = inp[ii:ii+3]; ii += 3
items = [[] for _ in range(rows+1)]
best = [0]*(cols+1)
for _ in range(k):
r, c, v = inp[ii:ii+3]; ii += 3
items[r].append([c, v])
for i in range(rows+1):
items[i].sort()
ans = 0
for r in range(1, rows+1):
dp = []
best1, best2 = 0, 0
Row = items[r]
for c, v in Row:
v1 = best[c] + v
v2 = best1 + v
v3 = best2 + v
V = v1
if V < v2:
V = v2
if V < v3:
V = v3
dp.append(V)
if v1 > best1:
best1 = v1
if v2 > best2:
best2 = v2
if ans < V:
ans = V
for j in range(len(dp)):
if best[Row[j][0]] < dp[j]:
best[Row[j][0]] = dp[j]
for j in range(2, cols+1):
if best[j] < best[j-1]:
best[j] = best[j-1]
print(ans)
| import sys
inp = [int(x) for x in sys.stdin.read().split()]; ii = 0
shift = int(10**9 + 1)
rows, cols, k = inp[ii:ii+3]; ii += 3
items = [[] for _ in range(rows+1)]
best = [0]*(cols+1)
for _ in range(k):
r, c, v = inp[ii:ii+3]; ii += 3
items[r].append(c*shift+v)
for i in range(rows+1):
items[i].sort()
ans = 0
for r in range(1, rows+1):
dp = []
best1, best2 = 0, 0
Row = items[r]
for X in Row:
c, v = X//shift, X%shift
v1 = best[c] + v
v2 = best1 + v
v3 = best2 + v
V = v1
if V < v2:
V = v2
if V < v3:
V = v3
dp.append(V)
if v1 > best1:
best1 = v1
if v2 > best2:
best2 = v2
if ans < V:
ans = V
for j in range(len(dp)):
c = Row[j]//shift
if best[c] < dp[j]:
best[c] = dp[j]
for j in range(2, cols+1):
if best[j] < best[j-1]:
best[j] = best[j-1]
print(ans)
| p02586 |
import sys
input = sys.stdin.buffer.readline
def main():
R, C, K = list(map(int, input().split()))
State = [[0]*R for _ in range(C)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
State[c-1][r-1] += v
dp = [[0]*4 for _ in range((C+1)*(R+1))]
for r in range(R):
for c in range(C):
for n in range(4):
if dp[(c+1)*(R+1)+r][n] > dp[(c+1)*(R+1)+r+1][0]:
dp[(c+1)*(R+1)+r+1][0] = dp[(c+1)*(R+1)+r][n]
if dp[(c+1)*(R+1)+r][n] + State[c][r] > dp[(c+1)*(R+1)+r+1][1]:
dp[(c+1)*(R+1)+r+1][1] = dp[(c+1)*(R+1)+r][n] + State[c][r]
if dp[c*(R+1)+r+1][n] > dp[(c+1)*(R+1)+r+1][n]:
dp[(c+1)*(R+1)+r+1][n] = dp[c*(R+1)+r+1][n]
if n < 3 and dp[c*(R+1)+r+1][n] + State[c][r] > dp[(c+1)*(R+1)+r+1][n+1]:
dp[(c+1)*(R+1)+r+1][n+1] = dp[c*(R+1)+r+1][n] + State[c][r]
print((max(dp[C*(R+1)+R])))
if __name__ == "__main__":
main() | import sys
input = sys.stdin.buffer.readline
def main():
R, C, K = list(map(int, input().split()))
State = [[0]*R for _ in range(C)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
State[c-1][r-1] += v
dp = [[0]*4 for _ in range(C+1)]
for r in range(R):
ndp = [[0]*4 for _ in range(C+1)]
for c in range(C):
ndp[c+1][0] = max(ndp[c+1][0], max(dp[c+1]))
ndp[c+1][1] = ndp[c+1][0] + State[c][r]
for n in range(4):
if ndp[c][n] > ndp[c+1][n]:
ndp[c+1][n] = ndp[c][n]
if n < 3 and ndp[c][n] + State[c][r] > ndp[c+1][n+1]:
ndp[c+1][n+1] = ndp[c][n] + State[c][r]
dp = ndp
print((max(dp[C])))
if __name__ == "__main__":
main() | p02586 |
import sys
input = sys.stdin.readline
def solve():
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
dp = [[0]*4 for _ in range((R+1)*5000)]
for i in range(1,R+1):
for j in range(1,C+1):
for k in range(4): #横から取らない
dp[i*5000+j][k] = dp[i*5000+j-1][k]
#上から取らない
dp[i*5000+j][0] = max(dp[i*5000+j][0],max(dp[(i-1)*5000+j]))
if item[i-1][j-1]>0:
#上からとる
dp[i*5000+j][1] = max(dp[i*5000+j][1],max(dp[(i-1)*5000+j])+item[i-1][j-1])
for k in range(1,4): #横から取る
dp[i*5000+j][k] = max(dp[i*5000+j][k],dp[i*5000+j-1][k-1]+item[i-1][j-1])
ans = max(dp[R*5000+C])
return ans
print((solve())) | import sys
input = sys.stdin.readline
def solve():
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
dp = [[[0]*(C+1) for _ in range(R+1)] for _ in range(4)]
for i in range(1,R+1):
for j in range(1,C+1):
for k in range(4): #横から取らない
dp[k][i][j] = dp[k][i][j-1]
#上から取らない
dp[0][i][j] = max(dp[0][i][j],dp[-1][i-1][j])
if item[i-1][j-1]>0:
#上からとる
dp[1][i][j] = max(dp[1][i][j],dp[-1][i-1][j]+item[i-1][j-1])
for k in range(1,4): #横から取る
dp[k][i][j] = max(dp[k][i][j],dp[k-1][i][j-1]+item[i-1][j-1])
for k in range(1,4):
dp[k][i][j] = max(dp[k-1][i][j],dp[k][i][j])
ans = 0
for k in range(4):
ans = max(ans,dp[k][-1][-1])
return ans
print((solve())) | p02586 |
import sys
input = sys.stdin.readline
R,C,K=list(map(int,input().split()))
itemMap = [[0]*(C+1) for _ in range(R+1)]
dp =[[[0]*(4) for _ in range(C+1)] for _ in range(R+1)]
for _ in range(K):
r,c,v=list(map(int,input().split()))
itemMap[r-1][c-1]=v
for ir in range(R):
for ic in range(C):
for k in range(2,-1,-1):
#-拾う拾わない遷移-#
dp[ir][ic][k+1] = max(dp[ir][ic][k+1],dp[ir][ic][k]+itemMap[ir][ic])
#-位置遷移-#
for k in range(4):
dp[ir+1][ic][0] = max(dp[ir+1][ic][0],dp[ir][ic][k])
dp[ir][ic+1][k] = max(dp [ir][ic+1][k],dp[ir][ic][k])
ans = 0
for k in range(4):
ans = max(ans,dp[R-1][C-1][k])
print(ans)
| import sys
input = sys.stdin.readline
R,C,K=list(map(int,input().split()))
itemMap = [[0]*(C+1) for _ in range(R+1)]
dp =[[[0]*(C+1) for _ in range(R+1)] for _ in range(4)]
for _ in range(K):
r,c,v=list(map(int,input().split()))
itemMap[r-1][c-1]=v
for ir in range(R):
for ic in range(C):
for k in range(2,-1,-1):
#-拾う拾わない遷移-#
dp[k+1][ir][ic] = max(dp[k+1][ir][ic],dp[k][ir][ic]+itemMap[ir][ic])
#-位置遷移-#
for k in range(4):
dp[0][ir+1][ic] = max(dp[0][ir+1][ic],dp[k][ir][ic])
dp[k][ir][ic+1] = max(dp[k][ir][ic+1],dp[k][ir][ic])
ans = 0
for k in range(4):
ans = max(ans,dp[k][R-1][C-1])
print(ans)
| p02586 |
import sys
input = sys.stdin.readline
def main(R,C,K,rcv):
inf=float('inf')
dp0=[[-inf,-inf,-inf,0] for _ in range(C)]
item=[[0]*C for _ in range(R)]
for r,c,v in rcv:
item[r-1][c-1]=v
# dp0[c][j]:c列目の時点で残りちょうどj個取れる時の最大値
for i in range(R):
# i+1行目に対する操作
# 初期化
for j in range(C):
dp0[j][3]=max(dp0[j])
dp0[j][2]=-inf
dp0[j][1]=-inf
dp0[j][0]=-inf
for j in range(C):
if j>0:
dp0[j][0]=max(dp0[j][0],dp0[j-1][0])
dp0[j][1]=dp0[j-1][1]
dp0[j][2]=dp0[j-1][2]
if item[i][j]>0:
v=item[i][j]
dp0[j][0]=max(dp0[j][0],dp0[j][1]+v)
dp0[j][1]=max(dp0[j][1],dp0[j][2]+v)
dp0[j][2]=max(dp0[j][2],dp0[j][3]+v)
print((max(dp0[-1])))
if __name__=='__main__':
R,C,K=list(map(int,input().split()))
rcv=[list(map(int,input().split())) for _ in range(K)]
main(R,C,K,rcv)
| import sys
input = sys.stdin.readline
def main(R,C,K,rcv):
inf=float('inf')
dp0=[[-inf,-inf,-inf,0] for _ in range(C)]
item=[[0]*C for _ in range(R)]
for r,c,v in rcv:
item[r-1][c-1]=v
# dp0[c][j]:c列目の時点で残りちょうどj個取れる時の最大値
for i in range(R):
# i+1行目に対する操作
# 遷移
for j in range(C):
if j>0:
dp0[j][3]=max(dp0[j])
dp0[j][0]=dp0[j-1][0]
dp0[j][1]=dp0[j-1][1]
dp0[j][2]=dp0[j-1][2]
else:
dp0[0][3]=max(dp0[0])
dp0[0][2]=-inf
dp0[0][1]=-inf
dp0[0][0]=-inf
if item[i][j]>0:
v=item[i][j]
dp0[j][0]=max(dp0[j][0],dp0[j][1]+v)
dp0[j][1]=max(dp0[j][1],dp0[j][2]+v)
dp0[j][2]=max(dp0[j][2],dp0[j][3]+v)
print((max(dp0[-1])))
if __name__=='__main__':
R,C,K=list(map(int,input().split()))
rcv=[list(map(int,input().split())) for _ in range(K)]
main(R,C,K,rcv)
| p02586 |
import sys
input = sys.stdin.readline
def main(R,C,K,rcv):
inf=float('inf')
dp0=[[-inf,-inf,-inf,0] for _ in range(C)]
item=[[0]*C for _ in range(R)]
for r,c,v in rcv:
item[r-1][c-1]=v
# dp0[c][j]:c列目の時点で残りちょうどj個取れる時の最大値
for i in range(R):
# i+1行目に対する操作
# 遷移
for j in range(C):
if j>0:
dp0[j][3]=max(dp0[j])
dp0[j][0]=dp0[j-1][0]
dp0[j][1]=dp0[j-1][1]
dp0[j][2]=dp0[j-1][2]
else:
dp0[0][3]=max(dp0[0])
dp0[0][2]=-inf
dp0[0][1]=-inf
dp0[0][0]=-inf
if item[i][j]>0:
v=item[i][j]
dp0[j][0]=max(dp0[j][0],dp0[j][1]+v)
dp0[j][1]=max(dp0[j][1],dp0[j][2]+v)
dp0[j][2]=max(dp0[j][2],dp0[j][3]+v)
print((max(dp0[-1])))
if __name__=='__main__':
R,C,K=list(map(int,input().split()))
rcv=[list(map(int,input().split())) for _ in range(K)]
main(R,C,K,rcv)
| R,C,K=list(map(int,input().split()))
rcv=[list(map(int,input().split())) for _ in range(K)]
mat=[[0]*C for _ in range(R)]
for r,c,v in rcv:
mat[r-1][c-1]=v
dp=[0]*C
for i in range(R):
ndp=[0]*C
wdp=[0]*4
for j in range(C):
wdp[0]=max(wdp[0],dp[j])
if mat[i][j]>0:
v=mat[i][j]
wdp[3]=max(wdp[3],wdp[2]+v)
wdp[2]=max(wdp[2],wdp[1]+v)
wdp[1]=max(wdp[1],wdp[0]+v)
ndp[j]=max(wdp)
dp=ndp.copy()
print((max(wdp))) | p02586 |
import sys
input = sys.stdin.buffer.readline
R, C, K = list(map(int,input().split()))
RC = [[0] * (C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int,input().split()))
RC[r-1][c-1] = v
dp = [[[0] * 4 for _ in range(C+1)] for _ in range(R+1)]
dp[0][0][1] = RC[0][0]
for r in range(R):
for c in range(C):
for i in range(4):
dp[r][c+1][i] = max(dp[r][c][i], dp[r][c+1][i])
dp[r+1][c][0] = max(dp[r][c][i], dp[r+1][c][0])
if i <= 2:
dp[r][c+1][i+1] = max(dp[r][c][i] + RC[r][c+1], dp[r][c+1][i+1])
dp[r+1][c][1] = max(dp[r+1][c][1], dp[r+1][c][0] + RC[r+1][c])
print((max(dp[-2][-2])))
| import sys
input = sys.stdin.buffer.readline
R, C, K = list(map(int,input().split()))
RC = [[0] * (C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = list(map(int,input().split()))
RC[r-1][c-1] = v
dp = [[[0] * (C+1) for i in range(R+1)] for j in range(4)]
dp[1][0][0] = RC[0][0]
for r in range(R):
for c in range(C):
for i in range(4):
dp[i][r][c+1] = max(dp[i][r][c], dp[i][r][c+1])
if i <= 2:
dp[i+1][r][c+1] = max(dp[i][r][c] + RC[r][c+1], dp[i+1][r][c+1])
dp[0][r+1][c] = max(dp[i][r][c], dp[0][r+1][c])
dp[1][r+1][c] = max(dp[1][r+1][c], dp[0][r+1][c] + RC[r+1][c])
print((max(dp[0][-2][-2], dp[1][-2][-2], dp[2][-2][-2], dp[3][-2][-2])))
| p02586 |
R, C, K = list(map(int, input().split()))
item = [[0] * C for i in range(R)]
for i in range(K):
r, c, v = list(map(int, input().split()))
item[r - 1][c - 1] = v
dp = [[[0] * 4 for j in range(C)] for i in range(R)]
#print(dp, item)
for i in range(R):
for j in range(C):
for k in range(4):
if (i == 0) and (j == 0):
continue
else:
if i == 0:
dp[i][j][k] = dp[i][j - 1][k]
#if (item[i][j] != 0) and (k != 0):
# dp[i][j][k] = max(dp[i][j][k], dp[i][j][k - 1] + item[i][j])
elif j == 0:
dp[i][j][k] = dp[i - 1][j][3]
#if (item[i][j] != 0) and (k != 0):
# dp[i][j][k] = max(dp[i][j][k], dp[i][j][k - 1] + item[i][j])
else:
dp[i][j][k] = dp[i][j - 1][k]
dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j][3])
#if (item[i][j] != 0) and (k != 0):
# dp[i][j][k] = max(dp[i][j][k], dp[i][j][k - 1] + item[i][j])
#for k in range(3):
# dp[i][j][k + 1] = max(dp[i][j][k + 1], dp[i][j][k])
for k in range(3):
if (item[i][j] != 0):
dp[i][j][3 - k] = max(dp[i][j][3 - k], dp[i][j][2 - k] + item[i][j])
#print(item)
#print(dp)
print((dp[-1][-1][-1]))
| R,C,K = list(map(int,input().split()))
J=[0] * K
for i in range(K):
J[i] = list(map(int,input().split()))
#DP0 = [[0]*(C+2) for i in range(R+2)]
DP1 = [[0]*(C+2) for i in range(R+2)]
DP2 = [[0]*(C+2) for i in range(R+2)]
DP3 = [[0]*(C+2) for i in range(R+2)]
MAP = [[0]*C for i in range(R)]
for x,y,v in J:
MAP[x-1][y-1] = v
#print(MAP)
for i in range(R):
for j in range(C):
DP1[i][j] = max(DP1[i][j-1],DP1[i-1][j]+MAP[i][j],DP2[i-1][j]+MAP[i][j],DP3[i-1][j]+MAP[i][j])
DP2[i][j] = max(DP2[i][j-1],DP1[i][j-1]+MAP[i][j])
DP3[i][j] = max(DP3[i][j-1],DP2[i][j-1]+MAP[i][j])
#print(DP1)
#print(DP2)
#print(DP3)
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 |
import sys
input = sys.stdin.readline
def main():
h, w, k = list(map(int, input().split()))
U = h*w
G = [0]*U
for _ in range(k):
r, c, v = list(map(int, input().split()))
r -= 1
c -= 1
G[r*w+c] = v
dp = [[0]*4 for _ in range(U)]
dp[0][0] = 0
dp[0][1] = G[0]
for i in range(h):
for j in range(w):
if j:
dp[i*w+j][0] = dp[i*w+j-1][0]
for k in range(1, 4):
dp[i*w+j][k] = max(dp[i*w+j][k], dp[i*w+j-1][k-1]+G[i*w+j], dp[i*w+j-1][k])
if i:
temp = max(dp[(i-1)*w+j])
dp[i*w+j][0] = max(dp[i*w+j][0], temp)
dp[i*w+j][1] = max(dp[i*w+j][1], temp+G[i*w+j])
ans = max(dp[U-1])
print(ans)
if __name__ == "__main__":
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()))
r -= 1
c -= 1
G[r][c] = v
dp = [[[0]*w for i in range(h)] for j in range(4)]
dp[0][0][0] = 0
dp[1][0][0] = G[0][0]
for i in range(h):
for j in range(w):
if j:
dp[0][i][j] = dp[0][i][j-1]
for k in range(1, 4):
dp[k][i][j] = max(dp[k][i][j], dp[k-1][i][j-1]+G[i][j], dp[k][i][j-1])
if i:
dp[0][i][j] = max(dp[0][i][j], 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], max(dp[0][i-1][j],dp[1][i-1][j],dp[2][i-1][j],dp[3][i-1][j])+G[i][j])
ans = max(dp[0][h-1][w-1],dp[1][h-1][w-1],dp[2][h-1][w-1],dp[3][h-1][w-1])
print(ans) | p02586 |
H, W, K = list(map(int, input().split()))
A = [[0] * W for _ in range(H)]
for i in range(K):
y, x, v = list(map(int, input().split()))
A[y - 1][x - 1] = v
dp = [[0] * 4 for i in range(W)]
pre = []
dp[0][1] = A[0][0]
for i in range(H):
for j in range(W):
for k in range(4):
if i:
if k == 1:
dp[j][k] = max(dp[j][k], max(pre[j]) + A[i][j])
if k == 0:
dp[j][k] = max(dp[j][k], max(pre[j]))
if j:
if 0 < k:
dp[j][k] = max(dp[j][k], dp[j - 1][k - 1] + A[i][j])
dp[j][k] = max(dp[j][k], dp[j - 1][k])
pre = dp
ans = 0
for j in range(W):
ans = max(ans, max(dp[j]))
print(ans)
| H, W, K = list(map(int, input().split()))
A = [[0] * W for _ in range(H)]
for i in range(K):
y, x, v = list(map(int, input().split()))
A[y - 1][x - 1] = v
dp = [[0] * 4 for i in range(W)]
pre = []
dp[0][1] = A[0][0]
for i in range(H):
for j in range(W):
if i:
dp[j][0] = max(dp[j][0], max(pre[j]))
dp[j][1] = max(dp[j][1], max(pre[j]) + A[i][j])
for k in range(4):
if j:
if 0 < k:
dp[j][k] = max(dp[j][k], dp[j - 1][k - 1] + A[i][j])
dp[j][k] = max(dp[j][k], dp[j - 1][k])
pre = dp
ans = 0
for j in range(W):
ans = max(ans, max(dp[j]))
print(ans)
| p02586 |
import sys
input = sys.stdin.readline
R,C,K = list(map(int,input().split()))
RCV = [tuple(map(int,input().split())) for i in range(K)]
goods = [dict() for _ in range(R)]
for r,c,v in RCV:
r,c = r-1,c-1
goods[r][c] = v
dp = [[[0]*4 for _ in range(C)] for _ in range(R)]
if 0 in goods[0]:
dp[0][0][1] = goods[0][0]
for i in range(R):
for j in range(C):
if i:
pre = max(dp[i-1][j])
dp[i][j][0] = pre
if j in goods[i]:
dp[i][j][1] = pre + goods[i][j]
if j:
for k in range(4):
dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k])
if j in goods[i]:
for k in reversed(list(range(3))):
dp[i][j][k+1] = max(dp[i][j][k+1], dp[i][j-1][k] + goods[i][j])
print((max(dp[-1][-1]))) | import sys
input = sys.stdin.readline
R,C,K = list(map(int,input().split()))
RCV = [tuple(map(int,input().split())) for i in range(K)]
goods = [dict() for _ in range(R)]
for r,c,v in RCV:
r,c = r-1,c-1
goods[r][c] = v
dp0 = [[0]*4 for _ in range(C)]
dp1 = [[0]*4 for _ in range(C)]
if 0 in goods[0]:
dp1[0][1] = goods[0][0]
for i in range(R):
for j in range(C):
if i:
pre = max(dp0[j])
dp1[j][0] = pre
if j in goods[i]:
dp1[j][1] = pre + goods[i][j]
if j:
for k in range(4):
dp1[j][k] = max(dp1[j][k], dp1[j-1][k])
if j in goods[i]:
for k in reversed(list(range(3))):
dp1[j][k+1] = max(dp1[j][k+1], dp1[j-1][k] + goods[i][j])
dp0 = dp1
dp1 = [[0]*4 for _ in range(C)]
print((max(dp0[-1]))) | p02586 |
r,c,k = list(map(int,input().split()))
dp = [[[0 for _ in range(4)] for _ in range(c+1)] for _ in range(r+1)]
g = [[0]*(c+1) for _ in range(r+1)]
for _ in range(k):
a,b,v = list(map(int,input().split()))
g[a][b] = v
for i in range(r+1):
for j in range(c+1):
for m in range(4):
tmp =dp[i][j][m]
if i+1<=r:
dp[i+1][j][0] = max(tmp,dp[i+1][j][0])
dp[i+1][j][1] = max(dp[i+1][j][1],tmp + g[i+1][j])
if j+1<=c:
dp[i][j+1][m] = max(dp[i][j+1][m],tmp)
if m<3:
dp[i][j+1][m+1] = max(dp[i][j+1][m+1],tmp + g[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)
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()))
dp = [[[0 for _ in range(4)] for _ in range(c+1)] for _ in range(r+1)]
g = [[0]*(c+1) for _ in range(r+1)]
for _ in range(k):
a,b,v = list(map(int,input().split()))
g[a][b] = v
for i in range(r+1):
for j in range(c+1):
for k in range(4):
here = dp[i][j][k]
if i + 1 <= r:
dp[i + 1][j][0] = max(dp[i + 1][j][0], here)
dp[i + 1][j][1] = max(dp[i + 1][j][1], here + g[i + 1][j])
if j + 1 <= c:
dp[i][j + 1][k] = max(dp[i][j + 1][k], here)
if k < 3:
dp[i][j + 1][k+1] = max(dp[i][j + 1][k+1], here + g[i][j + 1])
ans = 0
for k in range(4):
ans = max(ans, dp[-1][-1][k])
print(ans)
# ans = 0
# tmp =dp[i][j][m]
# if i+1<=r:
# dp[i+1][j][0] = max(tmp,dp[i+1][j][0])
# dp[i+1][j][1] = max(dp[i+1][j][1],tmp + g[i+1][j])
# if j+1<=c:
# dp[i][j+1][m] = max(dp[i][j+1][m],tmp)
# if m<3:
# dp[i][j+1][m+1] = max(dp[i][j+1][m+1],tmp + g[i][j+1])
# print(max(dp[-1][-1]))
| r,c,k = list(map(int,input().split()))
dp = [[[0]*(c+1) for _ in range(r+1)] for _ in range(4)]
g = [[0]*(c+1) for _ in range(r+1)]
for _ in range(k):
a,b,v = list(map(int,input().split()))
g[a][b] = v
for i in range(r+1):
for j in range(c+1):
for m in range(4):
tmp =dp[m][i][j]
if i+1<=r:
dp[0][i+1][j] = max(tmp,dp[0][i+1][j])
dp[1][i+1][j] = max(dp[1][i+1][j],tmp + g[i+1][j])
if j+1<=c:
dp[m][i][j+1] = max(dp[m][i][j+1],tmp)
if m<3:
dp[m+1][i][j+1] = max(dp[m+1][i][j+1],tmp + g[i][j+1])
ans = 0
for m in range(4):
ans = max(ans,dp[m][-1][-1])
print(ans)
| p02586 |
r,c,k = list(map(int, input().split()))
rcv = [list(map(int, input().split())) for i in range(k)]
d = dict()
for rr,cc,vv in rcv:
d[(rr-1,cc-1)] = vv
DP_now = [[0]*4 for i in range(c)]
DP_prev = [[0]*4 for i in range(c)]
for i in range(r):
for j in range(c):
if (i,j) in d:
v = d[(i,j)]
max_top = max(DP_prev[j]) if i!=0 else 0
DP_now[j][0] = max_top
DP_now[j][1] = max_top + v
for k in range(4):
if j != 0:
if DP_now[j][k] < DP_now[j-1][k]:
DP_now[j][k] = DP_now[j-1][k]
if k!=0 and DP_now[j][k] < DP_now[j-1][k-1] + v:
DP_now[j][k] = DP_now[j-1][k-1] + v
else:
max_top = max(DP_prev[j]) if i!=0 else 0
DP_now[j][0] = max_top
for k in range(4):
if j != 0 and DP_now[j][k] < DP_now[j-1][k]:
DP_now[j][k] = DP_now[j-1][k]
DP_prev = DP_now
DP_now = [[0]*4 for i in range(c)]
ans = max(DP_prev[-1])
print(ans)
| r,c,k = list(map(int, input().split()))
rcv = [list(map(int, input().split())) for i in range(k)]
d = dict()
for rr,cc,vv in rcv:
d[(rr-1,cc-1)] = vv
DP_now = [[0]*4 for i in range(c)]
DP_prev = [[0]*4 for i in range(c)]
for i in range(r):
for j in range(c):
max_top = max(DP_prev[j]) if i!=0 else 0
if (i,j) in d:
v = d[(i,j)]
DP_now[j][0] = max_top
DP_now[j][1] = max_top + v
for k in range(4):
if j != 0:
if DP_now[j][k] < DP_now[j-1][k]:
DP_now[j][k] = DP_now[j-1][k]
if k!=0 and DP_now[j][k] < DP_now[j-1][k-1] + v:
DP_now[j][k] = DP_now[j-1][k-1] + v
else:
DP_now[j][0] = max_top
if j>0:
DP_now[j] = DP_now[j-1][:]
if DP_now[j][0] < max_top:
DP_now[j][0] = max_top
DP_prev = DP_now
DP_now = [[0]*4 for i in range(c)]
ans = max(DP_prev[-1])
print(ans)
| p02586 |
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):
if i>0:
dp[1][i][j]=max(dp[1][i][j],dp[0][i-1][j]+v[i][j])
dp[0][i][j]=max(dp[0][i][j],dp[0][i-1][j])
dp[1][i][j]=max(dp[1][i][j],dp[1][i-1][j]+v[i][j])
dp[0][i][j]=max(dp[0][i][j],dp[1][i-1][j])
dp[1][i][j]=max(dp[1][i][j],dp[2][i-1][j]+v[i][j])
dp[0][i][j]=max(dp[0][i][j],dp[2][i-1][j])
dp[1][i][j]=max(dp[1][i][j],dp[3][i-1][j]+v[i][j])
dp[0][i][j]=max(dp[0][i][j],dp[3][i-1][j])
if j>0:
dp[1][i][j]=max(dp[1][i][j],dp[0][i][j-1]+v[i][j])
dp[2][i][j]=max(dp[2][i][j],dp[1][i][j-1]+v[i][j])
dp[3][i][j]=max(dp[3][i][j],dp[2][i][j-1]+v[i][j])
dp[0][i][j]=max(dp[0][i][j],dp[0][i][j-1])
dp[1][i][j]=max(dp[1][i][j],dp[1][i][j-1])
dp[2][i][j]=max(dp[2][i][j],dp[2][i][j-1])
dp[3][i][j]=max(dp[3][i][j],dp[3][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()
| import sys
input=sys.stdin.readline
def main():
r,c,k=map(int,input().split())
v=[0] * (c * r)
for _ in range(k):
ri,ci,a=map(int,input().split())
v[(ri-1)*c + (ci-1)]=a
dp= [0] * (c * r * 4)
#print(dp)
x = c * r
if v[0]>0: dp[x] = v[0]
for i in range(r):
for j in range(c):
idx = i*c+j
idx2 = (i-1)*c + j
idx3 = i*c + j-1
if i>0:
dp[x + idx] = max(dp[x + idx], dp[idx2]+v[idx])
dp[idx] = max(dp[idx],dp[idx2])
dp[x + idx]=max(dp[x + idx],dp[x + idx2]+v[idx])
dp[idx]=max(dp[idx],dp[x + idx2])
dp[x + idx]=max(dp[x + idx],dp[2*x + idx2]+v[idx])
dp[idx]=max(dp[idx],dp[2*x + idx2])
dp[x + idx]=max(dp[x + idx],dp[3*x + idx2]+v[idx])
dp[idx]=max(dp[idx],dp[3*x + idx2])
if j>0:
dp[x + idx]=max(dp[x + idx],dp[idx3]+v[idx])
dp[2*x + idx]=max(dp[2*x + idx],dp[x + idx3]+v[idx])
dp[3*x + idx]=max(dp[3*x + idx],dp[2*x + idx3]+v[idx])
dp[idx]=max(dp[idx],dp[idx3])
dp[x + idx]=max(dp[x + idx],dp[x + idx3])
dp[2*x + idx]=max(dp[2*x + idx],dp[2*x + idx3])
dp[3*x + idx]=max(dp[3*x + idx],dp[3*x + idx3])
#print(dp)
ans=0
for i in range(4): ans=max(dp[i*x + (r-1)*c + (c-1)],ans)
return print(ans)
if __name__=="__main__":
main()
| p02586 |
import sys
input=sys.stdin.readline
def main():
r,c,k=map(int,input().split())
v=[0] * (c * r)
for _ in range(k):
ri,ci,a=map(int,input().split())
v[(ri-1)*c + (ci-1)]=a
dp= [0] * (c * r * 4)
#print(dp)
x = c * r
if v[0]>0: dp[x] = v[0]
for i in range(r):
for j in range(c):
idx = i*c+j
idx2 = (i-1)*c + j
idx3 = i*c + j-1
if i>0:
dp[x + idx] = max(dp[x + idx], dp[idx2]+v[idx])
dp[idx] = max(dp[idx],dp[idx2])
dp[x + idx]=max(dp[x + idx],dp[x + idx2]+v[idx])
dp[idx]=max(dp[idx],dp[x + idx2])
dp[x + idx]=max(dp[x + idx],dp[2*x + idx2]+v[idx])
dp[idx]=max(dp[idx],dp[2*x + idx2])
dp[x + idx]=max(dp[x + idx],dp[3*x + idx2]+v[idx])
dp[idx]=max(dp[idx],dp[3*x + idx2])
if j>0:
dp[x + idx]=max(dp[x + idx],dp[idx3]+v[idx])
dp[2*x + idx]=max(dp[2*x + idx],dp[x + idx3]+v[idx])
dp[3*x + idx]=max(dp[3*x + idx],dp[2*x + idx3]+v[idx])
dp[idx]=max(dp[idx],dp[idx3])
dp[x + idx]=max(dp[x + idx],dp[x + idx3])
dp[2*x + idx]=max(dp[2*x + idx],dp[2*x + idx3])
dp[3*x + idx]=max(dp[3*x + idx],dp[3*x + idx3])
#print(dp)
ans=0
for i in range(4): ans=max(dp[i*x + (r-1)*c + (c-1)],ans)
return print(ans)
if __name__=="__main__":
main()
| import sys
input=sys.stdin.readline
def main():
r,c,k=map(int,input().split())
v=[0] * (c * r)
for _ in range(k):
ri,ci,a=map(int,input().split())
v[(ri-1)*c + (ci-1)]=a
dp= [0] * (c * r * 4)
#print(dp)
x = c * r
if v[0]>0: dp[x] = v[0]
for i in range(r):
for j in range(c):
idx = i*c+j
idx2 = (i-1)*c + j
idx3 = i*c + j-1
if i>0:
a = max(dp[idx2],dp[x + idx2],dp[2*x+idx2],dp[3*x+idx2])+v[idx]
dp[x+idx]=max(dp[x+idx], a)
dp[idx]=max(dp[idx],dp[idx2],dp[x+idx2],dp[2*x+idx2],dp[3*x+idx2])
if j>0:
dp[idx]=max(dp[idx],dp[idx3])
dp[x + idx]=max(dp[x + idx],dp[idx3]+v[idx],dp[x + idx3])
dp[2*x + idx]=max(dp[2*x + idx],dp[x + idx3]+v[idx],dp[2*x + idx3])
dp[3*x + idx]=max(dp[3*x + idx],dp[2*x + idx3]+v[idx],dp[3*x + idx3])
#print(dp)
ans=0
for i in range(4): ans = max(dp[i*x + (r-1)*c + (c-1)],ans)
return print(ans)
if __name__=="__main__":
main()
| p02586 |
import sys
input=sys.stdin.readline
class list2D:
def __init__(self, H, W, num):
self.__H = H
self.__W = W
self.__dat = [num] * (H * W)
def __getitem__(self, a):
return self.__dat[a[0]*self.__W+a[1]]
def __setitem__(self, a, b):
self.__dat[a[0]*self.__W+a[1]] = b
def debug(self):
print(self.__dat)
class list3D:
def __init__(self, H, W, D, num):
self.__H = H
self.__W = W
self.__D = D
self.__dat = [num] * (H * W * D)
def __getitem__(self, a):
return self.__dat[a[0]*self.__W*self.__D+a[1]*self.__D + a[2]]
def __setitem__(self, a, b):
self.__dat[a[0]*self.__W*self.__D+a[1]*self.__D + a[2]] = b
def debug(self):
print(self.__dat)
def main():
r,c,k=map(int,input().split())
v = list2D(r, c, 0)
for _ in range(k):
ri,ci,a=map(int,input().split())
v[ri-1, ci-1] = a
dp = list3D(r, c, 4, 0)
#print(dp)
if v[0, 0]>0: dp[0, 0, 1]=v[0, 0]
for i in range(r):
for j in range(c):
val = v[i, j]
if i>0:
x = 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]=max(dp[i, j, 1],x+val)
dp[i, j, 0]=max(dp[i, j, 0],x)
if j>0:
X = dp[i, j-1, 0]
Y = dp[i, j-1, 1]
V = dp[i, j-1, 2]
Z = dp[i, j-1, 3]
dp[i, j, 0]=max(dp[i, j, 0],X)
dp[i, j, 1]=max(dp[i, j, 1],X+val,Y)
dp[i, j, 2]=max(dp[i, j, 2],Y+val,V)
dp[i, j, 3]=max(dp[i, j, 3],V+val,Z)
#print(dp)
ans=0
for i in range(4): ans=max(dp[r-1, c-1, i],ans)
return print(ans)
if __name__=="__main__":
main()
| import sys
input=sys.stdin.readline
class list2D:
def __init__(self, H, W, num):
self.__H = H
self.__W = W
self.__dat = [num] * (H * W)
def __getitem__(self, a):
return self.__dat[a[0]*self.__W+a[1]]
def __setitem__(self, a, b):
self.__dat[a[0]*self.__W+a[1]] = b
def debug(self):
print(self.__dat)
class list3D:
def __init__(self, H, W, D, num):
self.__H = H
self.__W = W
self.__D = D
self.__X = W * D
self.__dat = [num] * (H * W * D)
def __getitem__(self, a):
return self.__dat[a[0]*self.__X+a[1]*self.__D + a[2]]
def __setitem__(self, a, b):
self.__dat[a[0]*self.__X+a[1]*self.__D + a[2]] = b
def debug(self):
print(self.__dat)
def main():
r,c,k=map(int,input().split())
v = list2D(r, c, 0)
for _ in range(k):
ri,ci,a=map(int,input().split())
v[ri-1, ci-1] = a
dp = list3D(r, c, 4, 0)
#print(dp)
if v[0, 0]>0: dp[0, 0, 1]=v[0, 0]
for i in range(r):
for j in range(c):
val = v[i, j]
if i>0:
x = 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]=max(dp[i, j, 1],x+val)
dp[i, j, 0]=max(dp[i, j, 0],x)
if j>0:
X = dp[i, j-1, 0]
Y = dp[i, j-1, 1]
V = dp[i, j-1, 2]
Z = dp[i, j-1, 3]
dp[i, j, 0]=max(dp[i, j, 0],X)
dp[i, j, 1]=max(dp[i, j, 1],X+val,Y)
dp[i, j, 2]=max(dp[i, j, 2],Y+val,V)
dp[i, j, 3]=max(dp[i, j, 3],V+val,Z)
#print(dp)
ans=0
for i in range(4): ans=max(dp[r-1, c-1, i],ans)
return print(ans)
if __name__=="__main__":
main()
| p02586 |
import sys
input=sys.stdin.readline
class list2D:
def __init__(self, H, W, num):
self.__H = H
self.__W = W
self.__dat = [num] * (H * W)
def __getitem__(self, a):
return self.__dat[a[0]*self.__W+a[1]]
def __setitem__(self, a, b):
self.__dat[a[0]*self.__W+a[1]] = b
def debug(self):
print(self.__dat)
class list3D:
def __init__(self, H, W, D, num):
self.__H = H
self.__W = W
self.__D = D
self.__X = W * D
self.__dat = [num] * (H * W * D)
def __getitem__(self, a):
return self.__dat[a[0]*self.__X+a[1]*self.__D + a[2]]
def __setitem__(self, a, b):
self.__dat[a[0]*self.__X+a[1]*self.__D + a[2]] = b
def debug(self):
print(self.__dat)
def main():
r,c,k=map(int,input().split())
v = list2D(r, c, 0)
for _ in range(k):
ri,ci,a=map(int,input().split())
v[ri-1, ci-1] = a
dp = list3D(r, c, 4, 0)
#print(dp)
if v[0, 0]>0: dp[0, 0, 1] = v[0, 0]
for i in range(r):
for j in range(c):
val = v[i, j]
if i>0:
x = 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]=x+val
dp[i, j, 0]=x
if j>0:
X = dp[i, j-1, 0]
Y = dp[i, j-1, 1]
V = dp[i, j-1, 2]
Z = dp[i, j-1, 3]
dp[i, j, 0]=max(dp[i, j, 0],X)
dp[i, j, 1]=max(dp[i, j, 1],X+val,Y)
dp[i, j, 2]=max(Y+val,V)
dp[i, j, 3]=max(V+val,Z)
#print(dp)
ans=0
for i in range(4): ans=max(dp[r-1, c-1, i],ans)
return print(ans)
if __name__=="__main__":
main()
| import sys
inp = [int(x) for x in sys.stdin.read().split()]
ii = 0
r, c, k = inp[ii:ii+3]
ii += 3
v=[0] * (c * r)
for _ in range(k):
ri,ci,a = inp[ii:ii+3]
ii += 3
v[(ri-1)*c + (ci-1)]=a
dp= [0] * (c * r * 4)
x = c * r
if v[0]>0: dp[x] = v[0]
for i in range(r):
for j in range(c):
idx = i*c+j
idx2 = (i-1)*c + j
idx3 = i*c + j-1
val = v[idx]
if i>0:
a = max(dp[idx2],dp[x + idx2],dp[2*x+idx2],dp[3*x+idx2])
dp[idx]= a
dp[x+idx]= a + val
if j>0:
dp[idx]=max(dp[idx],dp[idx3])
dp[x + idx]=max(dp[x + idx],dp[idx3]+val,dp[x + idx3])
dp[2*x + idx]=max(dp[x+idx3]+val,dp[2*x+idx3])
dp[3*x + idx]=max(dp[2*x+idx3]+val,dp[3*x+idx3])
ans=0
for i in range(4): ans = max(dp[i*x + (r-1)*c + (c-1)],ans)
print(ans)
| p02586 |
R,C,K = list(map(int, input().split()))
d = [[0 for _ in range(C+1)] for _ in range(R+1)]
dp = [[[0 for _ in range(4)] for _ in range(C+1)] for _ in range(R+1)]
for i in range(K):
r, c, v = list(map(int, input().split()))
d[r-1][c-1] = v
for i in range(R):
for j in range(C):
# kが大きい方からやらないとダメ。01ナップサックと同じ考え方。書き換えられた値を見ないように。
for k in range(2, -1, -1):
# 拾う遷移。d[i][j]を取るかどうかという判定
dp[i][j][k+1] = max(dp[i][j][k+1], dp[i][j][k] + d[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) | R,C,K = list(map(int, input().split()))
d = [[0 for _ in range(C+1)] for _ in range(R+1)]
dp = [[[0 for _ in range(C+1)] for _ in range(R+1)] for _ in range(4)]
for i in range(K):
r, c, v = list(map(int, input().split()))
d[r-1][c-1] = v
for i in range(R):
for j in range(C):
# kが大きい方からやらないとダメ。01ナップサックと同じ考え方。書き換えられた値を見ないように。
for k in range(2, -1, -1):
# 拾う遷移。d[i][j]を取るかどうかという判定
dp[k+1][i][j] = max(dp[k+1][i][j], dp[k][i][j] + d[i][j])
for k in range(4):
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])
ans = 0
for k in range(4):
ans = max(ans, dp[k][R-1][C-1])
print(ans) | p02586 |
def main():
import sys
input=sys.stdin.readline
h,w,k=list(map(int,input().split()))
H=list(range(h))
W=list(range(w))
dp=[[[0]*4 for j in W] for i in H]
for _ in range(k):
r,c,v=list(map(int,input().split()))
dp[r-1][c-1][0]=v
if dp[0][0][0]!=0:
dp[0][0][1]=dp[0][0][0]
dp[0][0][0]=0
for y in H:
for x in W:
v=dp[y][x][0]
dp[y][x][0]=0
for i in range(4):
if 0<x:
if dp[y][x][i]<dp[y][x-1][i]:
dp[y][x][i]=dp[y][x-1][i]
if 0<i and v!=0 and dp[y][x][i]<dp[y][x-1][i-1]+v:
dp[y][x][i]=dp[y][x-1][i-1]+v
if 0<y:
if dp[y][x][0]<dp[y-1][x][i]:
dp[y][x][0]=dp[y-1][x][i]
if v!=0 and dp[y][x][1]<dp[y-1][x][i]+v:
dp[y][x][1]=dp[y-1][x][i]+v
print((max(dp[h-1][w-1])))
main() | def main():
import sys
input=sys.stdin.readline
h,w,k=list(map(int,input().split()))
H=list(range(h))
W=list(range(w))
dp=[[[0]*w for j in H] for i in range(4)]
for _ in range(k):
r,c,v=list(map(int,input().split()))
dp[0][r-1][c-1]=v
if dp[0][0][0]!=0:
dp[1][0][0]=dp[0][0][0]
dp[0][0][0]=0
for y in H:
for x in W:
v=dp[0][y][x]
dp[0][y][x]=0
for i in range(4):
if 0<x:
if dp[i][y][x]<dp[i][y][x-1]:
dp[i][y][x]=dp[i][y][x-1]
if 0<i and v!=0 and dp[i][y][x]<dp[i-1][y][x-1]+v:
dp[i][y][x]=dp[i-1][y][x-1]+v
if 0<y:
if dp[0][y][x]<dp[i][y-1][x]:
dp[0][y][x]=dp[i][y-1][x]
if v!=0 and dp[1][y][x]<dp[i][y-1][x]+v:
dp[1][y][x]=dp[i][y-1][x]+v
print((max([dp[i][h-1][w-1] for i in range(4)])))
main() | 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
X = [[[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):
X[i][j][0] = max(X[i-1][j][0], X[i-1][j][1], X[i-1][j][2], X[i-1][j][3], X[i][j-1][0])
X[i][j][1] = max(X[i][j][0] + V[i][j], X[i][j-1][1])
X[i][j][2] = max(X[i][j-1][1] + V[i][j], X[i][j-1][2])
X[i][j][3] = max(X[i][j-1][2] + V[i][j], X[i][j-1][3])
print((max(X[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
X = [[[0] * 4 for _ in range(C + 1)] for _ in range(R + 1)]
for i in range(1, R + 1):
Xi = X[i]
Xi1 = X[i-1]
Vi = V[i]
for j in range(1, C + 1):
Vij = Vi[j]
Xij = Xi[j]
Xij1 = Xi[j-1]
Xij[0] = max(max(Xi1[j]), Xij1[0])
Xij[1] = max(Xij[0] + Vij, Xij1[1])
Xij[2] = max(Xij1[1] + Vij, Xij1[2])
Xij[3] = max(Xij1[2] + Vij, Xij1[3])
print((max(X[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
X = [[[0] * 4 for _ in range(C + 1)] for _ in range(R + 1)]
for i in range(1, R + 1):
Xi = X[i]
Xi1 = X[i-1]
Vi = V[i]
for j in range(1, C + 1):
Vij = Vi[j]
Xij = Xi[j]
Xij1 = Xi[j-1]
Xij[0] = max(max(Xi1[j]), Xij1[0])
Xij[1] = max(Xij[0] + Vij, Xij1[1])
Xij[2] = max(Xij1[1] + Vij, Xij1[2])
Xij[3] = max(Xij1[2] + Vij, Xij1[3])
print((max(X[R][C]))) | R, C, K = list(map(int, input().split()))
V = [[0] * (R + 1) for _ in range(C + 1)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
V[c][r] = v
X = [[0] * 4 for _ in range(R + 1)]
for i in range(1, C + 1):
Vi = V[i]
for j in range(1, R + 1):
v = Vi[j]
Xj = X[j]
if v:
Xj[3] = max(Xj[3], Xj[2] + v)
Xj[2] = max(Xj[2], Xj[1] + v)
Xj[0] = max(Xj[0], max(X[j-1]))
Xj[1] = max(Xj[1], Xj[0] + v)
else:
Xj[0] = max(Xj[0], max(X[j-1]))
print((max(X[R]))) | p02586 |
import sys
input = sys.stdin.readline
R, C, K = list(map(int, input().split()))
values = [[0]*C for _ in range(R)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
values[r-1][c-1] = v
dp = [[[0]*4 for _ in range(C)] for _ in range(R+1)] # [r, c, とったアイテム]のvの最大値
for r in range(R-1, -1, -1):
dp[r][C - 1][0] = dp[r + 1][C - 1][3]
for i in range(1, 4):
dp[r][C-1][i] = dp[r + 1][C-1][3]+values[r][C-1]
for c in range(C-2, -1, -1):
v = values[r][c]
for i in range(4):
if i == 0 or v==0:
dp[r][c][i] = max([dp[r+1][c][3], dp[r][c+1][i]])
else:
dp[r][c][i] = max([dp[r + 1][c][3]+v, dp[r][c + 1][i], dp[r][c + 1][i-1] + v])
print((dp[0][0][3]))
| import sys
input = sys.stdin.readline
R, C, K = list(map(int, input().split()))
values = [[0]*C for _ in range(R)]
for _ in range(K):
r, c, v = list(map(int, input().split()))
values[r-1][c-1] = v
dp = [[[0 for _ in range(C+1)] for _ in range(R+1)] for _ in range(4)]
for r in range(R-1, -1, -1):
# dp[0][r][C - 1] = dp[3][r + 1][C - 1]
# for i in range(1, 4):
# dp[i][r][C-1] = dp[3][r + 1][C-1][3]+values[r][C-1]
for c in range(C-1, -1, -1):
v = values[r][c]
for i in range(4):
if i == 0 or v == 0:
dp[i][r][c] = max(dp[3][r+1][c], dp[i][r][c+1])
else:
dp[i][r][c] = max(dp[3][r + 1][c]+v, dp[i][r][c + 1], dp[i-1][r][c + 1] + v)
print((dp[3][0][0]))
| p02586 |
import sys
import math
import collections
import bisect
import itertools
# import numpy as np
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline().rstrip())
ns = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na1 = lambda: list([int(x) - 1 for x in sys.stdin.readline().rstrip().split()])
# ===CODE===
def main():
r, c, k = ns()
mat = [[0 for _ in range(c + 1)] for __ in range(r + 1)]
for _ in range(k):
x, y, v = ns()
x, y = x - 1, y - 1
mat[x][y] = v
dp = [[[0 for ___ in range(4)] for _ in range(c + 1)] for __ in range(r + 1)]
for i in range(r):
for j in range(c):
for n in range(2, -1, -1):
dp[i][j][n + 1] = max(dp[i][j][n + 1], dp[i][j][n] + mat[i][j])
dp[i + 1][j][0] = max(dp[i][j])
for n in range(4):
dp[i][j + 1][n] = max(dp[i][j + 1][n], dp[i][j][n])
print((max(dp[r - 1][c - 1])))
if __name__ == '__main__':
main()
| import sys
import math
import collections
import bisect
import itertools
# import numpy as np
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline().rstrip())
ns = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na1 = lambda: list([int(x) - 1 for x in sys.stdin.readline().rstrip().split()])
# ===CODE===
def main():
r, c, k = ns()
mat = [[0 for _ in range(c + 1)] for __ in range(r + 1)]
for _ in range(k):
x, y, v = ns()
x, y = x - 1, y - 1
mat[x][y] = v
dp = [[0] * 4 for _ in range(c + 1)]
for i in range(r):
ndp = [[0] * 4 for _ in range(c + 1)]
for j in range(c):
for n in range(2, -1, -1):
dp[j][n + 1] = max(dp[j][n + 1], dp[j][n] + mat[i][j])
ndp[j][0] = max(dp[j])
for n in range(4):
dp[j + 1][n] = max(dp[j + 1][n], dp[j][n])
dp = ndp
print((max(dp[c - 1])))
if __name__ == '__main__':
main()
| p02586 |
import sys
input = lambda: sys.stdin.readline().rstrip()
inpl = lambda: list(map(int,input().split()))
R, C, K = inpl()
val = [[0]*(C+1) for r in range(R+1)]
for _ in range(K):
r, c, v = inpl()
val[r][c] = v
score = [[[0]*4 for c in range(C+1)] for r in range(R+1)]
for r in range(1,R+1):
for c in range(1,C+1):
for n in range(4):
if n == 0:
score[r][c][0] = max(max(score[r-1][c]), score[r][c-1][0])
elif val[r][c] == 0:
score[r][c][n] = score[r][c-1][n]
elif n == 1:
score[r][c][1] = max(max(score[r-1][c])+val[r][c],
score[r][c-1][0]+val[r][c],
score[r][c-1][1])
else:
score[r][c][n] = max(score[r][c-1][n-1]+val[r][c],
score[r][c-1][n])
print((max(score[R][C])))
| import sys
input = lambda: sys.stdin.readline().rstrip()
inpl = lambda: list(map(int,input().split()))
R, C, K = inpl()
N = 3
val = [[0]*(C+1) for r in range(R+1)]
for _ in range(K):
r, c, v = inpl()
val[r][c] = v
score = [[[0]*(N+1) for c in range(C+1)] for r in range(R+1)]
for r in range(1,R+1):
for c in range(1,C+1):
for n in range(N+1):
if n == 0:
score[r][c][0] = max(score[r-1][c][-1], score[r][c-1][0])
elif val[r][c] == 0:
score[r][c][n] = max(score[r][c-1][n],score[r][c][n-1])
elif n == 1:
score[r][c][1] = max(score[r-1][c][-1]+val[r][c],
score[r][c-1][0]+val[r][c],
score[r][c-1][1],
score[r][c][0])
else:
score[r][c][n] = max(score[r][c-1][n-1]+val[r][c],
score[r][c-1][n],
score[r][c][n-1])
print((score[R][C][-1]))
| p02586 |
import sys
input=sys.stdin.readline
R,C,K=list(map(int,input().split()))
rcv=[tuple(map(int,input().split())) for _ in range(K)]
MAP=[[0 for _ in range(C+2)] for _ in range(R+2)]
DP=[[[0 for _ in range(3)] for _ in range(C+2)] for _ in range(R+2)]
for r,c,v in rcv:
MAP[r-1][c-1]=v
for i in range(R):
for j in range(C):
for k in range(3):
if k==0:
DP[i][j][k]=max(DP[i][j-1][k],DP[i-1][j][k]+MAP[i][j],
DP[i-1][j][k+1]+MAP[i][j],
DP[i-1][j][k+2]+MAP[i][j])
else:
DP[i][j][k]=max(DP[i][j-1][k],DP[i][j-1][k-1]+MAP[i][j])
ans=0
for i in range(R):
for j in range(C):
ans=max(ans,max(DP[i][j]))
print(ans) | import sys
input = sys.stdin.readline
R,C,K=list(map(int,input().split()))
J=[tuple(map(int,input().split())) for i in range(K)]
#DP0=[[0]*(C+2) for i in range(R+2)]
DP1=[[0]*(C+2) for i in range(R+2)]
DP2=[[0]*(C+2) for i in range(R+2)]
DP3=[[0]*(C+2) for i in range(R+2)]
MAP=[[0]*C for i in range(R)]
for x,y,v in J:
MAP[x-1][y-1]=v
for i in range(R):
for j in range(C):
DP1[i][j]=max(DP1[i][j-1],DP1[i-1][j]+MAP[i][j],DP2[i-1][j]+MAP[i][j],DP3[i-1][j]+MAP[i][j])
DP2[i][j]=max(DP2[i][j-1],DP1[i][j-1]+MAP[i][j])
DP3[i][j]=max(DP3[i][j-1],DP2[i][j-1]+MAP[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()))
a = [[0] * (C+1) for i in range(R+1)]
dp = [[[0] * (C+1) for i in range(R+1)] for j in range(4)]
for i in range(K):
r,c,v = list(map(int, input().split()))
a[r-1][c-1] = v
for i in range(R):
for j in range(C):
for k in range(2,-1,-1):
dp[k+1][i][j] = max(dp[k+1][i][j], dp[k][i][j] + a[i][j])
for k in range(4):
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])
ans = 0
for k in range(4):
ans = max(ans, dp[k][R-1][C-1])
print(ans) | R,C,K = list(map(int, input().split()))
a = [[0] * (C+1) for i in range(R+1)]
dp = [[[0] * (C+1) for i in range(R+1)] for j in range(4)]
for i in range(K):
r,c,v = list(map(int, input().split()))
r -= 1
c -= 1
a[r][c] = v
for i in range(R):
for j in range(C):
for k in range(2,-1,-1):
dp[k+1][i][j] = max(dp[k+1][i][j], dp[k][i][j] + a[i][j])
for k in range(4):
dp[k][i][j+1] = max(dp[k][i][j+1], dp[k][i][j])
dp[0][i+1][j] = max(dp[0][i+1][j], dp[k][i][j])
ans = 0
for k in range(4):
ans = max(ans, dp[k][R-1][C-1])
print(ans)
| p02586 |
from copy import deepcopy
def getval():
r,c,k = list(map(int,input().split()))
item = [[0 for i in range(c)] for i in range(r)]
for i in range(k):
ri,ci,vi = list(map(int,input().split()))
item[ri-1][ci-1] = vi
return r,c,k,item
def main(r,c,k,item):
#DP containing the information of max value given k items picked in i,j
prev = [[0 for i in range(4)]]
inititem = item[0][0]
prev[0] = [0,inititem,inititem,inititem]
for i in range(1,r):
initval = prev[i-1][3]
temp = []
cur = item[i][0]
for j in range(4):
temp.append(initval)
for j in range(1,4):
temp[j] += cur
prev.append(temp)
for j in range(1,c):
init = deepcopy(prev[0])
for i in range(1,4):
init[i] = prev[0][i]
if prev[0][i-1]+item[0][j]>init[i]:
init[i] = prev[0][i-1]+item[0][j]
curcol = [init]
for i in range(1,r):
cur = item[i][j]
left = curcol[-1][3]
down = prev[i]
temp = [left]
if down[0]>temp[0]:
temp[0] = down[0]
for k in range(1,4):
c = down[k]
if left+cur>c:
c = left+cur
if down[k-1]+cur>c:
c = down[k-1]+cur
temp.append(c)
curcol.append(temp)
prev = deepcopy(curcol)
print((max(prev[-1])))
#print(prev)
if __name__=="__main__":
r,c,k,item = getval()
main(r,c,k,item) | from copy import deepcopy
def getval():
r,c,k = list(map(int,input().split()))
item = [[0 for i in range(c)] for i in range(r)]
for i in range(k):
ri,ci,vi = list(map(int,input().split()))
item[ri-1][ci-1] = vi
return r,c,k,item
def main(r,c,k,item):
#DP containing the information of max value given k items picked in i,j
prev = [[0 for i in range(4)]]
inititem = item[0][0]
prev[0] = [0,inititem,inititem,inititem]
for i in range(1,r):
initval = prev[i-1][3]
temp = []
cur = item[i][0]
for j in range(4):
temp.append(initval)
for j in range(1,4):
temp[j] += cur
prev.append(temp)
for j in range(1,c):
init = deepcopy(prev[0])
for i in range(1,4):
init[i] = max(prev[0][i],prev[0][i-1]+item[0][j])
curcol = [init]
for i in range(1,r):
cur = item[i][j]
left = curcol[-1]
down = prev[i]
temp = [max(left[3],down[0])]
for k in range(1,4):
temp.append(max(max(left[3],down[k-1])+cur,down[k]))
curcol.append(temp)
prev = curcol
print((max(prev[-1])))
if __name__=="__main__":
r,c,k,item = getval()
main(r,c,k,item) | p02586 |
# pypy
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
from collections import defaultdict
R, C, K = list(map(int, readline().split()))
rcv = list(map(int, read().split()))
rc2v = defaultdict(int)
for rr, cc, vv in zip(rcv[::3], rcv[1::3], rcv[2::3]):
rc2v[(rr-1, cc-1)] = vv
dp = [[[0]*4 for c in range(C)] for r in range(2)]
dp[0][0][1] = rc2v[(0, 0)]
for c in range(1, C):
for k in range(1, 4):
dp[0][c][k] = max(dp[0][c-1][k], dp[0][c-1][k-1]+rc2v[(0, c)])
for r in range(1, R):
rr = r % 2
dp[rr][0][0] = max(dp[rr-1][0])
dp[rr][0][1] = dp[rr][0][0] + rc2v[(r, 0)]
for c in range(1, C):
temp_max = max(dp[rr-1][c])
dp[rr][c][1] = max(dp[rr][c-1][1], max(dp[rr][c-1][0], temp_max)+rc2v[(r, c)])
for k in range(2, 4):
dp[rr][c][k] = max(dp[rr][c-1][k], dp[rr][c-1][k-1]+rc2v[(r, c)])
if R % 2:
print((max(dp[0][-1])))
else:
print((max(dp[-1][-1]))) | # pypy
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
R, C, K = list(map(int, readline().split()))
rcv = list(map(int, read().split()))
rc2v = {}
for rr, cc, vv in zip(rcv[::3], rcv[1::3], rcv[2::3]):
rc2v[(rr-1, cc-1)] = vv
dp = [[[0]*4 for c in range(C)] for r in range(2)]
dp[0][0][1] = rc2v[(0, 0)] if (0, 0) in rc2v else 0
for c in range(1, C):
for k in range(1, 4):
v = rc2v[(0, c)] if (0, c) in rc2v else 0
dp[0][c][k] = max(dp[0][c-1][k], dp[0][c-1][k-1]+v)
for r in range(1, R):
rr = r % 2
dp[rr][0][0] = max(dp[rr-1][0])
v = rc2v[(r, 0)] if (r, 0) in rc2v else 0
dp[rr][0][1] = dp[rr][0][0] + v
for c in range(1, C):
v = rc2v[(r, c)] if (r, c) in rc2v else 0
temp_max = max(dp[rr-1][c])
dp[rr][c][1] = max(dp[rr][c-1][1], max(dp[rr][c-1][0], temp_max)+v)
for k in range(2, 4):
dp[rr][c][k] = max(dp[rr][c-1][k], dp[rr][c-1][k-1]+v)
if R % 2:
print((max(dp[0][-1])))
else:
print((max(dp[-1][-1]))) | p02586 |
# pypy
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
R, C, K = list(map(int, readline().split()))
rcv = list(map(int, read().split()))
rc2v = {}
for rr, cc, vv in zip(rcv[::3], rcv[1::3], rcv[2::3]):
rc2v[(rr-1, cc-1)] = vv
dp = [[[0]*4 for c in range(C)] for r in range(2)]
dp[0][0][1] = rc2v[(0, 0)] if (0, 0) in rc2v else 0
for c in range(1, C):
for k in range(1, 4):
v = rc2v[(0, c)] if (0, c) in rc2v else 0
dp[0][c][k] = max(dp[0][c-1][k], dp[0][c-1][k-1]+v)
for r in range(1, R):
rr = r % 2
dp[rr][0][0] = max(dp[rr-1][0])
v = rc2v[(r, 0)] if (r, 0) in rc2v else 0
dp[rr][0][1] = dp[rr][0][0] + v
for c in range(1, C):
v = rc2v[(r, c)] if (r, c) in rc2v else 0
temp_max = max(dp[rr-1][c])
dp[rr][c][1] = max(dp[rr][c-1][1], max(dp[rr][c-1][0], temp_max)+v)
for k in range(2, 4):
dp[rr][c][k] = max(dp[rr][c-1][k], dp[rr][c-1][k-1]+v)
if R % 2:
print((max(dp[0][-1])))
else:
print((max(dp[-1][-1]))) | # pypy
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
R, C, K = list(map(int, readline().split()))
rcv = list(map(int, read().split()))
rc2v = {}
for rr, cc, vv in zip(rcv[::3], rcv[1::3], rcv[2::3]):
rc2v[(rr, cc)] = vv
dp = [[0]*4 for c in range(C+1)]
for r in range(1, R+1):
for c in range(1, C+1):
v = rc2v[(r, c)] if (r, c) in rc2v else 0
dp[c][0] = max(dp[c-1][0], max(dp[c]))
dp[c][1] = max(dp[c-1][1], dp[c][0] + v)
for k in range(2, 4):
dp[c][k] = max(dp[c-1][k], dp[c-1][k-1] + v)
print((max(dp[-1]))) | p02586 |
import sys
input=sys.stdin.readline
H,W,K=list(map(int,input().split()))
G=[[0]*W for i in range(H)]
for i in range(K):
r,c,v=list(map(int,input().split()))
r,c=r-1,c-1
G[r][c]=v
dp=[[[-1,-1,-1,-1] for i in range(W)] for i in range(H)]
dp[0][0][0]=0
if G[0][0]!=0:
dp[0][0][1]=G[0][0]
for i in range(H):
for j in range(W):
m=max(dp[i][j])
if i+1<H:
dp[i+1][j][1]=max(dp[i+1][j][1],m+G[i+1][j])
dp[i+1][j][0]=max(dp[i+1][j][0],m)
if j+1<W:
dp[i][j+1][0]=0
dp[i][j+1][1]=max(dp[i][j+1][1],dp[i][j][1],dp[i][j][0]+G[i][j+1])
dp[i][j+1][2]=max(dp[i][j+1][2],dp[i][j][2],dp[i][j][1]+G[i][j+1])
dp[i][j+1][3]=max(dp[i][j+1][3],dp[i][j][3],dp[i][j][2]+G[i][j+1])
print((max(dp[H-1][W-1]))) | import sys
input=sys.stdin.readline
H,W,K=list(map(int,input().split()))
G=[[0]*W for i in range(H)]
for i in range(K):
r,c,v=list(map(int,input().split()))
r,c=r-1,c-1
G[r][c]=v
dp0=[[-1 for i in range(W)] for i in range(H)]
dp1=[[-1 for i in range(W)] for i in range(H)]
dp2=[[-1 for i in range(W)] for i in range(H)]
dp3=[[-1 for i in range(W)] for i in range(H)]
dp0[0][0]=0
if G[0][0]!=0:
dp1[0][0]=G[0][0]
for i in range(H):
for j in range(W):
m=max(dp0[i][j],dp1[i][j],dp2[i][j],dp3[i][j])
if i+1<H:
dp1[i+1][j]=max(dp1[i+1][j],m+G[i+1][j])
dp0[i+1][j]=max(dp0[i+1][j],m)
if j+1<W:
dp0[i][j+1]=0
dp1[i][j+1]=max(dp1[i][j+1],dp1[i][j],dp0[i][j]+G[i][j+1])
dp2[i][j+1]=max(dp2[i][j+1],dp2[i][j],dp1[i][j]+G[i][j+1])
dp3[i][j+1]=max(dp3[i][j+1],dp3[i][j],dp2[i][j]+G[i][j+1])
print((max(dp0[H-1][W-1],dp1[H-1][W-1],dp2[H-1][W-1],dp3[H-1][W-1]))) | p02586 |
"""
dp[i][j] => i行目j列目がゴールの場合の最大値
"""
def main():
import sys
input = sys.stdin.readline
R,C,K = list(map(int,input().split()))
items = [[0]*(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]*4 for _ in range(C)] for _ in range(R)]
dp[0][0][1] = items[0][0]
for i in range(R):
for j in range(C):
v = items[i][j]
if i==0 and j == 0:
continue
if i!=0:
#上から入る場合のシミュレート
dp[i][j][0] = max(dp[i][j][0],max(dp[i-1][j]))
if v:
dp[i][j][1] = max(dp[i][j][1],max(dp[i-1][j])+v)
if j!=0:
#左から入る場合のシミュレート
dp[i][j][0] = max(dp[i][j][0],dp[i][j-1][0])
if v:
#itemが存在する場合の処理
for k in range(1,4):
dp[i][j][k] = max(dp[i][j][k],dp[i][j-1][k-1]+v,dp[i][j-1][k])
else:
for k in range(1,4):
dp[i][j][k] = max(dp[i][j][k],dp[i][j-1][k])
print((max(dp[-1][-1])))
main() | """
dp[i][j] => i行目j列目がゴールの場合の最大値
"""
def main():
import sys
input = sys.stdin.readline
R,C,K = list(map(int,input().split()))
items = [[0]*(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]*4 for _ in range(C)]
dp[0][1] = items[0][0]
for i in range(R):
for j in range(C):
v = items[i][j]
if i==0 and j == 0:
continue
if i!=0:
#上から入る場合のシミュレート
dp[j][0] = max(dp[j])
if v:
dp[j][1] = dp[j][0]+v
if j!=0:
#左から入る場合のシミュレート
dp[j][0] = max(dp[j][0],dp[j-1][0])
if v:
#itemが存在する場合の処理
for k in range(1,4):
dp[j][k] = max(dp[j][k],dp[j-1][k-1]+v,dp[j-1][k])
else:
for k in range(1,4):
dp[j][k] = max(dp[j][k],dp[j-1][k])
print((max(dp[-1])))
main()
| p02586 |
"""
dp[i][j][k] => i行目、j列のマスまで見る。k個取る時の最高値。
"""
def main():
import sys
input = sys.stdin.readline
R,C,K = list(map(int,input().split()))
items = [[0]*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]*4 for _ in range(C)]for _ in range(R)]
for i in range(R):
for j in range(C):
v = items[i][j]
if i == 0 and j == 0 and v != 0:
dp[i][j][1] = v
#上から降りてくる場合の価値を求める
if i != 0:
#i行目j列のアイテムを取らない場合
dp[i][j][0] = max(dp[i-1][j])
#i行目j列のアイテムを取る場合
if v!=0:
dp[i][j][1] = max(dp[i-1][j]) + v
#左から入ってくる場合の価値を求める
if j != 0:
if v == 0:
for k in range(4):
dp[i][j][k] = max(dp[i][j][k],dp[i][j-1][k])
else:
for k in range(1,4):
dp[i][j][k] = max(dp[i][j][k],dp[i][j-1][k],dp[i][j-1][k-1]+v)
if i > 0:
tmp = dp[i-1]
dp[i-1] = []
del(tmp)
print((max(dp[-1][-1])))
main() | """
dp[i][j][k] => i行目、j列のマスまで見る。k個取る時の最高値。
"""
def main():
import sys
input = sys.stdin.readline
R,C,K = list(map(int,input().split()))
items = [[0]*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]*4 for _ in range(C)]
for i in range(R):
for j in range(C):
v = items[i][j]
if i == 0 and j == 0 and v != 0:
dp[j][1] = v
continue
if i != 0:
#上から降りてくる場合の価値を求める
#i行目j列のアイテムを取らない場合
dp[j][0] = max(dp[j])
#i行目j列のアイテムを取る場合
if v!=0:
dp[j][1] = dp[j][0] + v
#左から入ってくる場合の価値を求める
if j != 0:
dp[j][0] = max(dp[j][0],dp[j-1][0])
if v == 0:
for k in range(1,4):
dp[j][k] = max(dp[j][k],dp[j-1][k])
else:
for k in range(1,4):
dp[j][k] = max(dp[j][k],dp[j-1][k],dp[j-1][k-1]+v)
print((max(dp[-1])))
main() | p02586 |
"""
dp[i][j][k] => i行目j列到達時点での最大価値。i行目において拾えるアイテムの数はK個。
"""
def main():
import sys
input = sys.stdin.readline
R,C,K = list(map(int,input().split()))
items = [[0]*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]*4 for _ in range(C)]for _ in range(R)]
for i in range(R):
for j in range(C):
v = items[i][j]
#上から入るパターン
dp[i][j][0] = max(dp[i-1][j])
if v:
dp[i][j][1] = dp[i][j][0]+v
#左から入ってくるパターン
if j > 0:
for k in range(4):
#このマスのアイテムをとらないパターン
dp[i][j][k] = max(dp[i][j][k],dp[i][j-1][k])
if v and k>0:
dp[i][j][k] = max(dp[i][j][k],dp[i][j-1][k-1]+v)
print((max(dp[-1][-1])))
main() | """
dp[i][j][k] => i行目j列到達時点での最大価値。i行目において拾えるアイテムの数はK個。
"""
def main():
import sys
input = sys.stdin.readline
R,C,K = list(map(int,input().split()))
items = [[0]*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]*4 for _ in range(C)]
for i in range(R):
for j in range(C):
v = items[i][j]
#上から入るパターン
dp[j][0] = max(dp[j])
if v:
dp[j][1] = dp[j][0]+v
#左から入ってくるパターン
if j > 0:
for k in range(4):
#このマスのアイテムをとらないパターン
dp[j][k] = max(dp[j][k],dp[j-1][k])
if v and k>0:
dp[j][k] = max(dp[j][k],dp[j-1][k-1]+v)
print((max(dp[-1])))
main() | p02586 |
R,C,K = list(map(int,input().split()))
V = [[0 for c in range(C+1)] for r in range(R+1)]
r_list = [False for r in range(R+1)]
c_list = [False for c in range(C+1)]
for i in range(K):
r,c,v = list(map(int,input().split()))
V[r][c] = v
r_list[r] = True
c_list[c] = True
r_map = {}
cnt = 0
for i in range(R+1):
if r_list[i]:
cnt += 1
r_map[i] = cnt
r_len = cnt
c_map = {}
cnt = 0
for i in range(C+1):
if c_list[i]:
cnt += 1
c_map[i] = cnt
c_len = cnt
new_v = [[0 for i in range(c_len+1)] for j in range(r_len+1)]
for r in range(R+1):
for c in range(C+1):
if V[r][c] > 0:
new_v[r_map[r]][c_map[c]] = V[r][c]
V = new_v
R = r_len
C = c_len
dp = [[[0 for i in range(4)] for j in range(C+1)] for k in range(R+1)]
for r in range(1, R+1):
for c in range(1, C+1):
v = V[r][c]
under_val = max(dp[r-1][c])
dp[r][c][0] = max(under_val, dp[r][c-1][0])
if v > 0:
dp[r][c][1] = max(under_val + v, dp[r][c-1][0] + v, dp[r][c-1][1])
dp[r][c][2] = max(dp[r][c-1][1] + v, dp[r][c-1][2])
dp[r][c][3] = max(dp[r][c-1][2] + v, dp[r][c-1][3])
else:
dp[r][c][1] = dp[r][c-1][1]
dp[r][c][2] = dp[r][c-1][2]
dp[r][c][3] = dp[r][c-1][3]
print((max(dp[-1][-1]))) | R,C,K = list(map(int,input().split()))
V = [[0 for c in range(C+1)] for r in range(R+1)]
for i in range(K):
r,c,v = list(map(int,input().split()))
V[r][c] = v
dp = [[0 for i in range(4)] for j in range(C+1)]
for r in range(1, R+1):
for c in range(1, C+1):
v = V[r][c]
under_val = max(dp[c])
dp[c][0] = max(under_val, dp[c-1][0])
if v > 0:
dp[c][1] = max(under_val + v, dp[c-1][0] + v, dp[c-1][1])
dp[c][2] = max(dp[c-1][1] + v, dp[c-1][2])
dp[c][3] = max(dp[c-1][2] + v, dp[c-1][3])
else:
dp[c][1] = dp[c-1][1]
dp[c][2] = dp[c-1][2]
dp[c][3] = dp[c-1][3]
print((max(dp[-1]))) | p02586 |
def e_picking_goods():
R, C, K = [int(i) for i in input().split()]
Goods = [[0] * (C + 1) for _ in range(R + 1)]
for _ in range(K):
r, c, v = [int(i) for i in input().split()]
Goods[r][c] = v
# dp[i][j][k]: マス (i, j) まで来たとき、その時点で i 行目のアイテムは k 個回収している
# 場合の、回収したアイテムの価値の総和の最大値
dp = [[[0] * 4 for j in range(C + 1)] for i in range(R + 1)]
for i in range(R + 1):
for j in range(C + 1):
for k in range(4):
# 下へ行く
if i - 1 >= 0:
# 行を変えるので、k は 0 にリセットされる
dp[i][j][0] = max(dp[i][j][0], dp[i - 1][j][k]) # (i, j) のアイテムを拾わない
dp[i][j][1] = max(dp[i][j][1], dp[i - 1][j][k] + Goods[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] + Goods[i][j]) # まだ拾えるし、拾う
return max(dp[R][C][k] for k in range(4))
print((e_picking_goods())) | def e_picking_goods():
# 参考: https://atcoder.jp/contests/abc175/submissions/16044254
R, C, K = [int(i) for i in input().split()]
Goods = [[0] * (C + 1) for _ in range(R + 1)]
for _ in range(K):
r, c, v = [int(i) for i in input().split()]
Goods[r][c] = v
# editorial に対し、行の情報を除去する
dp = [[0] * 4 for _ in range(C + 1)]
for i in range(1, R + 1):
dp_next = [[0] * 4 for _ in range(C + 1)]
for j in range(1, C + 1):
up_max = max(dp[j]) # 上のマスで 0~3 回アイテムを拾っていたときの、価値の最大値
v = Goods[i][j]
# 左か上から来て、アイテムを拾わない
dp_next[j][0] = max(up_max, dp_next[j - 1][0])
# 上から来て拾う or 左から来て拾う or 左から来て拾わない
dp_next[j][1] = max(up_max + v, dp_next[j - 1][0] + v, dp_next[j - 1][1])
# 左から来て k-1 個拾っており、ここで拾う or k 個拾っており、ここで拾わない
for k in range(2, 4):
dp_next[j][k] = max(dp_next[j - 1][k - 1] + v, dp_next[j - 1][k])
dp = dp_next # 次の行へ注目を移す
return max(dp[-1])
print((e_picking_goods())) | p02586 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
R, C, K, *RCV = list(map(int, read().split()))
item = dict()
for r, c, v in zip(*[iter(RCV)] * 3):
item[(r - 1, c - 1)] = v
dp = [0] * (C + 1)
for i in range(R):
dp, dp_prev = [0] * (C + 1), dp
v = [0] * 4
for j in range(C):
for k in range(4):
if v[k] < dp_prev[j + 1]:
v[k] = dp_prev[j + 1]
if (i, j) in item:
for k in range(2, -1, -1):
if v[k + 1] < v[k] + item[(i, j)]:
v[k + 1] = v[k] + item[(i, j)]
dp[j + 1] = v[3]
print((dp[C]))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
R, C, K, *RCV = list(map(int, read().split()))
item = [[0] * C for _ in range(R)]
for r, c, v in zip(*[iter(RCV)] * 3):
item[r - 1][c - 1] = v
dp = [0] * (C + 1)
for i in range(R):
dp, dp_prev = [0] * (C + 1), dp
v = [0] * 4
for j in range(C):
for k in range(4):
if v[k] < dp_prev[j + 1]:
v[k] = dp_prev[j + 1]
if item[i][j] > 0:
for k in range(2, -1, -1):
if v[k + 1] < v[k] + item[i][j]:
v[k + 1] = v[k] + item[i][j]
dp[j + 1] = v[3]
print((dp[C]))
return
if __name__ == '__main__':
main()
| p02586 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
R, C, K, *RCV = list(map(int, read().split()))
item = [[0] * C for _ in range(R)]
for r, c, v in zip(*[iter(RCV)] * 3):
item[r - 1][c - 1] = v
dp = [0] * (C + 1)
for i in range(R):
dp, dp_prev = [0] * (C + 1), dp
v = [0] * 4
for j in range(C):
for k in range(4):
if v[k] < dp_prev[j + 1]:
v[k] = dp_prev[j + 1]
if item[i][j] > 0:
for k in range(2, -1, -1):
if v[k + 1] < v[k] + item[i][j]:
v[k + 1] = v[k] + item[i][j]
dp[j + 1] = v[3]
print((dp[C]))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
R, C, K, *RCV = list(map(int, read().split()))
item = [[0] * C for _ in range(R)]
for r, c, v in zip(*[iter(RCV)] * 3):
item[r - 1][c - 1] = v
dp = [0] * (C + 1)
for i in range(R):
dp, dp_prev = [0] * (C + 1), dp
v = [0] * 4
for j in range(C):
for k in range(4):
if v[k] < dp_prev[j + 1]:
v[k] = dp_prev[j + 1]
else:
break
if item[i][j] > 0:
for k in range(2, -1, -1):
if v[k + 1] < v[k] + item[i][j]:
v[k + 1] = v[k] + item[i][j]
dp[j + 1] = v[3]
print((dp[C]))
return
if __name__ == '__main__':
main()
| p02586 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
R, C, K, *RCV = list(map(int, read().split()))
item = [[0] * C for _ in range(R)]
for r, c, v in zip(*[iter(RCV)] * 3):
item[r - 1][c - 1] = v
dp = [0] * (C + 1)
for i in range(R):
dp, dp_prev = [0] * (C + 1), dp
v = [0] * 4
for j in range(C):
for k in range(4):
if v[k] < dp_prev[j + 1]:
v[k] = dp_prev[j + 1]
else:
break
if item[i][j] > 0:
for k in range(2, -1, -1):
if v[k + 1] < v[k] + item[i][j]:
v[k + 1] = v[k] + item[i][j]
dp[j + 1] = v[3]
print((dp[C]))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
R, C, K, *RCV = list(map(int, read().split()))
item = [[0] * C for _ in range(R)]
for r, c, v in zip(*[iter(RCV)] * 3):
item[r - 1][c - 1] = v
dp = [0] * (C + 1)
for i in range(R):
value = [0] * 4
for j in range(C):
for k in range(4):
if value[k] < dp[j + 1]:
value[k] = dp[j + 1]
else:
break
if item[i][j] > 0:
for k in range(2, -1, -1):
if value[k + 1] < value[k] + item[i][j]:
value[k + 1] = value[k] + item[i][j]
dp[j + 1] = value[3]
print((dp[C]))
return
if __name__ == '__main__':
main()
| p02586 |
import sys
from collections import defaultdict
input=sys.stdin.readline
d=defaultdict(int)
R,C,k=list(map(int,input().split()))
for i in range(k):
r,c,v=list(map(int,input().split()))
d[(r-1)*C+c-1]=v
dp=[[[0,0,0,0] for j in range(C+1)] for i in range(R+1)]
for i in range(1,R+1):
for j in range(1,C+1):
V=d[(i-1)*C+(j-1)]
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]=max(dp[i][j][0]+V,dp[i][j-1][1])
dp[i][j][2]=max(dp[i][j-1][1]+V,dp[i][j-1][2])
dp[i][j][3]=max(dp[i][j-1][2]+V,dp[i][j-1][3])
print((max(dp[-1][-1]))) | import sys
input=sys.stdin.readline
R,C,k=list(map(int,input().split()))
A=[[0]*C for i in range(R)]
for i in range(k):
r,c,v=list(map(int,input().split()))
A[r-1][c-1]=v
dp=[[[0,0,0,0] for j in range(C+1)] for i in range(R+1)]
for i in range(1,R+1):
for j in range(1,C+1):
V=A[i-1][j-1]
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]=max(dp[i][j][0]+V,dp[i][j-1][1])
dp[i][j][2]=max(dp[i][j-1][1]+V,dp[i][j-1][2])
dp[i][j][3]=max(dp[i][j-1][2]+V,dp[i][j-1][3])
print((max(dp[-1][-1]))) | p02586 |
import sys
input=sys.stdin.readline
R,C,k=list(map(int,input().split()))
A=[[0]*C for i in range(R)]
for i in range(k):
r,c,v=list(map(int,input().split()))
A[r-1][c-1]=v
dp=[[[0,0,0,0] for j in range(C+1)] for i in range(R+1)]
for i in range(1,R+1):
for j in range(1,C+1):
V=A[i-1][j-1]
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]=max(dp[i][j][0]+V,dp[i][j-1][1])
dp[i][j][2]=max(dp[i][j-1][1]+V,dp[i][j-1][2])
dp[i][j][3]=max(dp[i][j-1][2]+V,dp[i][j-1][3])
print((max(dp[-1][-1]))) | import sys
input=sys.stdin.readline
R,C,k=list(map(int,input().split()))
A=[[0]*C for i in range(R)]
for i in range(k):
r,c,v=list(map(int,input().split()))
A[r-1][c-1]=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=A[i-1][j-1]
dp0[i][j]=max(dp0[i-1][j],dp1[i-1][j],dp2[i-1][j],dp3[i-1][j],dp0[i][j-1])
dp1[i][j]=max(dp0[i][j]+V,dp1[i][j-1])
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[-1][-1],dp1[-1][-1],dp2[-1][-1],dp3[-1][-1]))) | p02586 |
import sys
input=lambda: sys.stdin.readline().rstrip()
import collections
D=collections.defaultdict(int)
r,c,k=list(map(int,input().split()))
for _ in range(k):
ri,ci,v=list(map(int,input().split()))
ri-=1
ci-=1
D[ri*10**5+ci]=v
DP=[[[0]*4 for _ in range(c+1)] for i in range(r+1)]
for i in range(r+1):
for j in range(c+1):
v=D[i*10**5+j]
if v!=0:
DP[i][j][1]=max(DP[i-1][j])+v
for ii in range(4):
DP[i][j][0]=max(DP[i][j][0],DP[i-1][j][ii])
if v!=0:
DP[i][j][1]=max(DP[i][j][1],DP[i-1][j][ii]+v)
DP[i][j][ii]=max(DP[i][j][ii],DP[i][j-1][ii])
if v!=0 and ii!=0:
DP[i][j][ii]=max(DP[i][j][ii],DP[i][j-1][ii-1]+v)
ans=max(DP[r-1][c-1])
print(ans)
| import sys
input=lambda: sys.stdin.readline().rstrip()
import collections
D=collections.defaultdict(int)
r,c,k=list(map(int,input().split()))
for _ in range(k):
ri,ci,v=list(map(int,input().split()))
ri-=1
ci-=1
D[ri*10**5+ci]=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(r+1):
for j in range(c+1):
v=D[i*10**5+j]
if v!=0:
DP1[i][j]=max(DP0[i-1][j],DP1[i-1][j],DP2[i-1][j],DP3[i-1][j])+v
DP0[i][j]=max(DP0[i][j],DP0[i-1][j],DP1[i-1][j],DP2[i-1][j],DP3[i-1][j])
if v!=0:
DP1[i][j]=max(DP1[i][j],DP0[i-1][j]+v,DP1[i-1][j]+v,DP2[i-1][j]+v,DP3[i-1][j]+v)
DP0[i][j]=max(DP0[i][j],DP0[i][j-1])
DP1[i][j]=max(DP1[i][j],DP1[i][j-1])
DP2[i][j]=max(DP2[i][j],DP2[i][j-1])
DP3[i][j]=max(DP3[i][j],DP3[i][j-1])
if v!=0:
DP1[i][j]=max(DP1[i][j],DP0[i][j-1]+v)
DP2[i][j]=max(DP2[i][j],DP1[i][j-1]+v)
DP3[i][j]=max(DP3[i][j],DP2[i][j-1]+v)
ans=max(DP0[r-1][c-1],DP1[r-1][c-1],DP2[r-1][c-1],DP3[r-1][c-1])
print(ans)
| p02586 |
import sys
input=lambda: sys.stdin.readline().rstrip()
import collections
D=collections.defaultdict(int)
r,c,k=list(map(int,input().split()))
for _ in range(k):
ri,ci,v=list(map(int,input().split()))
ri-=1
ci-=1
D[ri*10**5+ci]=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(r+1):
for j in range(c+1):
v=D[i*10**5+j]
if v!=0:
DP1[i][j]=max(DP0[i-1][j],DP1[i-1][j],DP2[i-1][j],DP3[i-1][j])+v
DP0[i][j]=max(DP0[i][j],DP0[i-1][j],DP1[i-1][j],DP2[i-1][j],DP3[i-1][j])
if v!=0:
DP1[i][j]=max(DP1[i][j],DP0[i-1][j]+v,DP1[i-1][j]+v,DP2[i-1][j]+v,DP3[i-1][j]+v)
DP0[i][j]=max(DP0[i][j],DP0[i][j-1])
DP1[i][j]=max(DP1[i][j],DP1[i][j-1])
DP2[i][j]=max(DP2[i][j],DP2[i][j-1])
DP3[i][j]=max(DP3[i][j],DP3[i][j-1])
if v!=0:
DP1[i][j]=max(DP1[i][j],DP0[i][j-1]+v)
DP2[i][j]=max(DP2[i][j],DP1[i][j-1]+v)
DP3[i][j]=max(DP3[i][j],DP2[i][j-1]+v)
ans=max(DP0[r-1][c-1],DP1[r-1][c-1],DP2[r-1][c-1],DP3[r-1][c-1])
print(ans)
| import sys
input=lambda: sys.stdin.readline().rstrip()
r,c,k=list(map(int,input().split()))
D=[[0]*c for _ in range(r)]
for _ in range(k):
ri,ci,v=list(map(int,input().split()))
ri-=1
ci-=1
D[ri][ci]=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(r):
for j in range(c):
v=D[i][j]
if v!=0:
DP1[i][j]=max(DP0[i-1][j],DP1[i-1][j],DP2[i-1][j],DP3[i-1][j])+v
DP0[i][j]=max(DP0[i][j],DP0[i-1][j],DP1[i-1][j],DP2[i-1][j],DP3[i-1][j])
if v!=0:
DP1[i][j]=max(DP1[i][j],DP0[i-1][j]+v,DP1[i-1][j]+v,DP2[i-1][j]+v,DP3[i-1][j]+v)
DP0[i][j]=max(DP0[i][j],DP0[i][j-1])
DP1[i][j]=max(DP1[i][j],DP1[i][j-1])
DP2[i][j]=max(DP2[i][j],DP2[i][j-1])
DP3[i][j]=max(DP3[i][j],DP3[i][j-1])
if v!=0:
DP1[i][j]=max(DP1[i][j],DP0[i][j-1]+v)
DP2[i][j]=max(DP2[i][j],DP1[i][j-1]+v)
DP3[i][j]=max(DP3[i][j],DP2[i][j-1]+v)
ans=max(DP0[r-1][c-1],DP1[r-1][c-1],DP2[r-1][c-1],DP3[r-1][c-1])
print(ans)
| p02586 |
import sys
input = sys.stdin.buffer.readline
r, c, k = list(map(int, input().split()))
graph = [[0] * (c) for _ in range(r)]
for _ in range(k):
d, e, f = list(map(int, input().split()))
graph[d - 1][e - 1] = f
# dijkstra
infi = 10 ** 10
money = [[[-infi] * (4) for _ in range(c)] for _ in range(r)]
money[0][0][0] = 0
for i in range(r):
for j in range(c):
for t in range(4):
m = money[i][j][t]
delta = graph[i][j]
if i < r - 1:
ni = i + 1
nj = j
nt = 0
money[ni][nj][nt] = max(money[ni][nj][nt], m)
if t < 3:
money[ni][nj][nt] = max(money[ni][nj][nt], m + delta)
if j < c - 1:
ni = i
nj = j + 1
nt = t
money[ni][nj][nt] = max(money[ni][nj][nt], m)
if t < 3:
nt = t + 1
money[ni][nj][nt] = max(money[ni][nj][nt], m + delta)
if graph[r - 1][c - 1] > 0:
for t in range(3):
money[r - 1][c - 1][t] += graph[r - 1][c - 1]
ans = max(money[r - 1][c - 1])
print(ans)
| import sys
input = sys.stdin.buffer.readline
r, c, k = list(map(int, input().split()))
graph = [[0] * (c) for _ in range(r)]
for _ in range(k):
d, e, f = list(map(int, input().split()))
graph[d - 1][e - 1] = f
infi = 10 ** 10
money = [[[-infi] * (c) for _ in range(r)] for _ in range(4)]
money[0][0][0] = 0
for i in range(r):
for j in range(c):
for t in range(4):
m = money[t][i][j]
delta = graph[i][j]
if i < r - 1:
ni = i + 1
nj = j
nt = 0
money[nt][ni][nj] = max(money[nt][ni][nj], m)
if t < 3:
money[nt][ni][nj] = max(money[nt][ni][nj], m + delta)
if j < c - 1:
ni = i
nj = j + 1
nt = t
money[nt][ni][nj] = max(money[nt][ni][nj], m)
if t < 3:
nt = t + 1
money[nt][ni][nj] = max(money[nt][ni][nj], m + delta)
ans = 0
if graph[r - 1][c - 1] > 0:
for t in range(3):
money[t][r - 1][c - 1] += graph[r - 1][c - 1]
for i in range(4):
ans = max(money[i][r - 1][c - 1], ans)
print(ans)
| p02586 |
while 1:
n=eval(input())
if n==0:break
p=list(map(int,input().split()))
sp=p[0]
ans=[]
for i in range(n-1):
if p[i]+1!=p[i+1]:
if sp!=p[i]:
ans.append(str(sp)+"-"+str(p[i]))
else:
ans.append(str(sp))
sp=p[i+1]
else:
if sp!=p[-1]:
ans.append(str(sp)+"-"+str(p[-1]))
else:
ans.append(str(sp))
print(" ".join(ans)) | while 1:
n=eval(input())
if n==0:break
p=list(map(int,input().split()))+["end"]
sp=p[0]
ans=[]
for i in range(n):
if p[i]+1!=p[i+1]:
if sp!=p[i]:
ans.append(str(sp)+"-"+str(p[i]))
else:
ans.append(str(sp))
sp=p[i+1]
print(" ".join(ans)) | p00637 |
#!/usr/bin/env python3
import sys
MOD = 998244353 # type: int
def comb(n, k):
if k > n:
return 0
k = min(k, n - k)
ret = 1
for i in range(k):
ret *= n - i
ret //= i + 1
return ret
def solve(S: str):
n = len(S)
b_total = 0
b_counts = []
for c in S:
b_total += ord(c) - ord('0')
b_counts.append(b_total)
dp = [[0] * (b_total + 1) for _ in range(2 * n + 1)]
dp[0][0] = 1
for i in range(n):
for j in range(min(i + 1, b_total + 1)):
if b_counts[i] >= j + 1:
dp[i + 1][j + 1] += dp[i][j]
if (i + 1) * 2 - b_counts[i] >= (i + 1) - j:
dp[i + 1][j] += dp[i][j]
# print(dp[i])
#print(dp[n])
ret = 0
for b, val in enumerate(dp[n]):
ret += val * comb(n, b_total - b)
print((ret % MOD))
return
##dp[0][0] = 1
##for i in range(2 * n):
## for j in range(min(i + 1, b_total + 1)):
## b_max = b_counts[i] if i < n else b_total
## r_max = (i + 1) * 2 - b_max if i < n else 2 * n - b_total
## if b_max >= j + 1:
## dp[i + 1][j + 1] += dp[i][j]
## if r_max >= (i + 1) - j:
## dp[i + 1][j] += dp[i][j]
##ret = sum(dp[2 * n])
##print(ret % MOD)
##return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = str(next(tokens))
solve(S)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
MOD = 998244353 # type: int
def comb(n, k):
if k > n:
return 0
k = min(k, n - k)
ret = 1
for i in range(k):
ret *= n - i
ret //= i + 1
return ret
def solve(S: str):
n = len(S)
b_total = 0
b_counts = []
for c in S:
b_total += ord(c) - ord('0')
b_counts.append(b_total)
dp = [[0] * (b_total + 1) for _ in range(2 * n + 1)]
dp[0][0] = 1
for i in range(n):
for j in range(min(i + 1, b_total + 1)):
if b_counts[i] >= j + 1:
dp[i + 1][j + 1] += dp[i][j]
if (i + 1) * 2 - b_counts[i] >= (i + 1) - j:
dp[i + 1][j] += dp[i][j]
# print(dp[i])
#print(dp[n])
comb = [0] * (n + 1)
comb[0] = 1
for i in range(n):
comb[i + 1] = comb[i] * (n - i) // (i + 1)
ret = 0
for b, val in enumerate(dp[n]):
#ret += val * comb(n, b_total - b)
if b_total - b >= 0 and b_total - b <= n:
ret += val * comb[b_total - b]
print((ret % MOD))
return
##dp[0][0] = 1
##for i in range(2 * n):
## for j in range(min(i + 1, b_total + 1)):
## b_max = b_counts[i] if i < n else b_total
## r_max = (i + 1) * 2 - b_max if i < n else 2 * n - b_total
## if b_max >= j + 1:
## dp[i + 1][j + 1] += dp[i][j]
## if r_max >= (i + 1) - j:
## dp[i + 1][j] += dp[i][j]
##ret = sum(dp[2 * n])
##print(ret % MOD)
##return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = str(next(tokens))
solve(S)
if __name__ == '__main__':
main()
| p03134 |
def f(n):
for k, c in list(dic.items()):
a, b = k
if a == n:
if not b in cost or c < cost[b]:
cost[b] = c
elif b == n:
if not a in cost or c < cost[a]:
cost[a] = c
for k, c in sorted(list(cost.items()), key=lambda x: x[1]):
if not k in res:
res.append(k)
ans.append(c)
f(k)
while True:
n, m = list(map(int, input().split()))
if n == m == 0: break
dic = {}
s, b, c = list(map(int, input().split()))
dic[(s, b)] = c
for i in range(m-1):
a, b, c = list(map(int, input().split()))
dic[(a, b)] = c
cost = {}
res = [s]
ans = []
f(s)
print(sum(ans)) | def f(n, ans):
for k, c in list(dic.items()):
a, b = k
if a == n:
if not b in cost or c < cost[b]:
cost[b] = c
elif b == n:
if not a in cost or c < cost[a]:
cost[a] = c
for k, c in sorted(list(cost.items()), key=lambda x: x[1]):
if not k in res:
res.append(k)
ans += c
del cost[k]
return f(k, ans)
return ans
while True:
n, m = list(map(int, input().split()))
if n == m == 0: break
dic = {}
s, b, c = list(map(int, input().split()))
dic[(s, b)] = c
for i in range(m-1):
a, b, c = list(map(int, input().split()))
dic[(a, b)] = c
cost = {}
res = [s]
print(f(s, 0)) | p00180 |
def f(s, cost, route, ans):
route.append(s)
ans += cost[s]
del cost[s]
for k, c in list(data.items()):
a, b = k
if s == a:
if not b in route:
if not b in cost or c < cost[b]:
cost[b] = c
elif s == b:
if not a in route:
if not a in cost or c < cost[a]:
cost[a] = c
if cost:
s = sorted(list(cost.items()), key=lambda x: x[1])[0][0]
return f(s, cost, route, ans)
else:
return ans
while True:
n, m = list(map(int, input().split()))
if n == m == 0: break
data = {}
for i in range(m):
a, b, c = list(map(int, input().split()))
data[(a, b)] = c
else:
print(f(0, {0:0}, [], 0)) | def f(s, cost, route, ans):
route.append(s)
ans += cost[s]
del cost[s]
for k, c in list(data.items()):
if s in k:
a, b = k
b = b if s == a else a
if not b in route:
if not b in cost or c < cost[b]:
cost[b] = c
if cost:
s = sorted(list(cost.items()), key=lambda x: x[1])[0][0]
return f(s, cost, route, ans)
else:
return ans
while True:
n, m = list(map(int, input().split()))
if n == m == 0: break
data = {}
for i in range(m):
a, b, c = list(map(int, input().split()))
data[(a, b)] = c
else:
print(f(0, {0:0}, [], 0)) | p00180 |
m=list(map(int, input().split()))
m.sort()
print(' '.join(map(str, m))) | a=list(map(int,input().split()));a.sort();print(a[0],a[1],a[2]) | p02393 |
#!/usr/bin/env python
# coding: utf-8
def main():
values = [int(x) for x in input().split(" ")]
if values[0] > values[1]:
values[0], values[1] = values[1], values[0]
if values[1] > values[2]:
values[1], values[2] = values[2], values[1]
if values[0] > values[1]:
values[0], values[1] = values[1], values[0]
print("%s %s %s" % tuple(values))
if __name__ == '__main__':
main() | if __name__ == '__main__':
a, b, c = list(map(int, input().split()))
if a < b:
if b < c:
print(a, b, c)
elif a < c:
print(a, c, b)
else:
print(c, a, b)
else:
if a < c:
print(b, a, c)
elif b < c:
print(b, c, a)
else:
print(c, b, a) | p02393 |
print((" ".join(map(str,sorted([int(i) for i in input().split(" ")]))))) | # encoding:utf-8
input = list(map(int, input().split()))
input.sort()
print((" ".join(map(str, input)))) | p02393 |
#coding:utf-8
import sys
abc=sys.stdin.readline()
nums=abc.split( ' ' )
for i in range( len( nums) ):
nums[i] = int( nums[i] )
nums.sort()
print(( "{} {} {}".format( nums[0], nums[1], nums[2] ) )) | import sys
nums = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
nums = sorted( nums )
print(( "{:d} {:d} {:d}".format( nums[0], nums[1], nums[2] ) )) | p02393 |
x=input().split()
y=list(map(int,x))
a=y[0]
b=y[1]
c=y[2]
d=sorted([a,b,c])
print(("{0} {1} {2}".format(d[0],d[1],d[2]))) | a,b,c=list(map(int,input().split()))
d=[a,b,c]
d.sort()
print(("{0} {1} {2}".format(d[0],d[1],d[2]))) | p02393 |
nums = input().split()
nums = list(map(int, nums))
nums.sort()
print((' '.join(list(map(str, nums))))) | a = sorted(list(map(int, input().split())))
print((' '.join(map(str, a))))
| p02393 |
xs=list(map(int,input().split()))
print((' '.join(map(str, sorted(xs))))) | input_list = list(map(int, input().split()))
print((' '.join(map(str, sorted(input_list)))))
| p02393 |
a,b,c=list(map(int,input().split()))
if(a>b):
tmp=a
a=b
b=tmp
if(b>c):
tmp=b
b=c
c=tmp
if(a>b):
tmp=a
a=b
b=tmp
print(a,b,c) | a,b,c=list(map(int,input().split()))
if(a>b):
tmp=a
a=b
b=tmp
if(b>c):
tmp=b
b=c
c=tmp
if(a>b):
tmp=b
b=a
a=tmp
print(str(a)+" "+str(b)+" "+str(c)) | p02393 |
a = list(map(int, input().split()))
for i in range(len(a)):
j = len(a) - 1
while i < j:
if a[j] < a[j-1]:
t = a[j]
a[j] = a[j-1]
a[j-1] = t
j -= 1
for i in range(len(a)):
if i == len(a) - 1:
print(a[i])
else:
print(a[i], end=" ")
| n = [int(i) for i in input().split()]
n = sorted(n)
for i in range(3):
if i == 2:
print(n[i])
else:
print(n[i], end = " ")
| p02393 |
s = input()
nlist = list(map(int, s.split()))
a, b, c= nlist
if a<b:
if b<c:
print('%d %d %d' %(a, b, c))
elif c<a:
print('%d %d %d' %(c, a, b))
else:
print('%d %d %d' %(a, c, b))
else:
if a<c:
print('%d %d %d' %(b, a, c))
elif c<b:
print('%d %d %d' %(c, b, a))
else:
print('%d %d %d' %(b, c, a)) | s = input()
nlist = list(map(int, s.split()))
a, b, c= nlist
#print nlist.sort()
ls = sorted(nlist)
print('%d %d %d' %(ls[0], ls[1], ls[2])) | p02393 |
from collections import deque
n= int(eval(input()))
tab = [[0 for _ in range(n)] for _ in range(n)]
branchdict = {}
for i in range(n-1):
a,b,c= list(map(int,input().split()))
tab[a-1][b-1] = c
tab[b-1][a-1] = c
branchdict[a-1] = branchdict.get(a-1,[]) + [b-1]
branchdict[b-1] = branchdict.get(b-1,[]) + [a-1]
q,k= list(map(int,input().split()))
start = k-1
que = deque()
que.append(start)
passed = set()
passed.add(start)
cost = [0] * n
while len(que)!=0:
node = que.pop()
for abr in branchdict[node]:
if not abr in passed:
cost[abr] = cost[node] + tab[node][abr]
passed.add(abr)
que.append(abr)
for i in range(q):
x,y= list(map(int,input().split()))
print((cost[x-1]+cost[y-1])) | import sys
sys.setrecursionlimit(1000000000)
input = sys.stdin.readline
n= int(eval(input()))
bd = [[] for _ in range(n)]
for i in range(n-1):
a,b,c= list(map(int,input().split()))
bd[a-1].append((b-1,c))
bd[b-1].append((a-1,c))
q,k= list(map(int,input().split()))
cost = [0] * n
def dfs(curnode,pre,addcost):
for abr in bd[curnode]:
if abr[0]!=pre:
cost[abr[0]]=addcost+abr[1]
dfs(abr[0],curnode,addcost+abr[1])
dfs(k-1,-1,0)
for i in range(q):
x,y= list(map(int,input().split()))
print((cost[x-1]+cost[y-1])) | p03634 |
N = int(eval(input()))
E = [set() for _ in range(N)]
C = [[0 for _ in range(N)] for _ in range(N)]
for i in range(N-1):
a,b,c = list(map(int,input().split()))
E[a-1].add(b-1)
E[b-1].add(a-1)
C[a-1][b-1] = c
C[b-1][a-1] = c
Q,K = list(map(int,input().split()))
K -= 1
Query = []
for i in range(Q):
x,y = list(map(int,input().split()))
Query.append([x-1,y-1])
#print(E)
#print(C)
#print(K)
#print(Query)
Kcost = [0 for _ in range(N)]
def dfs(u,v):
if v != -1:
Kcost[u] = Kcost[v] + C[u][v]
for t in E[u]:
if t != K and Kcost[t] == 0:
dfs(t,u)
dfs(K,-1)
for x,y in Query:
print((Kcost[x]+Kcost[y])) | import sys
sys.setrecursionlimit(10 ** 6)
N = int(eval(input()))
E = [set() for _ in range(N)]
C = {}
for i in range(N-1):
a,b,c = list(map(int,input().split()))
E[a-1].add(b-1)
E[b-1].add(a-1)
C[min(a-1,b-1)*N+max(a-1,b-1)] = c
Q,K = list(map(int,input().split()))
K -= 1
Query = []
for i in range(Q):
x,y = list(map(int,input().split()))
Query.append([x-1,y-1])
#print(E)
#print(C)
#print(K)
#print(Query)
Kcost = [0 for _ in range(N)]
def dfs(u,v):
if v != -1:
Kcost[u] = Kcost[v] + C[min(u,v)*N+max(u,v)]
for t in E[u]:
if t != K and Kcost[t] == 0:
dfs(t,u)
dfs(K,-1)
for x,y in Query:
print((Kcost[x]+Kcost[y])) | p03634 |
n=int(eval(input()))
INF=9999999999
d=[INF for _ in range(n)]
dist=[[INF for _ in range(n)] for _ in range(n)]
linked=[[] for _ in range(n)]
for i in range(n):
dist[i][i]=0
for i in range(n-1):
a,b,c=list(map(int,input().split()))
dist[a-1][b-1]=c
dist[b-1][a-1]=c
linked[a-1].append(b-1)
linked[b-1].append(a-1)
def dfs(v,p,dv):
d[v]=dv
for i in linked[v]:
linked[i].remove(v)
if(i==p):
continue
dfs(i,v,dv+dist[v][i])
q,k=list(map(int,input().split()))
dfs(k-1,-1,0)
for i in range(q):
x,y=list(map(int,input().split()))
print((d[x-1]+d[y-1]))
| import sys
sys.setrecursionlimit(10**6)
n=int(eval(input()))
INF=9999999999
d=[INF for _ in range(n)]
g=[[] for _ in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
g[a-1].append([b-1,c])
g[b-1].append([a-1,c])
def dfs(v,p,dv):
d[v]=dv
for gi,c in g[v]:
if(gi==p):
continue
dfs(gi,v,dv+c)
q,k=list(map(int,input().split()))
dfs(k-1,-1,0)
for i in range(q):
x,y=list(map(int,input().split()))
print((d[x-1]+d[y-1]))
| p03634 |
import sys
from collections import Counter
from collections import deque
def input(): return sys.stdin.readline().strip()
def mp(): return list(map(int,input().split()))
def lmp(): return list(map(int,input().split()))
n=int(eval(input()))
tree=[[] for i in range(n+1)]
for i in range(n-1):
a,b,c=mp()
tree[a].append((b,c))
tree[b].append((a,c))
q,k=mp()
dist=[-1]*(n+1)
dist[k]=0
deq=deque()
deq.append(k)
while len(list(deq))>0:
p=deq.popleft()
for x,y in tree[p]:
if dist[x]==-1:
dist[x]=dist[p]+y
deq.append(x)
for i in range(q):
xi,yi=mp()
print((dist[xi]+dist[yi])) | import sys
from collections import Counter
from collections import deque
def input(): return sys.stdin.readline().strip()
def mp(): return list(map(int,input().split()))
def lmp(): return list(map(int,input().split()))
n=int(eval(input()))
tree=[[] for i in range(n+1)]
for i in range(n-1):
a,b,c=mp()
tree[a].append((b,c))
tree[b].append((a,c))
q,k=mp()
dist=[-1]*(n+1)
dist[k]=0
deq=deque()
deq.append(k)
while len(deq):
p=deq.popleft()
for x,y in tree[p]:
if dist[x]==-1:
dist[x]=dist[p]+y
deq.append(x)
for i in range(q):
xi,yi=mp()
print((dist[xi]+dist[yi])) | p03634 |
import sys
sys.setrecursionlimit(10**8)
N = int(eval(input()))
a = [[] for i in range(N)]
for i in range(N-1):
A, B, C = list(map(int, input().split()))
a[A-1].append([B-1, C])
a[B-1].append([A-1, C])
dist = [-1]*N
Q, K = list(map(int, input().split()))
dist[K-1] = 0
def dfs(now):
for i, dis_e in a[now]:
if dist[i] == -1:
dist[i] = dist[now] + dis_e
dfs(i)
def main():
dfs(K-1)
ans = []
for i in range(Q):
x, y = list(map(int, input().split()))
print((dist[x-1]+dist[y-1]))
#print(*ans, sep = "\n")
if __name__ == "__main__":
main() | import sys
sys.setrecursionlimit(10**8)
N = int(input())
a = [[] for i in range(N)]
for i in range(N-1):
A, B, C = map(int, input().split())
a[A-1].append([B-1, C])
a[B-1].append([A-1, C])
dist = [-1]*N
Q, K = map(int, input().split())
dist[K-1] = 0
def dfs(now):
for i, dis_e in a[now]:
if dist[i] == -1:
dist[i] = dist[now] + dis_e
dfs(i)
def main():
dfs(K-1)
ans = []
for i in range(Q):
x, y = map(int, input().split())
ans.append(dist[x-1]+dist[y-1])
print(*ans, sep = "\n")
if __name__ == "__main__":
main()
| p03634 |
N = int(eval(input()))
INF = float("inf")
es = [[INF for _ in range(N)] for _ in range(N)]
for i in range(N-1):
a,b,c = list(map(int, input().split()))
a,b = a-1, b-1
es[a][b] = c
es[b][a] = c
Q, K = list(map(int, input().split()))
xy = []
for i in range(Q):
x,y = list(map(int, input().split()))
xy.append([x-1, y-1])
checked = [False] * N
d = [INF] * N
d[K-1] = 0
def dijkstra(s):
while True:
v = -1
for i in range(N):
if checked[i] == False and v == -1:
v = i
elif checked[i] == False and d[i] < d[v]:
v = i
if v == -1:
break
checked[v] = True
for i in range(N):
d[i] = min(d[i], d[v] + es[v][i])
return
dijkstra(K-1)
for x,y in xy:
print((d[x] + d[y]))
| N = int(eval(input()))
INF = float("inf")
es = [[] for _ in range(N)]
for i in range(N-1):
a,b,c = list(map(int, input().split()))
a,b = a-1, b-1
es[a].append((b,c))
es[b].append((a,c))
Q, K = list(map(int, input().split()))
xy = []
for i in range(Q):
x,y = list(map(int, input().split()))
xy.append([x-1, y-1])
checked = [False] * N
d = [INF] * N
d[K-1] = 0
next_check = []
next_check.append(K-1)
while len(next_check):
now = next_check.pop()
for next,cost in es[now]:
if not checked[next]:
d[next] = min(d[next], d[now] + cost)
checked[next] = True
next_check.append(next)
for x,y in xy:
print((d[x] + d[y]))
| p03634 |
n = int(eval(input()))
path = [[0 for i in range(n)] for j in range(n)]
for i in range(n-1):
a, b, c = list(map(int, input().split()))
path[min(a-1, b-1)][max(a-1, b-1)] = c
q, k = list(map(int, input().split()))
distance = [None] * n
distance[k-1] = 0
queue = [k-1]
while(len(queue)):
p = queue.pop()
for i in range(n):
if(path[min(i,p)][max(i,p)]!=0 and distance[i] == None):
distance[i] = distance[p] + path[min(i,p)][max(i,p)]
queue.append(i)
for i in range(q):
x, y = list(map(int, input().split()))
print((distance[x-1]+distance[y-1]))
| n = int(eval(input()))
path = [[] for i in range(n)]
for i in range(n-1):
a, b, c = list(map(int, input().split()))
path[a-1].append((b-1, c))
path[b-1].append((a-1, c))
q, k = list(map(int, input().split()))
distance = [None] * n
distance[k-1] = 0
queue = [k-1]
while(len(queue)):
p = queue.pop()
for i,c in path[p]:
if(distance[i] == None):
distance[i] = distance[p] + c
queue.append(i)
for i in range(q):
x, y = list(map(int, input().split()))
print((distance[x-1]+distance[y-1]))
| p03634 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N = int(eval(input()))
query = [[0]*N for _ in range(N)]
for _ in range(N-1):
a, b, c = mapint()
query[a-1][b-1] = c
query[b-1][a-1] = c
Q, K = mapint()
from collections import deque
stack = deque([(K-1, 0, -1)])
dist = [0]*N
while stack:
now, cnt, per = stack.pop()
lis = query[now]
dist[now] = cnt
for nx, c in enumerate(lis):
if nx==per:
continue
if c!=0:
stack.append((nx, cnt+c, now))
for _ in range(Q):
x, y = mapint()
print((dist[x-1]+dist[y-1])) | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N = int(eval(input()))
query = [[] for _ in range(N)]
for _ in range(N-1):
a, b, c = mapint()
query[a-1].append((b-1, c))
query[b-1].append((a-1, c))
Q, K = mapint()
from collections import deque
stack = deque([(K-1, 0, -1)])
dist = [0]*N
while stack:
now, cnt, per = stack.pop()
lis = query[now]
dist[now] = cnt
for nx, c in lis:
if nx==per:
continue
if c!=0:
stack.append((nx, cnt+c, now))
for _ in range(Q):
x, y = mapint()
print((dist[x-1]+dist[y-1])) | p03634 |
import sys
TO_K = []
TREE = []
DISTANCE = []
def dfs(child, parent):
TO_K[child] = TO_K[parent] + DISTANCE[parent][child]
for i_gch in TREE[child]:
if i_gch == parent:
continue
dfs(i_gch, child)
return
def main():
n = int(eval(input()))
abc = [[int(_) for _ in input().split()] for i in range(n-1)]
q, k = list(map(int, input().split()))
xy = [[int(_) for _ in input().split()] for i in range(q)]
global TO_K
# index '0' is not used.
TO_K = [0]*(n+1)
global TREE
global DISTANCE
# index '0' is not used.
TREE = [[] for _ in range(n+1)]
DISTANCE = [[0]*(n+1) for _ in range(n+1)]
for a, b, c in abc:
TREE[a].append(b)
TREE[b].append(a)
DISTANCE[a][b] = c
DISTANCE[b][a] = c
dfs(k, 0)
for x, y in xy:
print((TO_K[x]+TO_K[y]))
return
if __name__ == "__main__":
main()
sys.exit(0) | import sys
sys.setrecursionlimit(10**9)
TO_K = []
TREE = []
DISTANCE = []
def dfs(child, parent):
for i_node in TREE[parent]:
if i_node[0] == child:
TO_K[child] = TO_K[parent] + i_node[1]
for i_gch in TREE[child]:
if i_gch[0] == parent:
TO_K[child] = TO_K[parent] + i_gch[1]
else:
dfs(i_gch[0], child)
return
def main():
n = int(eval(input()))
abc = [[int(_) for _ in input().split()] for i in range(n-1)]
q, k = list(map(int, input().split()))
xy = [[int(_) for _ in input().split()] for i in range(q)]
global TO_K
# index '0' is not used.
TO_K = [0]*(n+1)
global TREE
# index '0' is not used.
TREE = [[] for _ in range(n+1)]
for a, b, c in abc:
TREE[a].append([b, c])
TREE[b].append([a, c])
dfs(k, 0)
for x, y in xy:
print((TO_K[x]+TO_K[y]))
return
if __name__ == "__main__":
main()
sys.exit(0) | p03634 |
import sys
from collections import defaultdict
sys.setrecursionlimit(1000000)
N = int(eval(input()))
edges = [list(map(int, input().split())) for _ in range(N - 1)]
Q, K = list(map(int, input().split()))
graph = defaultdict(set)
for v, w, c in edges:
graph[v].add((w, c))
graph[w].add((v, c))
INF = 10 ** 9 + 7
dp = [INF] * (N + 1)
visited = [False] * (N + 1)
def dfs(v, p, d):
dp[v] = d
visited[v] = True
for j, c in graph[v]:
if j == p or visited[j]:
continue
dfs(j, v, d + c)
dfs(K, 0, 0)
for _ in range(Q):
x, y = list(map(int, input().split()))
print((dp[x] + dp[y]))
| from collections import defaultdict
from heapq import heappop, heappush
N = int(eval(input()))
edges = [list(map(int, input().split())) for _ in range(N - 1)]
Q, K = list(map(int, input().split()))
graph = defaultdict(set)
for v, w, c in edges:
graph[v].add((w, c))
graph[w].add((v, c))
dp = [-1] * (N + 1)
pq = []
# Initialization
dp[K] = 0
heappush(pq, (0, K))
while pq:
cost, u = heappop(pq)
for w, c in graph[u]:
if dp[w] > -1:
continue
dp[w] = dp[u] + c
heappush(pq, (dp[w], w))
for _ in range(Q):
x, y = list(map(int, input().split()))
print((dp[x] + dp[y]))
| p03634 |
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
N = int(eval(input()))
graph = [[mod for i in range(N)] for i in range(N)]
weights = {}
roots = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = LI()
a -= 1
b -= 1
roots[a].append(b)
roots[b].append(a)
weights[(a,b)] = c
weights[(b,a)] = c
Q, K = LI()
K -= 1
xy = [0 for i in range(Q)]
for i in range(Q):
x, y = LI()
x -= 1
y -= 1
xy[i] = [x, y]
"""
xyzで全部の通りを見つけるとN ** 3で無理
なので今回は木構造に注目してBFS or DFSで解いたらいいのでは？
"""
visited = [-1 for i in range(N)]
queue = collections.deque()
queue.append(K)
visited[K] = 0
while len(queue)> 0:
node = queue.popleft()
cnt = visited[node]
for n_node in roots[node]:
if visited[n_node] == -1:
visited[n_node] = cnt + weights[(node, n_node)]
queue.append(n_node)
for x, y in xy:
print((visited[x] + visited[y]))
| #!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
N = int(eval(input()))
weights = {}
roots = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = LI()
a -= 1
b -= 1
roots[a].append(b)
roots[b].append(a)
weights[(a,b)] = c
weights[(b,a)] = c
Q, K = LI()
K -= 1
xy = [0 for i in range(Q)]
for i in range(Q):
x, y = LI()
x -= 1
y -= 1
xy[i] = [x, y]
"""
xyzで全部の通りを見つけるとN ** 3で無理
なので今回は木構造に注目してBFS or DFSで解いたらいいのでは？
重みを単純にグラフに持つと10**5 ** 2になってしまうので注意
"""
visited = [-1 for i in range(N)]
queue = collections.deque()
queue.append(K)
visited[K] = 0
while len(queue)> 0:
node = queue.popleft()
cnt = visited[node]
for n_node in roots[node]:
if visited[n_node] == -1:
visited[n_node] = cnt + weights[(node, n_node)]
queue.append(n_node)
for x, y in xy:
print((visited[x] + visited[y]))
| p03634 |
from heapq import heappush,heappop
N = int(eval(input()))
table=[[]for i in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
table[a-1].append([b-1,c])
table[b-1].append([a-1,c])
Q,K=list(map(int,input().split()))
Que=[[int(i) for i in input().split()] for i in range(Q)]
inf=10**17
dis=[inf]*N
dis[K-1]=0
kei=[]
heappush(kei,[0,K-1])
while kei:
q,x=heappop(kei)
if dis[x]<q:
continue
for i,d in table[x]:
if dis[x]+d<dis[i]:
dis[i]=dis[x]+d
heappush(kei,[dis[i],i])
ans =[]
for x,y in Que:
ans.append(dis[x-1]+dis[y-1])
print(('\n'.join(map(str,ans)))) | import sys
input = sys.stdin.readline
from heapq import heappop,heappush
N=int(eval(input()))
table=[[] for i in range(N)]
for i in range(N-1):
a,b,c=list(map(int,input().split()))
a,b=a-1,b-1
table[a].append((b,c))
table[b].append((a,c))
Q,K=list(map(int,input().split()))
query=[[int(i)-1 for i in input().split()] for i in range(Q)]
K=K-1
H=[]
visit=[10**18]*(N)
visit[K]=0
heappush(H,(0,K))
while H:
co,pt=heappop(H)
if co>visit[pt]:
continue
for x,c in table[pt]:
if visit[x]>visit[pt]+c:
visit[x]=visit[pt]+c
heappush(H,(visit[x],x))
for a,b in query:
print((visit[a]+visit[b])) | p03634 |
import heapq
N = int(eval(input()))
G = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
a, b = a - 1, b - 1
G[a].append([b, c])
G[b].append([a, c])
Q, K = list(map(int, input().split()))
K -= 1
def dijkstra(x):
d = [float('inf')] * N
d[x] = 0
visited = {x}
# d, u
hq = [(0, x)]
while hq:
u = heapq.heappop(hq)[1]
visited.add(u)
for node, cost in G[u]:
if (node not in visited) and d[node] > d[u] + cost:
d[node] = d[u] + cost
heapq.heappush(hq, (d[u]+cost, node))
return d
dist = dijkstra(K)
for q in range(Q):
x, y = list(map(int, input().split()))
x, y = x - 1, y - 1
print((dist[x] + dist[y]))
| import sys
sys.setrecursionlimit(10 ** 9)
N = int(eval(input()))
G = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = list(map(int, input().split()))
a, b = a - 1, b - 1
G[a].append([b, c])
G[b].append([a, c])
Q, K = list(map(int, input().split()))
K -= 1
dist = [-1] * N
dist[K] = 0
def dfs(n):
for v, c in G[n]:
if dist[v] < 0:
dist[v] = dist[n] + c
dfs(v)
dfs(K)
for q in range(Q):
x, y = list(map(int, input().split()))
x, y = x - 1, y - 1
print((dist[x] + dist[y]))
| p03634 |
import sys
input=sys.stdin.readline
# 頂点 s からの最短距離を求める (存在しないときはinf)
# n: 頂点数, edge[i]: 頂点 i からの [cost, dst] の list (heapq のため cost が先)
# O(|E|log|V|)
import heapq
def dijkstra(s,n,edge):
d = [float("inf")] * n # s からの距離
d[s] = 0
q = [] # 頂点への距離を管理する。ヒープにする
for e in edge[s]:
heapq.heappush(q, e)
while q:
minedge = heapq.heappop(q)
v = minedge[1]
if d[v] < minedge[0]:
continue # 最小のもの以降はスルー
d[v] = minedge[0]
for e in edge[v]:
heapq.heappush(q, [e[0]+d[v], e[1]])
return d
def main():
N = int(eval(input()))
edge = [[] for i in range(N)]
# edge[i] : 頂点 i から出る経路の [重み,行先] の配列
for _ in range(N-1):
a,b,c = list(map(int, input().split()))
edge[a-1].append([c,b-1])
edge[b-1].append([c,a-1])
Q,K = list(map(int, input().split()))
D = dijkstra(K-1, N, edge)
for _ in range(Q):
x,y = list(map(int, input().split()))
print((D[x-1] + D[y-1]))
if __name__ == '__main__':
main()
| import sys
input=sys.stdin.readline
sys.setrecursionlimit(3*10**5) # 大丈夫か？
N = int(eval(input()))
edge = [[] for i in range(N)]
# edge[i] : 頂点 i から出る経路の [距離,行先] の隣接リスト
for _ in range(N-1):
a,b,c = list(map(int, input().split()))
edge[a-1].append([c,b-1])
edge[b-1].append([c,a-1])
D = [-1]*N # K からの距離. 未訪問の場合 -1.
# 今回の問題の場合、木なので経路は 1 通りしか無く、
# K から頂点を順に辿りながらコストを足していくだけで良い
def dfs(src, cost):
D[src] = cost
for e in edge[src]:
if D[e[1]] == -1:
dfs(e[1], cost + e[0])
def main():
Q,K = list(map(int, input().split()))
dfs(K-1, 0)
for _ in range(Q):
x,y = list(map(int, input().split()))
print((D[x-1] + D[y-1]))
if __name__ == '__main__':
main()
| p03634 |
import sys
def I(): return int(sys.stdin.readline().rstrip())
def S(): return sys.stdin.readline().rstrip()
N = I()
G = {}
for i in range(1,N+1):
G[i] = []
for i in range(N-1):
a,b,c = list(map(int,S().split()))
G[a].append((b,c))
G[b].append((a,c))
Q,K = list(map(int,S().split()))
from collections import deque
distance = [-1]*(N+1) # arrive[i] = 頂点Kからの最短距離
distance[K] = 0
q = deque([K])
while q:
a = q.pop()
for b,c in G[a]:
if distance[b] != -1:
continue
distance[b] = distance[a] + c
q.appendleft(b)
for i in range(Q):
x,y = list(map(int,S().split()))
print((distance[x] + distance[y])) | import sys
def I(): return int(sys.stdin.readline().rstrip())
def S(): return sys.stdin.readline().rstrip()
N = I()
G = [[] for i in range(N+1)]
for i in range(N-1):
a,b,c = list(map(int,S().split()))
G[a].append((b,c))
G[b].append((a,c))
Q,K = list(map(int,S().split()))
from collections import deque
distance = [-1]*(N+1) # arrive[i] = 頂点Kからの最短距離
distance[K] = 0
q = deque([K])
while q:
a = q.pop()
for b,c in G[a]:
if distance[b] != -1:
continue
distance[b] = distance[a] + c
q.appendleft(b)
for i in range(Q):
x,y = list(map(int,S().split()))
print((distance[x] + distance[y])) | p03634 |
import sys
def I(): return int(sys.stdin.readline().rstrip())
def S(): return sys.stdin.readline().rstrip()
N = I()
G = [[] for i in range(N+1)]
for i in range(N-1):
a,b,c = list(map(int,S().split()))
G[a].append((b,c))
G[b].append((a,c))
Q,K = list(map(int,S().split()))
from collections import deque
distance = [-1]*(N+1) # arrive[i] = 頂点Kからの最短距離
distance[K] = 0
q = deque([K])
while q:
a = q.pop()
for b,c in G[a]:
if distance[b] != -1:
continue
distance[b] = distance[a] + c
q.appendleft(b)
for i in range(Q):
x,y = list(map(int,S().split()))
print((distance[x] + distance[y])) | def main():
import sys
def I():
return int(sys.stdin.readline().rstrip())
def S():
return sys.stdin.readline().rstrip()
N = I()
G = [[] for i in range(N + 1)]
for i in range(N - 1):
a, b, c = list(map(int, S().split()))
G[a].append((b, c))
G[b].append((a, c))
Q, K = list(map(int, S().split()))
from collections import deque
distance = [-1] * (N + 1) # arrive[i] = 頂点Kからの最短距離
distance[K] = 0
q = deque([K])
while q:
a = q.pop()
for b, c in G[a]:
if distance[b] != -1:
continue
distance[b] = distance[a] + c
q.appendleft(b)
for i in range(Q):
x, y = list(map(int, S().split()))
print((distance[x] + distance[y]))
if __name__ == '__main__':
main() | p03634 |
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
n = ni()
g = []
for i in range(n+1): g.append([])
for i in range(n-1):
a, b, c = na()
g[a].append((b,c))
g[b].append((a,c))
q,k = na()
def dfs(cur, pre, g, par, dw, w):
dw[cur] = w
par[cur] = pre
for e in g[cur]:
if e[0] != pre:
dfs(e[0], cur, g, par, dw, w + e[1])
par = [-1] * (n+2)
dw = [-1] * (n+2)
from queue import Queue
qs = Queue()
qs.put(k)
dw[k] = 0
while not qs.empty():
cur = qs.get()
for e in g[cur]:
if e[0] != par[cur]:
par[e[0]] = cur
dw[e[0]] = dw[cur] + e[1]
qs.put(e[0])
# dfs(k, -1, g, par, dw, 0)
for z in range(q):
x, y = na()
print((dw[x] + dw[y]))
| import sys
sys.setrecursionlimit(1000001)
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
n = ni()
g = []
for i in range(n+1): g.append([])
for i in range(n-1):
a, b, c = na()
g[a].append((b,c))
g[b].append((a,c))
q,k = na()
def dfs(cur, pre, g, par, dw, w):
dw[cur] = w
par[cur] = pre
for e in g[cur]:
if e[0] != pre:
dfs(e[0], cur, g, par, dw, w + e[1])
par = [-1] * (n+2)
dw = [-1] * (n+2)
dfs(k, -1, g, par, dw, 0)
for z in range(q):
x, y = na()
print((dw[x] + dw[y]))
| p03634 |
from collections import deque
n=int(eval(input()))
l=[0]*n
d={}
for i in range(n-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
if a in d:
d[a].add((b,c))
else:
d[a]={(b,c)}
if b in d:
d[b].add((a,c))
else:
d[b]={(a,c)}
q,k=list(map(int,input().split()))
k-=1
p=deque([k])
while len(p):
w=p.popleft()
for i in d[w]:
if (l[i[0]]==0 and i[0]!=k) or (l[i[0]]!=0 and l[i[0]]>l[w]+i[1]):
l[i[0]]=l[w]+i[1]
p.append(i[0])
for i in range(q):
x,y=list(map(int,input().split()))
print((l[x-1]+l[y-1]))
| from collections import deque
def main():
n=int(eval(input()))
l=[0]*n
d={}
for i in range(n-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
if a in d:
d[a].add((b,c))
else:
d[a]={(b,c)}
if b in d:
d[b].add((a,c))
else:
d[b]={(a,c)}
q,k=list(map(int,input().split()))
k-=1
p=deque([k])
while len(p):
w=p.popleft()
for i in d[w]:
if (l[i[0]]==0 and i[0]!=k) or (l[i[0]]!=0 and l[i[0]]>l[w]+i[1]):
l[i[0]]=l[w]+i[1]
p.append(i[0])
for i in range(q):
x,y=list(map(int,input().split()))
print((l[x-1]+l[y-1]))
if __name__ == '__main__':
main() | p03634 |
def main():
from collections import defaultdict
import sys
sys.setrecursionlimit(1000000)
n, *rem = list(map(int, open(0).read().split()))
t = 3 * (n - 1)
abc = rem[:t]
q, k = rem[t], rem[t + 1]
xy = rem[t + 2:]
m = [[] for _ in range(n + 1)]
dist = defaultdict(dict)
for a, b, c in zip(*[iter(abc)] * 3):
m[a].append(b)
m[b].append(a)
dist[a].update({b: c})
dist[b].update({a: c})
vis = [False] * (n + 1)
cost = [0] * (n + 1)
vis[k] = True
def dfs(frm, to):
if vis[to]:
return
vis[to] = True
cost[to] = cost[frm] + dist[frm][to]
frm = to
for to in m[frm]:
dfs(frm, to)
frm = k
for to in m[frm]:
dfs(frm, to)
tmp = []
for x, y in zip(*[iter(xy)] * 2):
tmp.append(cost[x] + cost[y])
ans = "\n".join(map(str, tmp))
print(ans)
if __name__ == '__main__':
main()
| def main():
from collections import defaultdict
import sys
sys.setrecursionlimit(1000000)
n, *rem = list(map(int, open(0).read().split()))
t = 3 * (n - 1)
abc = rem[:t]
q, k = rem[t], rem[t + 1]
xy = rem[t + 2:]
dist = defaultdict(dict)
for a, b, c in zip(*[iter(abc)] * 3):
dist[a].update({b: c})
dist[b].update({a: c})
vis = [False] * (n + 1)
cost = [0] * (n + 1)
vis[k] = True
def dfs(a, b):
if vis[b]:
return
vis[b] = True
cost[b] = cost[a] + dist[a][b]
a = b
for b in list(dist[a].keys()):
dfs(a, b)
for b in list(dist[k].keys()):
dfs(k, b)
tmp = []
for x, y in zip(*[iter(xy)] * 2):
tmp.append(cost[x] + cost[y])
ans = "\n".join(map(str, tmp))
print(ans)
if __name__ == '__main__':
main()
| p03634 |
# !入力
# グラフの構築
# クエリの入力
# Kからの各点のの距離をdfs
# クエリの処理
from collections import deque
n=int(eval(input()))
edge=[[]for _ in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
edge[a-1].append((b-1,c))
edge[b-1].append((a-1,c))
q,k=list(map(int,input().split()))
dist=[0]*n
seen=[False]*n
todo=deque([k-1])
while todo:
par=todo.pop()
seen[par]=True
for cld,cost in edge[par]:
if dist[cld]==0:
if seen[cld]==False:
dist[cld]=dist[par]+cost
seen[cld]=True
todo.append(cld)
for i in range(q):
x,y=list(map(int,input().split()))
print((dist[x-1]+dist[y-1]))
| # !入力
# グラフの構築
# クエリの入力
# Kからの各点のの距離をdfs
# クエリの処理
from collections import deque
n=int(eval(input()))
edge=[[]for _ in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
edge[a-1].append((b-1,c))
edge[b-1].append((a-1,c))
q,k=list(map(int,input().split()))
dist=[0]*n
seen=[False]*n
todo=deque([k-1])
while todo:
par=todo.popleft()
seen[par]=True
for cld,cost in edge[par]:
if dist[cld]==0:
if seen[cld]==False:
dist[cld]=dist[par]+cost
seen[cld]=True
todo.append(cld)
for i in range(q):
x,y=list(map(int,input().split()))
print((dist[x-1]+dist[y-1]))
| p03634 |
import sys
from collections import defaultdict, deque
import bisect
from heapq import *
from math import factorial
sys.setrecursionlimit(200000)
input = sys.stdin.readline
N, = list(map(int, input().split()))
# N = int(input())
# L = [int(v) for v in input().split()]
# L = [[int(v) for v in input().split()] for _ in range(N)]
# L = [int(input()) for _ in range(N)]
# L = [list(input().strip()) for _ in range(N)]
# S = input().strip()
L = [[int(v) for v in input().split()] for _ in range(N - 1)]
Q, K = list(map(int, input().split()))
QL = [[int(v) for v in input().split()] for _ in range(Q)]
m = {}
for a, b, c in L:
if m.get(a) == None:
m[a] = {}
if m.get(b) == None:
m[b] = {}
m[a][b] = c
m[b][a] = c
def dfs(now, a, l, al):
ans = 10 ** 18
if now == a:
return l
for k, v in list(m[now].items()):
if k in al:
continue
re = dfs(k, a, l + v, al + [k])
ans = min(ans, re)
return ans
for i in range(N):
a = dfs(K, i + 1, 0, [])
m[K][i + 1] = a
for x, y in QL:
print((m[K][x] + m[K][y])) | import sys
from collections import defaultdict, deque
import bisect
from heapq import *
from math import factorial
sys.setrecursionlimit(200000)
input = sys.stdin.readline
N, = list(map(int, input().split()))
# N = int(input())
# L = [int(v) for v in input().split()]
# L = [[int(v) for v in input().split()] for _ in range(N)]
# L = [int(input()) for _ in range(N)]
# L = [list(input().strip()) for _ in range(N)]
# S = input().strip()
L = [[int(v) for v in input().split()] for _ in range(N - 1)]
Q, K = list(map(int, input().split()))
QL = [[int(v) for v in input().split()] for _ in range(Q)]
m = {}
l = [set() for _ in range(N)]
for a, b, c in L:
a -= 1
b -= 1
if m.get(a) == None:
m[a] = {}
if m.get(b) == None:
m[b] = {}
m[a][b] = c
m[b][a] = c
l[a].add(b)
l[b].add(a)
ans = [None] * N
ans[K - 1] = 0
def dfs(now, a):
for v in l[now]:
p = a + m[now][v]
if ans[v] == None:
ans[v] = p
dfs(v, ans[v])
elif ans[v] > p:
ans[v] = p
dfs(v, ans[v])
dfs(K - 1, 0)
for x, y in QL:
print((ans[x - 1] + ans[y - 1])) | p03634 |
from collections import defaultdict
from heapq import heappop, heappush
class Graph:
def __init__(self):
self.graph = defaultdict(list)
self.vertices = set()
self.edges = []
def add_edge(self, a, b, weight=1):
self.graph[a].append((b, weight))
self.vertices |= {a, b}
self.edges.append((a, b, weight))
self.graph[b].append((a, weight))
self.edges.append((b, a, weight))
def get_vertices(self):
return sorted(list(self.vertices))
def num_of_vertices(self):
return len(self.vertices)
def get_edges(self):
return self.edges
def num_of_edges(self):
return len(self.edges)
class Dijkstra:
def __init__(self, graph, start):
self.g = graph.graph
self.dist = defaultdict(lambda: float("inf"))
self.dist[start] = 0
self.prev = defaultdict(lambda: None)
self.Q = []
heappush(self.Q, (0, start))
while self.Q:
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, weight in self.g[u]:
alt = dist_u + weight
if self.dist[v] > alt:
self.dist[v] = alt
self.prev[v] = u
heappush(self.Q, (alt, v))
def shortest_distance(self, goal):
return self.dist[goal]
def shortest_path(self, goal):
path = []
vertice = goal
while vertice is not None:
path.append(vertice)
vertice = self.prev[vertice]
return path[::-1]
G = Graph()
N = int(eval(input()))
for i in range(N-1):
a, b, c = list(map(int, input().split()))
G.add_edge(a, b, c)
Q, K = list(map(int, input().split()))
for _ in range(Q):
x, y = list(map(int, input().split()))
D1 = Dijkstra(G, x)
D2 = Dijkstra(G, K)
print((D1.shortest_distance(K)+D2.shortest_distance(y)))
| from collections import deque
N = int(eval(input()))
D = [[] for _ in range(N)]
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
a, b = a-1, b-1
D[a].append((b, c))
D[b].append((a, c))
cnt, K = list(map(int, input().split()))
K -= 1
Q = deque([(K, 0)])
Dist = [0]*N
check = [0]*N
while Q:
n, d = Q.popleft()
check[n] = 1
Dist[n] = d
for v, e in D[n]:
if check[v]:
continue
else:
Q.append((v, d+e))
for _ in range(cnt):
x, y = list(map(int, input().split()))
x, y = x-1, y-1
print((Dist[x]+Dist[y])) | p03634 |
def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
from collections import defaultdict, deque, Counter
from sys import exit
import heapq
import math
import copy
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
N = getN()
dist = [[] for i in range(N + 1)]
for i in range(N - 1):
a, b, c = getNM()
dist[a].append([b, c])
dist[b].append([a, c])
d = [[float('inf')] * (N + 1) for i in range(N + 1)]
ignore = [-1] * (N + 1)
# Kからの最短距離をbfsで測る
def distance(sta):
# 木をKから順にたどる（戻るの禁止）
pos = deque([sta])
while len(pos) > 0:
u = pos.popleft()
for i in dist[u]:
if ignore[i[0]] == -1:
ignore[i[0]] = ignore[u] + i[1]
pos.append(i[0])
Q, K = getNM()
ignore[K] = 0
distance(K)
# 答えはK~xまでの距離+K~yまでの距離
ans = []
for i in range(Q):
x, y = getNM()
ans.append(ignore[x] + ignore[y])
for i in ans:
print(i) | def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
from collections import defaultdict, deque, Counter
from sys import exit
import heapq
import math
import copy
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
N = getN()
dist = [[] for i in range(N + 1)]
for i in range(N - 1):
a, b, c = getNM()
dist[a].append([b, c])
dist[b].append([a, c])
ignore = [-1] * (N + 1)
# Kからの最短距離をbfsで測る
def distance(sta):
# 木をKから順にたどる（戻るの禁止）
pos = deque([sta])
while len(pos) > 0:
u = pos.popleft()
for i in dist[u]:
if ignore[i[0]] == -1:
ignore[i[0]] = ignore[u] + i[1]
pos.append(i[0])
Q, K = getNM()
ignore[K] = 0
distance(K)
# 答えはK~xまでの距離+K~yまでの距離
ans = []
for i in range(Q):
x, y = getNM()
ans.append(ignore[x] + ignore[y])
for i in ans:
print(i) | p03634 |
from queue import Queue
INF=float('inf')
n=int(eval(input()))
g=[[] for _ in range(n)]
for _ in range(n-1):
u,v,w=list(map(int,input().split()))
g[u-1].append((v-1,w))
g[v-1].append((u-1,w))
q,k=list(map(int,input().split()))
ds=[INF]*n
que=Queue()
que.put((k-1,0))
while not que.empty():
u,d=que.get()
if ds[u] != INF:
continue
ds[u]=d
for v,w in g[u]:
que.put((v,d+w))
for _ in range(q):
u,v=list(map(int,input().split()))
print((ds[u-1]+ds[v-1]))
| from queue import Queue
INF=float('inf')
n=int(eval(input()))
g=[[] for _ in range(n)]
for _ in range(n-1):
u,v,w=list(map(int,input().split()))
g[u-1].append((v-1,w))
g[v-1].append((u-1,w))
q,k=list(map(int,input().split()))
ds=[INF]*n
ds[k-1]=0
que=Queue()
que.put((k-1,0))
while not que.empty():
u,d=que.get()
for v,w in g[u]:
if ds[v]==INF:
ds[v]=d+w
que.put((v,d+w))
for _ in range(q):
u,v=list(map(int,input().split()))
print((ds[u-1]+ds[v-1]))
| p03634 |
from queue import Queue
INF=float('inf')
n=int(eval(input()))
g=[[] for _ in range(n)]
for _ in range(n-1):
u,v,w=list(map(int,input().split()))
g[u-1].append((v-1,w))
g[v-1].append((u-1,w))
q,k=list(map(int,input().split()))
ds=[INF]*n
ds[k-1]=0
que=Queue()
que.put((k-1,0))
while not que.empty():
u,d=que.get()
for v,w in g[u]:
if ds[v]==INF:
ds[v]=d+w
que.put((v,d+w))
for _ in range(q):
u,v=list(map(int,input().split()))
print((ds[u-1]+ds[v-1]))
| from collections import deque
INF=float('inf')
n=int(eval(input()))
g=[[] for _ in range(n)]
for _ in range(n-1):
u,v,w=list(map(int,input().split()))
g[u-1].append((v-1,w))
g[v-1].append((u-1,w))
q,k=list(map(int,input().split()))
ds=[INF]*n
ds[k-1]=0
que=deque()
que.append((k-1,0))
while len(que):
u,d=que.popleft()
for v,w in g[u]:
if ds[v]==INF:
ds[v]=d+w
que.append((v,d+w))
for _ in range(q):
u,v=list(map(int,input().split()))
print((ds[u-1]+ds[v-1]))
| p03634 |
import sys;sys.setrecursionlimit(int(1e7))
class edge():
def __init__(self,_to,_cost):
self.to = _to;
self.cost = _cost;
N = int(eval(input()))
tree = [[] for i in range(N+1)]
for i in range(N-1):
a,b,c = list(map(int,input().split()))
a = a - 1
b = b - 1
tree[a].append(edge(b,c))
tree[b].append(edge(a,c))
Q,K = list(map(int,input().split()))
K = K - 1
depth = [None]*N
def DFS(v,p,d):
depth[v] = d
for e in tree[v]:
if e.to == p:
continue
DFS(e.to, v, d + e.cost)
DFS(K,-1,0)
for _ in range(Q):
x,y = list(map(int, input().split()))
x = x - 1
y = y - 1
print((depth[x] + depth[y]))
| import sys;sys.setrecursionlimit(int(1e7))
N = int(eval(input()))
tree = [[] for _ in range(N+1)]
depth = [None]*(N+1)
ABC = [ tuple(map(int,input().split())) for _ in range(N-1)]
Q,K = list(map(int,input().split()))
XY = [tuple(map(int,input().split())) for _ in range(Q)]
for abc in ABC:
tree[abc[0]].append((abc[1],abc[2]))
tree[abc[1]].append((abc[0],abc[2]))
def DFS(v,p,d):
depth[v] = d
for e in tree[v]:
if e[0] != p:
DFS(e[0], v, d + e[1])
DFS(K,0,0)
for i in range(Q):
print((depth[XY[i][0]] + depth[XY[i][1]])) | p03634 |
import sys;sys.setrecursionlimit(int(1e7))
N = int(eval(input()))
ABC = [list(map(int,input().split())) for _ in range(N-1)]
Q,K = list(map(int,input().split()))
XY = [list(map(int,input().split())) for _ in range(Q)]
tree = [[] for _ in range(N+1)]
depth = [None]*(N+1)
for abc in ABC:
tree[abc[0]].append([abc[1],abc[2]])
tree[abc[1]].append([abc[0],abc[2]])
def DFS(v,p,d):
depth[v] = d
for e in tree[v]:
if e[0] != p:
DFS(e[0], v, d + e[1])
DFS(K,0,0)
for i in range(Q):
print((depth[XY[i][0]] + depth[XY[i][1]])) | import sys;sys.setrecursionlimit(int(1e7))
N = int(eval(input()))
ABC = [tuple(map(int,input().split())) for _ in range(N-1)]
Q,K = list(map(int,input().split()))
XY = [tuple(map(int,input().split())) for _ in range(Q)]
tree = [[] for _ in range(N+1)]
depth = [None]*(N+1)
for abc in ABC:
tree[abc[0]].append((abc[1],abc[2]))
tree[abc[1]].append((abc[0],abc[2]))
def DFS(v,p,d):
depth[v] = d
for e in tree[v]:
if e[0] != p:
DFS(e[0], v, d + e[1])
DFS(K,0,0)
for i in range(Q):
print((depth[XY[i][0]] + depth[XY[i][1]])) | p03634 |
import sys;sys.setrecursionlimit(int(1e7))
from collections import deque
N = int(eval(input()))
tree = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b, c = list(map(int,input().split()))
tree[a].append((b,c))
tree[b].append((a,c))
Qn,K = list(map(int,input().split()))
XY = [tuple(map(int,input().split())) for _ in range(Qn)]
dist = [-1]*(N+1)
dist[K] = 0
Q = deque()
Q.append(K)
while len(Q):
p = Q.popleft()
for q,c in tree[p]:
if dist[q] != -1: continue
dist[q] = dist[p]+c
Q.append(q)
for i in range(Qn):
print((dist[XY[i][0]] + dist[XY[i][1]])) | import sys;sys.setrecursionlimit(int(1e7))
from sys import stdin
from collections import deque
input = stdin.readline
N = int(eval(input()))
tree = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b, c = list(map(int,input().split()))
tree[a].append((b,c))
tree[b].append((a,c))
Qn,K = list(map(int,input().split()))
XY = [tuple(map(int,input().split())) for _ in range(Qn)]
dist = [-1]*(N+1)
dist[K] = 0
Q = deque()
Q.append(K)
while len(Q):
p = Q.popleft()
for q,c in tree[p]:
if dist[q] != -1: continue
dist[q] = dist[p]+c
Q.append(q)
for i in range(Qn):
print((dist[XY[i][0]] + dist[XY[i][1]])) | p03634 |
N=int(eval(input()))
from collections import defaultdict
from collections import deque
branch=defaultdict(set)
for i in range(N-1):
a,b,c=list(map(int,input().split()))
branch[a]|={(b,c),}
branch[b]|={(a,c),}
Q,K=list(map(int,input().split()))
dist=[float('inf')]*(N+1)
dist[K]=0
check=deque([K])
while len(check)>0:
now=check.popleft()
for nex,c in branch[now]:
if dist[nex]>dist[now]+c:
dist[nex]=dist[now]+c
check.append(nex)
for q in range(Q):
x,y=list(map(int,input().split()))
print((dist[x]+dist[y])) | N=int(eval(input()))
from collections import defaultdict
branch=defaultdict(dict)
for i in range(N-1):
a,b,c=list(map(int,input().split()))
branch[a-1][b-1]=c
branch[b-1][a-1]=c
Q,K=list(map(int,input().split()))
dist=[float('inf') for i in range(N)]
K-=1
dist[K]=0
check={K}
while len(check)>0:
now=check.pop()
for nex,cost in list(branch[now].items()):
if dist[nex]>dist[now]+cost:
dist[nex]=dist[now]+cost
check|={nex}
for i in range(Q):
x,y=list(map(int,input().split()))
print((dist[x-1]+dist[y-1])) | p03634 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
g = [[] for _ in range(N+1)]
dist = [[-1]*(N+1) for _ in range(N+1)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
g[a].append([b, c])
g[b].append([a, c])
Q, K = list(map(int, input().split()))
cost = [-1] * (N+1)
cost[K] = 0
temp = [K]
while temp:
p = temp.pop()
for q in g[p]:
if cost[q[0]] == -1:
cost[q[0]] = cost[p] + q[1]
temp.append(q[0])
for i in range(Q):
x, y = list(map(int, input().split()))
print((cost[x] + cost[y]))
| import sys
input = sys.stdin.readline
N = int(eval(input()))
g = [[] for _ in range(N+1)]
for i in range(N-1):
a, b, c = list(map(int, input().split()))
g[a].append([b, c])
g[b].append([a, c])
Q, K = list(map(int, input().split()))
cost = [-1] * (N+1)
cost[K] = 0
temp = [K]
while temp:
p = temp.pop()
for q in g[p]:
if cost[q[0]] == -1:
cost[q[0]] = cost[p] + q[1]
temp.append(q[0])
for i in range(Q):
x, y = list(map(int, input().split()))
print((cost[x] + cost[y]))
| p03634 |
import heapq
def dijkstra_heap(s):
d = [float("inf")] * n
used = [True] * n
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist,e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
if not used[minedge[1]]:
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,[e[0]+d[v],e[1]])
return d
import sys
input = sys.stdin.readline
n =int(eval(input()))
edge = [[] for i in range(n)]
#edge[i] : [weght,to]
for i in range(n-1):
a, b, c = list(map(int,input().split()))
a, b = a-1, b-1
edge[a].append([c,b])
edge[b].append([c,a])
q, k = list(map(int, input().split()))
k = k-1
d = dijkstra_heap(k)
for i in range(q):
x, y = list(map(int, input().split()))
x, y = x-1, y-1
print((d[x]+d[y])) | import heapq
def dijkstra_heap(s):
d = [float("inf")] * n
used = [True] * n #True: not used
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist,e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
if not used[minedge[1]]:
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,(e[0]+d[v],e[1]))
return d
import sys
input = sys.stdin.readline
n =int(eval(input()))
edge = [[] for i in range(n)]
#edge[i] : [weght,to]
for i in range(n-1):
a, b, c = list(map(int,input().split()))
a, b = a-1, b-1
edge[a].append((c,b))
edge[b].append((c,a))
q, k = list(map(int, input().split()))
k = k-1
d = dijkstra_heap(k)
for i in range(q):
x, y = list(map(int, input().split()))
x, y = x-1, y-1
print((d[x]+d[y])) | p03634 |
n = int(eval(input()))
g = {}
for i in range(1,n+1):
g[i] = []
for _ in range(n-1):
a,b,c = list(map(int,input().split()))
g[a].append([b,c])
g[b].append([a,c])
Q,k = list(map(int,input().split()))
q = [list(map(int,input().split())) for _ in range(Q)]
from collections import deque
queue = deque(g[k])
shortest = [0]*(n+1)
while queue:
a,c = queue.pop()
shortest[a] = c
for v in g[a]:
if shortest[v[0]]==0:
queue.appendleft([v[0],v[1]+c])
for x,y in q:
print((shortest[x]+shortest[y])) | n = int(eval(input()))
g = {}
from collections import deque
for i in range(1,n+1):
g[i] = deque([])
for _ in range(n-1):
a,b,c = list(map(int,input().split()))
g[a].appendleft([b,c])
g[b].appendleft([a,c])
Q,k = list(map(int,input().split()))
q = [list(map(int,input().split())) for _ in range(Q)]
queue = deque(g[k])
shortest = [0]*(n+1)
while queue:
a,c = queue.pop()
shortest[a] = c
while g[a]:
v = g[a].pop()
if shortest[v[0]]==0:
queue.appendleft([v[0],v[1]+c])
for x,y in q:
print((shortest[x]+shortest[y])) | p03634 |
import heapq
def dijkstra(s):
hq = [(0, s)]
heapq.heapify(hq) # リストを優先度付きキューに変換
cost = [float('inf')] * n # 行ったことのないところはinf
cost[s] = 0 # 開始地点は0
while hq:
c, v = heapq.heappop(hq)
if c > cost[v]: # コストが現在のコストよりも高ければスルー
continue
for d, u in e[v]:
tmp = d + cost[v]
if tmp < cost[u]:
cost[u] = tmp
heapq.heappush(hq, (tmp, u))
return cost
n = int(eval(input()))
e = [[] for _ in range(n)]
for _ in range(n-1):
a,b,c = list(map(int,input().split()))
a,b = a-1, b-1
e[a].append((c, b))
e[b].append((c, a))
q,k = list(map(int,input().split()))
for _ in range(q):
x,y = list(map(int,input().split()))
print((dijkstra(x-1)[k-1] + dijkstra(k-1)[y-1])) | import heapq
def dijkstra(s):
hq = [(0, s)]
heapq.heapify(hq) # リストを優先度付きキューに変換
cost = [float('inf')] * n # 行ったことのないところはinf
cost[s] = 0 # 開始地点は0
while hq:
c, v = heapq.heappop(hq)
if c > cost[v]: # コストが現在のコストよりも高ければスルー
continue
for d, u in e[v]:
tmp = d + cost[v]
if tmp < cost[u]:
cost[u] = tmp
heapq.heappush(hq, (tmp, u))
return cost
n = int(eval(input()))
e = [[] for _ in range(n)]
for _ in range(n-1):
a,b,c = list(map(int,input().split()))
a,b = a-1, b-1
e[a].append((c, b))
e[b].append((c, a))
q,k = list(map(int,input().split()))
l = dijkstra(k-1)
for _ in range(q):
x,y = list(map(int,input().split()))
print((l[x-1] + l[y-1])) | p03634 |
#!/usr/bin/env python3
#ABC70 D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop
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
n = int(eval(input()))
abc = [list(map(int,input().split())) for _ in range(n-1)]
q,k = list(map(int,input().split()))
g = [[] for _ in range(n)]
cost = [[float('inf')]*n for _ in range(n)]
for a,b,c in abc:
g[a-1].append(b-1)
g[b-1].append(a-1)
cost[a-1][b-1] = c
cost[b-1][a-1] = c
que = deque()
que.append((0,k-1))
c = [False]*n
dist = [float('inf')]*n
while que:
d,v = que.popleft()
dist[v] = min(dist[v],d)
if not c[v]:
c[v] = True
for u in g[v]:
que.append((d+cost[v][u],u))
for _ in range(q):
x,y = list(map(int,input().split()))
print((dist[x-1] + dist[y-1]))
| #!/usr/bin/env python3
#ABC70 D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop
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
n = int(eval(input()))
abc = [list(map(int,input().split())) for _ in range(n-1)]
q,k = list(map(int,input().split()))
g = [[] for _ in range(n)]
for a,b,c in abc:
g[a-1].append((b-1,c))
g[b-1].append((a-1,c))
que = deque()
que.append(k-1)
dist = [-1]*n
dist[k-1] = 0
while que:
v = que.popleft()
for x,c in g[v]:
if dist[x] == -1:
dist[x] = dist[v] + c
que.append(x)
for _ in range(q):
x,y = list(map(int,input().split()))
print((dist[x-1] + dist[y-1]))
| p03634 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.