input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n = int(eval(input()))
dp =[[0]*3 for _ in range(n)]
dp[0] = list(map(int,input().split()))
for i in range(1,n):
a,b,c=list(map(int,input().split()))
dp[i][0] = a + max(dp[i-1][1],dp[i-1][2])
dp[i][1] = b + max(dp[i-1][0],dp[i-1][2])
dp[i][2] = c + max(dp[i-1][0],dp[i-1][1])
print((max(dp[n-1]))) | def I(): return int(eval(input()))
def LI(): return list(map(int,input().split()))
def MI(): return list(map(int,input().split()))
def LLI(n): return [list(map(int, input().split())) for _ in range(n)]
n = I()
act = [[0,0,0]] + LLI(n)
dp = [[-10**10,-10**10,-10**10] for _ in range(n+1)]
#dp[i][0]はi日目でA選ぶときの幸福度の最大値
#dp[i][1]はi日目でB選ぶときの幸福度の最大値
#dp[i][2]はi日目でC選ぶときの幸福度の最大値
#1-indexedで考えよう
dp[1] = act[1]
for i in range(2,n+1):
dp[i][0] = max(dp[i-1][1] + act[i][0], dp[i-1][2] + act[i][0])
dp[i][1] = max(dp[i-1][0] + act[i][1], dp[i-1][2] + act[i][1])
dp[i][2] = max(dp[i-1][1] + act[i][2], dp[i-1][0] + act[i][2])
print((max(dp[n][0],dp[n][1],dp[n][2])))
| p03162 |
N = int(eval(input()))
dp = [[0] * 3 for _ in range(N)]
action = list(map(int, input().split()))
dp[0][0] = action[0]
dp[0][1] = action[1]
dp[0][2] = action[2]
for i in range(N-1):
action = list(map(int, input().split()))
dp[i+1][0] = max(dp[i][1]+action[0],dp[i][2]+action[0])
dp[i+1][1] = max(dp[i][0]+action[1],dp[i][2]+action[1])
dp[i+1][2] = max(dp[i][0]+action[2],dp[i][1]+action[2])
print((max(dp[N-1]))) | N = int(eval(input()))
dp = [[0] * 3 for _ in range(N)]
dp[0][0], dp[0][1], dp[0][2] = list(map(int, input().split()))
for i in range(1,N):
a, b, c= list(map(int, input().split()))
dp[i][0] = max(dp[i-1][1]+a,dp[i-1][2]+a)
dp[i][1] = max(dp[i-1][0]+b,dp[i-1][2]+b)
dp[i][2] = max(dp[i-1][1]+c,dp[i-1][0]+c)
print((max(dp[N-1]))) | p03162 |
N = int(eval(input()))
dp = [0, 0, 0]
for i in range(N):
a, b, c = list(map(int, input().split()))
tmp_a = a + max(dp[1], dp[2])
tmp_b = b + max(dp[0], dp[2])
tmp_c = c + max(dp[0], dp[1])
dp = [tmp_a, tmp_b, tmp_c]
print((max(dp)))
| N = int(eval(input()))
dp = [0, 0, 0]
for _ in range(N):
a, b, c = list(map(int, input().split()))
dp = [a+max(dp[1], dp[2]), b+max(dp[0], dp[2]), c+max(dp[0], dp[1])]
print((max(dp))) | p03162 |
n = int(eval(input()))
s = [list(map(int, input().split())) for _ in range(n)]
dp = [[0] * 3 for i in range(n+1)]
for i in range(n):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i+1][k] = max(dp[i][j] + s[i][k], dp[i+1][k])
print((max(dp[n])))
| n = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(n)]
dp = [[0, 0, 0] for _ in range(2 * n)]
for i in range(n):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + abc[i][k])
print((max(dp[n])))
| p03162 |
import sys
sys.setrecursionlimit(10**8)
N = int(eval(input()))
abc = [list(map(int, input().split())) for i in range(N)]
abc.append([0, 0, 0])
dp = [[-1] * 4 for i in range(N + 1)]
def happy(n, p):
if n < 0:
return 0
if dp[n][p] >= 0:
return dp[n][p]
a = 0 if p == 0 else happy(n - 1, 0) + abc[n][0]
b = 0 if p == 1 else happy(n - 1, 1) + abc[n][1]
c = 0 if p == 2 else happy(n - 1, 2) + abc[n][2]
dp[n][p] = max([a, b, c])
return dp[n][p]
print((happy(N - 1, 3)))
| N = int(eval(input()))
abc = [list(map(int, input().split())) for i in range(N)]
abc.append([0, 0, 0])
dp = [[-1] * 4 for i in range(N + 1)]
dp[0] = [0, 0, 0]
for i in range(1, N + 1):
dp[i][0] = max([dp[i - 1][1] + abc[i - 1][1], dp[i - 1][2] + abc[i - 1][2]])
dp[i][1] = max([dp[i - 1][0] + abc[i - 1][0], dp[i - 1][2] + abc[i - 1][2]])
dp[i][2] = max([dp[i - 1][1] + abc[i - 1][1], dp[i - 1][0] + abc[i - 1][0]])
print((max(dp[N])))
| p03162 |
n = int(eval(input()))
li = [list(map(int,input().split())) for _ in range(n)]
dp = [[0,0,0] for _ in range(n)]
for i in range(n):
if i == 0:
for j in range(3):
dp[i][j] = li[i][j]
else:
for j in range(3):
for k in range(3):
if j == k:
continue
else:
dp[i][j] = max(dp[i-1][k] + li[i][j], dp[i][j])
print((max(dp[-1])))
| n = int(eval(input()))
li = [list(map(int, input().split())) for _ in range(n)]
dp = [[0,0,0] for _ in range(n)]
for i in range(n):
if i == 0:
for j in range(3):
dp[i][j] = li[i][j]
else:
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i][k] = max(dp[i][k], dp[i-1][j] + li[i][k])
print((max(dp[-1]))) | p03162 |
n = int(eval(input()))
d = [[int(e) for e in input().split()] for i in range(n)]
f = [None for i in range(n)]
f[0] = d[0]
for i in range(1, n):
f[i] = [max(f[i - 1][1] + d[i][0], f[i - 1][2] + d[i][0]), max(f[i - 1][0] + d[i][1], f[i - 1][2] + d[i][1]), max(f[i - 1][0] + d[i][2], f[i - 1][1] + d[i][2])]
print((max(f[n - 1])))
| # DP(貰うDP)
N = int(eval(input()))
dp = [[0] * 3 for _ in range(N + 1)]
for i in range(N):
a, b, c = list(map(int, input().split()))
dp[i + 1][0] = max(dp[i][1] + b, dp[i][2] + c)
dp[i + 1][1] = max(dp[i][0] + a, dp[i][2] + c)
dp[i + 1][2] = max(dp[i][0] + a, dp[i][1] + b)
print((max(dp[N])))
| p03162 |
N = int(eval(input()))
ABC = (list(map(int, input().split())) for _ in range(N))
DP = [[0, 0, 0] for _ in range(N)]
for i, abc in enumerate(ABC):
if i == 0:
for j in range(3):
DP[i][j] = abc[j]
else:
for j in range(3):
DP[i][j] = max(DP[i-1][k] + abc[j] for k in range(3) if j != k)
print((max(DP[N-1]))) | N, = list(map(int, input().split()))
ABC = [list(map(int, input().split())) for i in range(N)]
dp = [[0] * 3 for i in range(N)]
for i in range(N):
for j in range(3):
if i - 1 < 0:
dp[i][j] += ABC[i][j]
else:
x = (j + 1) % 3
y = (j + 2) % 3
dp[i][j] = max(dp[i-1][x], dp[i-1][y]) + ABC[i][j]
print((max(dp[N-1])))
| p03162 |
n = int(eval(input()))
l = [list(map(int, input().split())) for i in range(n)]
a, b, c = [list(i) for i in zip(*l)]
dp = [[0, 0, 0] for i in range(n+1)]
for i in range(n):
dp[i+1][0] = max(dp[i][1]+a[i], dp[i][2]+a[i])
dp[i+1][1] = max(dp[i][0]+b[i], dp[i][2]+b[i])
dp[i+1][2] = max(dp[i][0]+c[i], dp[i][1]+c[i])
print((max(dp[-1][0], dp[-1][1], dp[-1][2])))
| n = int(eval(input()))
l = [list(map(int,input().split())) for i in range(n)]
a,b,c = [list(i) for i in zip(*l)]
dp = [[0,0,0] for i in range(n+1)]
for i in range(n):
dp[i+1][0] = max(dp[i][1]+a[i],dp[i][2]+a[i])
dp[i+1][1] = max(dp[i][0]+b[i],dp[i][2]+b[i])
dp[i+1][2] = max(dp[i][0]+c[i],dp[i][1]+c[i])
print((max(dp[-1]))) | p03162 |
def main():
n = int(eval(input()))
abc = [[0, 0, 0] for _ in range(n + 1)]
for i in range(1, n + 1):
abc[i] = list(map(int, input().split()))
dp = [[0, 0, 0] for _ in range(n + 1)]
dp[1] = abc[1]
for i in range(1, n + 1):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i][j] = max(dp[i][j], dp[i - 1][k] + abc[i][k])
print((max(dp[-1])))
if __name__ == "__main__":
main()
| def main():
n = int(eval(input()))
abc = [[0, 0, 0] for _ in range(n + 1)]
for i in range(1, n + 1):
abc[i] = list(map(int, input().split()))
dp = [[0, 0, 0] for _ in range(n + 1)]
dp[1] = abc[1]
for i in range(1, n + 1):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i][j] = max(dp[i][j], dp[i - 1][k] + abc[i][j])
print((max(dp[-1])))
if __name__ == "__main__":
main()
| p03162 |
N = int(eval(input()))
A, B, C = 0, 0, 0
for _ in range(N):
a, b, c = list(map(int, input().split()))
A, B, C = max(B, C) + a, max(C, A) + b, max(A, B) + c
ans = max(A, B, C)
print(ans) | import sys
input=sys.stdin.readline
def solve():
N = int(eval(input()))
A, B, C = 0, 0, 0
for _ in range(N):
a, b, c = list(map(int, input().split()))
A, B, C = max(B, C) + a, max(C, A) + b, max(A, B) + c
return max(A, B, C)
if __name__ == "__main__":
print((solve())) | p03162 |
def run():
N = int(eval(input()))
abc_li = [[int(i) for i in input().split()] for n in range(N)]
dp = [0] * N
dp[0] = [(abc_li[0][k], k) for k in range(3)]
for n in range(1, N):
len_dp = len(dp[n-1])
dp[n] = [(0, 0) for _ in range(len_dp)]
for k in range(len_dp):
value, pre_abc = dp[n-1][k]
for abc, abc_value in enumerate(abc_li[n]):
if pre_abc == abc: continue
if dp[n][k][0] == (value + abc_value):
dp[n].append((value + abc_value, abc))
continue
dp[n][k] = max([dp[n][k], (value + abc_value, abc)],
key=lambda x:x[0])
dp[n] = list(set(dp[n]))
print((max(dp[-1])[0]))
if __name__ == '__main__':
run() | def run():
N = int(eval(input()))
abc_li = [[int(i) for i in input().split()] for n in range(N)]
dp = [[0]*3 for n in range(N)]
dp[0] = abc_li[0]
for n in range(1, N):
for next_abc in range(3):
for pre_abc in range(3):
if pre_abc == next_abc: continue
dp[n][next_abc] = max(dp[n][next_abc], dp[n-1][pre_abc]+abc_li[n][next_abc])
print((max(dp[N-1])))
if __name__ == '__main__':
run() | p03162 |
n=int(eval(input()))
dp=[[0]*(n) for _ in range(3)]
l=[]
for i in range(n):
a,b,c=list(map(int,input().split()))
l.append([a,b,c])
dp[0][0],dp[1][0],dp[2][0]=l[0][0],l[0][1],l[0][2]
for i in range(0,n-1):
dp[0][i+1]=max(dp[1][i]+l[i+1][0],dp[2][i]+l[i+1][0])
dp[1][i+1]=max(dp[0][i]+l[i+1][1],dp[2][i]+l[i+1][1])
dp[2][i+1]=max(dp[0][i]+l[i+1][2],dp[1][i]+l[i+1][2])
print((max([dp[0][n-1],dp[1][n-1],dp[2][n-1]])))
| import sys
input=sys.stdin.readline
n=int(eval(input()))
dp=[[0]*3 for _ in range(n)]
a,b,c=list(map(int,input().split()))
dp[0]=[a,b,c]
for i in range(1,n):
a,b,c=list(map(int,input().split()))
dp[i][0]=max(dp[i-1][1],dp[i-1][2])+a
dp[i][1]=max(dp[i-1][0],dp[i-1][2])+b
dp[i][2]=max(dp[i-1][0],dp[i-1][1])+c
print((max(dp[n-1])))
| p03162 |
import sys
sys.setrecursionlimit(1000000)
def maxcost(li,n,i,strt,dp):
if i==(n-1):
return li[i][strt]
mx=-sys.maxsize
for l in range(3):
if l!=strt:
if dp[i+1][l]==-1:
cost=maxcost(li,n,i+1,l,dp)
dp[i+1][l]=cost
else:
cost=dp[i+1][l]
mx=max(mx,cost+li[i][strt])
return mx
n=int(eval(input()))
li=[]
for i in range(n):
temp=[int(x) for x in input().split()]
li.append(temp)
dp=[[-1 for j in range(3)] for i in range(n)]
print((max(maxcost(li,n,0,0,dp),maxcost(li,n,0,1,dp),maxcost(li,n,0,2,dp)))) | import sys
def maxcost(li,n):
dp=[[-1 for j in range(3)] for i in range(n)]
dp[n-1][0],dp[n-1][1],dp[n-1][2]=li[n-1][0],li[n-1][1],li[n-1][2]
for i in range(n-2,-1,-1):
for j in range(3):
mx=-sys.maxsize
for k in range(3):
if j!=k:
mx=max(mx,dp[i+1][k]+li[i][j])
dp[i][j]=mx
return max(dp[0][0],dp[0][1],dp[0][2])
n=int(eval(input()))
li=[]
for i in range(n):
temp=[int(x) for x in input().split()]
li.append(temp)
print((maxcost(li,n))) | p03162 |
#https://atcoder.jp/contests/dp/tasks/dp_c
N = int(eval(input()))
p = [list(map(int,input().split())) for l in range(N)]
dp = [[0,0,0]]*N
dp[0] = p[0]
for i in range(1,N,1):
dp[i] = [0,0,0]#この文がないとバグる、理由はわからん
#print(dp)
for j in range(3):
for k in range(3):
if k != j:
dp[i][j] = max(dp[i][j],dp[i-1][k] + p[i][j])
#print(i,j,dp[i][j])
print((max(max(dp)))) | #動的計画法
#C - Vacation
#aのところをdp[i][0]とするとなぜか事故る、そういう仕様なのか？、それどもdp = [[0,0,0]]*Nが影響しているのか
N = int(eval(input()))
H = [list(map(int,input().split())) for i in range(N)]
dp = [[0,0,0]]*N
dp[0] = H[0]
for i in range(1,N):
a = max(dp[i-1][1],dp[i-1][2])+H[i][0]
b = max(dp[i-1][0],dp[i-1][2])+H[i][1]
c = max(dp[i-1][0],dp[i-1][1])+H[i][2]
dp[i] = [a,b,c]
print((max(dp[N-1]))) | p03162 |
N = int(eval(input()))
H = []
for _ in range(N):
h = tuple(map(int, input().split()))
H.append(h)
dp = [H[0]]
for i in range(1, N):
dp.append([
max(dp[i-1][1] + H[i][0], dp[i-1][2] + H[i][0]),
max(dp[i-1][0] + H[i][1], dp[i-1][2] + H[i][1]),
max(dp[i-1][0] + H[i][2], dp[i-1][1] + H[i][2]),
])
print((max(dp[-1])))
| N = int(eval(input()))
H = []
for _ in range(N):
h = tuple(map(int, input().split()))
H.append(h)
dp = H[0]
for i in range(1, N):
a, b, c = H[i]
dp_next = [
max(dp[1] + a, dp[2] + a),
max(dp[0] + b, dp[2] + b),
max(dp[0] + c, dp[1] + c),
]
dp = dp_next
print((max(dp))) | p03162 |
N = int(eval(input()))
dp = [[0 for _ in range(3)] for _ in range(N)]
a,b,c = [int(i) for i in input().split()]
dp[0][0] = a
dp[0][1] = b
dp[0][2] = c
for i in range(1,N):
li = [int(i) for i in input().split()]
for j in range(3):
tmp = []
for k in range(3):
if j != k:
tmp.append(dp[i-1][k] + li[j])
dp[i][j] = max(tmp)
print((max(dp[-1])))
| N = int(eval(input()))
A = [[int(i) for i in input().split()] for _ in range(N)]
dp = [[0]*3 for _ in range(N)]
dp[0] = A[0]
for i in range(1,N):
for j in range(3):
for k in range(3):
if j != k:
dp[i][k] = max(dp[i][k], dp[i-1][j]+A[i][k])
print((max(dp[-1])))
| p03162 |
class Solver(object):
def __init__(self, N, happy):
self.dp = [[99999999 for _ in range(3)] for _ in range(N)]
self.N = N
self.happy = happy
def solve(self):
happy_list = self.happy
self.dp[0] = happy_list[0]
for i in range(1, self.N):
self.dp[i][0] = max(happy_list[i][0] + self.dp[i-1][1],
happy_list[i][0] + self.dp[i-1][2])
self.dp[i][1] = max(happy_list[i][1] + self.dp[i-1][0],
happy_list[i][1] + self.dp[i-1][2])
self.dp[i][2] = max(happy_list[i][2] + self.dp[i-1][0],
happy_list[i][2] + self.dp[i - 1][1])
return max(self.dp[-1])
def main():
N = int(eval(input()))
happy = [[int(i) for i in input().split()] for _ in range(N)]
solver = Solver(N, happy)
print((solver.solve()))
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
# sys.setrecursionlimit(100000)
def main():
N = int(input().strip())
happy_list = [[int(i) for i in input().strip().split()] for _ in range(N)]
dp = [[None, None, None] for _ in range(N)]
dp[0] = happy_list[0]
for i in range(1, N):
dp[i][0] = happy_list[i][0] + max(dp[i - 1][1], dp[i - 1][2])
dp[i][1] = happy_list[i][1] + max(dp[i - 1][0], dp[i - 1][2])
dp[i][2] = happy_list[i][2] + max(dp[i - 1][0], dp[i - 1][1])
return max(dp[-1])
if __name__ == "__main__":
print((main()))
| p03162 |
import sys
n = int(sys.stdin.readline())
L = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
p = [[0 for _ in range(3)] for _ in range(n)]
p[0] = L[0].copy()
#print(p)
#print(L)
for d in range(1, n):
for i in range(3):
if i ==0:
p[d][0] = max(p[d-1][1], p[d-1][2]) + L[d][0]
elif i ==1:
p[d][1] = max(p[d-1][0], p[d-1][2]) + L[d][1]
elif i==2:
p[d][2] = max(p[d-1][0], p[d-1][1]) + L[d][2]
print((max(p[-1]))) | import sys
n = int(sys.stdin.readline())
L = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
#print(L)
dp = [[0 for _ in range(3)] for _ in range(n)]
dp[0] = L[0].copy()
for i in range(1,n):
dp[i][0] = max(dp[i-1][1], dp[i-1][2]) + L[i][0]
dp[i][1] = max(dp[i-1][0], dp[i-1][2]) + L[i][1]
dp[i][2] = max(dp[i-1][0], dp[i-1][1]) + L[i][2]
print((max(dp[-1]))) | p03162 |
from functools import lru_cache
import sys
sys.setrecursionlimit(10**9)
n = int(eval(input()))
arr = []
for i in range(n):
arr.append([int(i) for i in input().split()])
@lru_cache(None)
def cal(i,action):
if i>=len(arr):
return 0
if action==0:
return max(cal(i+1,1)+arr[i][1],cal(i+1,2)+arr[i][2])
elif action==1:
return max(cal(i+1,0)+arr[i][0],cal(i+1,2)+arr[i][2])
else:
return max(cal(i+1,1)+arr[i][1],cal(i+1,0)+arr[i][0])
print((max(cal(0,0),cal(0,1),cal(0,2)))) |
import sys
sys.setrecursionlimit(10**9)
n = int(eval(input()))
arr = []
for i in range(n):
arr.append([int(i) for i in input().split()])
dp = [[-1 for i in range(n+2)] for i in range(3)]
def cal(i,action):
if i>=len(arr):
return 0
if dp[action][i]==-1:
if action==0:
dp[action][i] = max(cal(i+1,1)+arr[i][1],cal(i+1,2)+arr[i][2])
elif action==1:
dp[action][i] = max(cal(i+1,0)+arr[i][0],cal(i+1,2)+arr[i][2])
else:
dp[action][i] = max(cal(i+1,1)+arr[i][1],cal(i+1,0)+arr[i][0])
return dp[action][i]
print((max(cal(0,0),cal(0,1),cal(0,2)))) | p03162 |
n=int(eval(input()))
data=[]
t=[[0 for x in range(4)] for w in range(n+1)]
for _ in range(n):
temp=[int(x) for x in input().split()]
data.append(temp)
for i in range(1,n+1):
for j in range(1,4):
large=0
for w in range(1,4):
if(w==j):
continue
else:
if(t[i-1][w]>large):
large=t[i-1][w]
t[i][j]=data[i-1][j-1]+large
print((max(t[-1]))) | import sys
sys.setrecursionlimit(10**8)
def solve(n,pos):
global data,helper
if(n==-1):
return 0
if(helper[n][pos]!=-1):
return helper[n][pos]
if(pos==0):
helper[n][pos]=max(data[n][1]+solve(n-1,1),data[n][2]+solve(n-1,2))
return helper[n][pos]
elif(pos==1):
helper[n][pos] = max(data[n][0]+solve(n-1,0),data[n][2]+solve(n-1,2))
return helper[n][pos]
else:
helper[n][pos] = max(data[n][1]+solve(n-1,1),data[n][0]+solve(n-1,0))
return helper[n][pos]
n=int(eval(input()))
data=[]
helper=[[-1 for y in range(3)] for x in range(n)]
for _ in range(n):
temp=[int(x) for x in input().split()]
data.append(temp)
t1=data[-1][0]+solve(n-2,0)
t2=data[-1][1]+solve(n-2,1)
t3=data[-1][2]+solve(n-2,2)
print((max(t1,t2,t3))) | p03162 |
def resolve():
n = int(eval(input()))
dp = [[0]*3 for _ in range(n+1) ]
for i in range(1, n+1):
r = list(map(int, input().split()))
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i][j] = max(dp[i][j], dp[i-1][k] + r[j])
print((max(dp[-1])))
resolve() | def resolve():
n = int(eval(input()))
dp = [[0]*3 for _ in range(n+1)]
for i in range(1, n+1):
nums = list(map(int, input().split()))
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i][j] = max(dp[i][j], nums[j] + dp[i-1][k])
print((max(dp[-1])))
resolve() | p03162 |
N = int(eval(input()))
dp = [[0 for i in range(3)] for i in range(N+1)]
for i in range(N):
a, b, c = list(map(int, input().split()))
dp[i+1][0] = max(dp[i][1], dp[i][2]) + a
dp[i+1][1] = max(dp[i][0], dp[i][2]) + b
dp[i+1][2] = max(dp[i][0], dp[i][1]) + c
print((max(dp[N])))
| N = int(eval(input()))
dp = [[0]*3 for i in range(N+1)]
for i in range(N):
a, b, c = list(map(int, input().split()))
dp[i+1][0] = max(dp[i][1] + a, dp[i][2] + a, dp[i][0])
dp[i+1][1] = max(dp[i][2] + b, dp[i][0] + b, dp[i][1])
dp[i+1][2] = max(dp[i][0] + c, dp[i][1] + c, dp[i][2])
print((max(dp[N])))
| p03162 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
##############################
N = int(eval(input()))
# 「翌日の値をセット」しているので、最終日+1日まで入る関係で+1
dp = [ [0 for _ in range(3)] for _ in range(N+1) ]
#print(dp)
ABC = [[]] * N
for i in range(N):
x = list(map(int, input().split()))
ABC[i] = x
#print(ABC)
# i日目
for i in range(N):
'''
j k
dp[ i ][ 0 ] から dp[ i + 1 ][ 0 ] はcontinue(以下略）
dp[ i ][ 0 ] から dp[ i + 1 ][ 1 ] への遷移(ABC[i][1])
dp[ i ][ 0 ] から dp[ i + 1 ][ 2 ] への遷移(ABC[i][2])
dp[ i ][ 1 ] から dp[ i + 1 ][ 0 ] への遷移(ABC[i][0])
dp[ i ][ 1 ] から dp[ i + 1 ][ 2 ] への遷移(ABC[i][2])
dp[ i ][ 2 ] から dp[ i + 1 ][ 0 ] への遷移(ABC[i][0])
dp[ i ][ 2 ] から dp[ i + 1 ][ 1 ] への遷移(ABC[i][1])
'''
# i日目の選択肢
for j in range(3):
# i+1日目の選択肢
for k in range(3):
# 翌日が今日と同じならパス
if j == k:
continue
### 配るdp
# 翌日の活動kと、今日の幸福度+選択した活動を比較
dp[i+1][k] = max(dp[i+1][k], dp[i][j]+ABC[i][k])
ans = 0
for i in range(3):
ans = max(ans, dp[N][i])
print(ans)
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
# A = [ int(input()) for _ in range(N) ]
##############################
N = int(eval(input()))
A = []
B = []
C = []
for i in range(N):
a, b, c = list(map(int, input().split()))
A.append(a)
B.append(b)
C.append(c)
dp = [ [0 for _ in range(3)] for _ in range(N+1) ]
for i in range(1, N+1):
dp[i][0] = max(dp[i-1][1]+B[i-1], dp[i-1][2]+C[i-1])
dp[i][1] = max(dp[i-1][0]+A[i-1], dp[i-1][2]+C[i-1])
dp[i][2] = max(dp[i-1][0]+A[i-1], dp[i-1][1]+B[i-1])
print((max(dp[N])))
| p03162 |
N=int(eval(input()))
ABC=[]
for i in range(N):
ABC+=[[int(i) for i in input().split()]]
DP=[[0,0,0] for i in range(N)]
for i in range(N):
DP[i]=[ABC[i][0]+max(DP[i-1][1],DP[i-1][2]),ABC[i][1]+max(DP[i-1][0],DP[i-1][2]),ABC[i][2]+max(DP[i-1][1],DP[i-1][0])]
print((max(DP[N-1]))) | N=int(eval(input()))
ABC=[]
for i in range(N):
ABC+=[[int(i) for i in input().split()]]
DP=[[0,0,0] for i in range(N+1)]
for i in range(N):
for j in range(3):
DP[i][j]=ABC[i][j]+max(DP[i-1][(j+1)%3],DP[i-1][(j+2)%3])
print((max(DP[N-1])))
| p03162 |
N=int(eval(input()))
ABC=[]
for i in range(N):
ABC+=[[int(i) for i in input().split()]]
DP=[[0,0,0] for i in range(N+1)]
for i in range(N):
for j in range(3):
DP[i][j]=ABC[i][j]+max(DP[i-1][(j+1)%3],DP[i-1][(j+2)%3])
print((max(DP[N-1])))
| N=int(eval(input()))
ABC=[[0,0,0]]
for i in range(N):
ABC+=[[int(i) for i in input().split()]]
DP=[[0,0,0] for i in range(N+1)]
for i in range(N):
for j in range(3):
DP[i+1][j]=ABC[i+1][j]+max(DP[i][(j+1)%3],DP[i][(j+2)%3])
print((max(DP[N]))) | p03162 |
N=int(eval(input()))
dp=[[0]*3 for i in range(N+1)]#今回は正の範囲で最大値をもとめたいので0で初期化
for i in range(N):
a=list(map(int,input().split()))
for j in range(3):
for k in range(3):
if k!=j:
dp[i+1][j]=max(dp[i][k]+a[j],dp[i+1][j])
print((max(dp[-1]))) | N=int(eval(input()))
dp=[[0]*3 for i in range(N+1)]
for i in range(N):
a=list(map(int,input().split()))
for j in range(3):
for k in range(3):
if j==k:
continue
dp[i][k]=max(dp[i][k],dp[i-1][j]+a[k])
print((max(dp[N-1]))) | p03162 |
# dp[i日目][i-1日目にどれを選んだか] = i日目までの最大の幸福度
import sys
sys.setrecursionlimit(10 ** 8)
n = int(eval(input()))
a, b, c = [0 for _ in range(n)], [0 for _ in range(n)], [0 for _ in range(n)]
for i in range(n):
a[i], b[i], c[i] = list(map(int, input().split()))
dp = [[-1 for _ in range(3)] for _ in range(n + 1)]
for i in range(3):
dp[0][i] = 0
def rec(i, choice):
if dp[i][choice] > 0:
return dp[i][choice]
if i == n:
return 0
ret = 0 # ループじゃなくてifでやってるのでそれぞれ確実に大きい値が入る（ので更新する必要がない）
if choice == 0:
ret = a[i] + max(rec(i + 1, 1), rec(i + 1, 2))
elif choice == 1:
ret = b[i] + max(rec(i + 1, 0), rec(i + 1, 2))
elif choice == 2:
ret = c[i] + max(rec(i + 1, 0), rec(i + 1, 1))
dp[i][choice] = ret
return ret
print((max(rec(0, 0), rec(0, 1), rec(0, 2))))
| # dp[i日目][i-1日目にどれを選んだか] = i日目までの最大の幸福度
# これはループでやってみたバージョン
n = int(eval(input()))
a, b, c = [0 for _ in range(n)], [0 for _ in range(n)], [0 for _ in range(n)]
for i in range(n):
a[i], b[i], c[i] = list(map(int, input().split()))
dp = [[-1 for _ in range(3)] for _ in range(n + 1)]
# 初期値、最初間違えて0にしてた
dp[0][0] = a[0]
dp[0][1] = b[0]
dp[0][2] = c[0]
for i in range(1, n):
for j in range(3):
if j == 0:
dp[i][j] = a[i] + max(dp[i - 1][1], dp[i - 1][2])
elif j == 1:
dp[i][j] = b[i] + max(dp[i - 1][0], dp[i - 1][2])
elif j == 2:
dp[i][j] = c[i] + max(dp[i - 1][1], dp[i - 1][0])
print((max(dp[n - 1][0], dp[n - 1][1], dp[n - 1][2])))
| p03162 |
N = int(eval(input()))
dp = [[0 for _ in range(3)] for i in range(N)]
a,b,c = list(map(int,input().split()))
dpa = a
dpb = b
dpc = c
for i in range(1,N):
dpap = dpa
dpbp = dpb
dpcp = dpc
a,b,c = list(map(int,input().split()))
dpa = max(dpbp + a, dpcp + a)
dpb = max(dpap + b, dpcp + b)
dpc = max(dpap + c, dpbp + c)
print((max(dpa,dpb,dpc)))
| N = int(eval(input()))
a,b,c = list(map(int,input().split()))
dpa = a
dpb = b
dpc = c
for i in range(1,N):
dpap = dpa
dpbp = dpb
dpcp = dpc
a,b,c = list(map(int,input().split()))
dpa = max(dpbp + a, dpcp + a)
dpb = max(dpap + b, dpcp + b)
dpc = max(dpap + c, dpbp + c)
print((max(dpa,dpb,dpc)))
| p03162 |
#!/usr/bin/env python3
import sys
import collections
import itertools
def solve(N: int, a: "List[int]", b: "List[int]", c: "List[int]"):
dp = collections.defaultdict(int)
for i,x in enumerate([a,b,c]):
dp[0,i] = x[0]
for i,abc in itertools.islice(enumerate(zip(a,b,c)),1,None):
for p,q in ((p,q) for p in range(3) for q in range(3) if p != q):
dp[i,p] = max(dp[i,p], dp[i-1,q] + abc[p])
print((max([dp[N-1,c] for c in range(3)])))
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int()] * (N) # type: "List[int]"
b = [int()] * (N) # type: "List[int]"
c = [int()] * (N) # type: "List[int]"
for i in range(N):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
c[i] = int(next(tokens))
solve(N, a, b, c)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, a: "List[int]", b: "List[int]", c: "List[int]"):
dp = [[0 for _ in range(3)] for _ in range(N)]
H = list(zip(a,b,c))
for j in range(3):
dp[0][j] = H[0][j]
for i in range(1,N):
for j in range(3):
for k in range(3):
if j != k:
dp[i][j] = max(dp[i][j],dp[i-1][k] + H[i][j])
print((max(dp[-1])))
return
# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int()] * (N) # type: "List[int]"
b = [int()] * (N) # type: "List[int]"
c = [int()] * (N) # type: "List[int]"
for i in range(N):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
c[i] = int(next(tokens))
solve(N, a, b, c)
if __name__ == '__main__':
main()
| p03162 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
from functools import reduce
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
_gcd = lambda x, y: _gcd(y, x%y) if (x%y) else y
_lcm = lambda x, y: x*y // _gcd(x, y)
def gcd(*numbers):
return reduce(_gcd, numbers)
def lcm(*numbers):
return reduce(_lcm, numbers)
def factorial(n):
if (n==0) or (n==1):
return 1
ret = 1
for i in range(2, n+1):
ret *= i
return ret
def combination(n, k):
return factorial(n)//factorial(k)//factorial(n-k)
sys.setrecursionlimit(1000000)
mod = 1000000007
dire4 = [(1,0), (0,1), (-1,0), (0,-1)]
dire8 = [(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)]
N = I()
abc = LIR(N)
#dpb[i] = max(dpa[i-1], dpc[i-1])
dpa = [0]*(N+1)
dpb = [0]*(N+1)
dpc = [0]*(N+1)
for i in range(1, N+1):
dpa[i] = max(dpb[i-1], dpc[i-1]) + abc[i-1][0]
dpb[i] = max(dpa[i-1], dpc[i-1]) + abc[i-1][1]
dpc[i] = max(dpa[i-1], dpb[i-1]) + abc[i-1][2]
print((max(dpa[N], dpb[N], dpc[N]))) | #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
from functools import reduce
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
_gcd = lambda x, y: _gcd(y, x%y) if (x%y) else y
_lcm = lambda x, y: x*y // _gcd(x, y)
def gcd(*numbers):
return reduce(_gcd, numbers)
def lcm(*numbers):
return reduce(_lcm, numbers)
def factorial(n):
if (n==0) or (n==1):
return 1
ret = 1
for i in range(2, n+1):
ret *= i
return ret
def combination(n, k):
return factorial(n)//factorial(k)//factorial(n-k)
sys.setrecursionlimit(1000000)
mod = 1000000007
dire4 = [(1,0), (0,1), (-1,0), (0,-1)]
dire8 = [(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)]
N = I()
abc = LIR(N)
dp = [[0]*(N+1) for i in range(3)]
A, B, C = 0, 1, 2
for i in range(N):
a, b, c = abc[i]
dp[A][i+1] = max(dp[B][i], dp[C][i]) + a
dp[B][i+1] = max(dp[A][i], dp[C][i]) + b
dp[C][i+1] = max(dp[A][i], dp[B][i]) + c
print((max(dp[A][N], dp[B][N], dp[C][N]))) | p03162 |
def LIST():
return list(map(int, input().split()))
N = int(eval(input()))
arr = [LIST() for _ in range(N)]
dp = [[arr[0][0],arr[0][1],arr[0][2]],[0,0,0]]
l=1
p=0
for i in range(1, N):
for j in range(3):
for k in range(3):
if j == k: continue
a1=dp[p][j]
a2=arr[i][k]
a3=a1+a2
dp[l][k] = max(dp[l][k], dp[p][j] + arr[i][k])
l=l^1
p=p^1
print((max([dp[p][j] for j in range(3)]))) | N=int(eval(input()))
arr = [int(a) for a in input().split()]
dp = [[arr[0],arr[1],arr[2]],[0,0,0]]
l=1
p=0
for i in range(1, N):
arr = list(map(int, input().split()))
for j in range(3):
for k in range(3):
if j == k: continue
dp[l][k] = max(dp[l][k], dp[p][j] + arr[k])
l=l^1
p=p^1
print((max([dp[p][j] for j in range(3)]))) | p03162 |
import sys
sys.setrecursionlimit(200000)
n = int(eval(input()))
def dp(i, a, b, c):
if i == -1: return 0
a_v = dp(i-1, a=False, b=True, c=True) + al[i] if a else -1
b_v = dp(i-1, a=True, b=False, c=True) + bl[i] if b else -1
c_v = dp(i-1, a=True, b=True, c=False) + cl[i] if c else -1
return max([a_v, b_v, c_v])
al = []
bl = []
cl = []
for i in range(n):
a, b, c = list(map(int, input().split(" ")))
al.append(a)
bl.append(b)
cl.append(c)
print((dp(n-1, a=True, b=True, c=True)))
| import sys
sys.setrecursionlimit(200000)
n = int(eval(input()))
m ={}
def dp(i, a, b, c):
if (i,a,b,c) in m:
return m[(i,a,b,c)]
if i == -1: return 0
a_v = dp(i-1, a=False, b=True, c=True) + al[i] if a else -1
b_v = dp(i-1, a=True, b=False, c=True) + bl[i] if b else -1
c_v = dp(i-1, a=True, b=True, c=False) + cl[i] if c else -1
m[(i,a,b,c)] = max([a_v, b_v, c_v])
return max([a_v, b_v, c_v])
al = []
bl = []
cl = []
for i in range(n):
a, b, c = list(map(int, input().split(" ")))
al.append(a)
bl.append(b)
cl.append(c)
print((dp(n-1, a=True, b=True, c=True))) | p03162 |
N = int(eval(input()))
a = [list(map(int, input().split())) for _ in range(N)]
table = [a[0]]
def dp(n, i):
for j in range(len(table), n+1):
table.append([0]*3)
for k in range(3):
h = [table[j-1][l]+a[j][k] for l in range(3) if k != l]
table[j][k] = max(h)
return table[n][i]
print((max([dp(N-1, i) for i in range(3)]))) | N = int(eval(input()))
dp = [[0]*3 for _ in range(N)]
dp[0] = list(map(int, input().split()))
for i in range(1, N):
h = list(map(int, input().split()))
for j in range(3):
dp[i][j] = max([dp[i-1][k]+h[j] for k in range(3) if k != j])
print((max([dp[N-1][j] for j in range(3)]))) | p03162 |
dp = [[0] * 3 for i in range(100010)]
N = int(eval(input()))
a = [list(map(int, input().split())) for i in range(N)]
for i in range(1, N+1):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i][k] = max(dp[i][k], dp[i-1][j] + a[i-1][k])
print((max(dp[N])))
| N = int(eval(input()))
a = [[0] * 3 for _ in range(N)]
for i in range(N):
a[i][0], a[i][1], a[i][2] = list(map(int, input().split()))
dp = [[0] * 3 for _ in range(N+1)]
for i in range(1, N+1):
for j in range(3):
for k in range(3):
if j == k:
continue
#前の値がdp[i-1][j]で今選んでいるのがa[i-1][k]
dp[i][k] = max(dp[i][k], dp[i-1][j] + a[i-1][k])
print((max(dp[N]))) | p03162 |
n = int(eval(input()))
dpa, dpb, dpc = 0, 0, 0
for i in range(n):
a, b, c = list(map(int, input().split()))
dpa, dpb, dpc = max(dpb, dpc) + a, max(dpa, dpc) + b, max(dpa, dpb) + c
print((max(dpa, dpb, dpc)))
| n = int(eval(input()))
da, db, dc = 0, 0, 0
for i in range(n):
a, b, c = list(map(int, input().split()))
da, db, dc = max(db, dc) + a, max(da, dc) + b, max(da, db) + c
print((max(da, db, dc)))
| p03162 |
N = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(N)]
dp = []
for i in range(N+1):
dp.append([0] * 3)
for j in range(1, N+1):
for k in range(3):
if j == 1:
dp[j][k] = abc[0][k]
else:
box = []
for l in range(3):
if l == k:
continue
else:
box.append(dp[j-1][l] + abc[j-1][k])
dp[j][k] = max(dp[j][k], max(box))
print((max(dp[N])))
| N = int(eval(input()))
dpa = [0] * N
dpb = [0] * N
dpc = [0] * N
a, b, c = list(map(int, input().split()))
dpa[0] = a
dpb[0] = b
dpc[0] = c
for i in range(1, N):
a, b, c = list(map(int, input().split()))
dpa[i] = max(dpb[i-1] + a, dpc[i-1] + a)
dpb[i] = max(dpa[i-1] + b, dpc[i-1] + b)
dpc[i] = max(dpa[i-1] + c, dpb[i-1] + c)
print((max(dpa[N-1], dpb[N-1], dpc[N-1]))) | p03162 |
from functools import lru_cache
import sys
sys.setrecursionlimit(2147483647)
N = int(eval(input()))
A = []
for i in range(0,N):
A.append(list(map(int,input().split())))
@lru_cache(None)
def dfs(d,pre):
if d>=N-1: return 0
tmp = [0]
for idx,a in enumerate(A[d]):
if idx != pre:
res = dfs(d + 1,idx) + a
tmp.append(res)
return max(tmp)
print((dfs(-1,-1))) | N = int(eval(input()))
A = []
for i in range(0,N):
A.append(list(map(int,input().split())))
dp = [[0 for _ in range(3)] for _ in range(N)]
for i in range(N):
for j in range(3):
if i == 0:
dp[i][j]= A[i][j]
else:
tmp = [0]
for k in range(3):
if j !=k:
tmp.append(dp[i-1][k])
dp[i][j] = max(tmp) + A[i][j]
print((max(dp[-1])))
| p03162 |
n = int(eval(input()))
e = tuple(tuple(map(int, input().split())) for _ in range(n))
dp = [[0] * 3 for _ in range(n + 1)]
for i in range(1, n + 1):
for j in range(3):
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + e[i - 1][0]
dp[i][1] = max(dp[i - 1][2], dp[i - 1][0]) + e[i - 1][1]
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + e[i - 1][2]
print((max(dp[n])))
| n = int(eval(input()))
v = tuple(tuple(map(int, input().split())) for _ in range(n))
e = tuple(zip(*v))
# e[j][i(0-indexed)]:=i日目に活動jして得る幸福度
# print(e)
dp = tuple([0] * 3 for _ in range(n + 1))
# dp[i(1-indexed)][j]:=i日目に活動jした最大幸福度
# もらう
for i in range(n):
for j in range(3):
dp[i + 1][j] = max(dp[i][(j + 1) % 3], dp[i][(j + 2) % 3]) + e[j][i]
print((max(dp[n])))
| p03162 |
n = int(eval(input()))
v = tuple(tuple(map(int, input().split())) for _ in range(n))
e = tuple(zip(*v))
# e[j][i(0-indexed)]:=i日目に活動jして得る幸福度
# print(e)
dp = tuple([0] * 3 for _ in range(n + 1))
# dp[i(1-indexed)][j]:=i日目に活動jした最大幸福度
# もらう
for i in range(n):
for j in range(3):
dp[i + 1][j] = max(dp[i][(j + 1) % 3], dp[i][(j + 2) % 3]) + e[j][i]
print((max(dp[n])))
| def main():
import sys
readline = sys.stdin.readline
n = int(readline())
dp = [[0] * 3 for _ in range(n + 1)]
for i in range(1, n + 1): # i日目の最大幸福度,1-indexed
a, b, c = list(map(int, input().split()))
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a
dp[i][1] = max(dp[i - 1][2], dp[i - 1][0]) + b
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + c
print((max(dp[n])))
if __name__ == '__main__':
main()
| p03162 |
def main():
import sys
readline = sys.stdin.readline
n = int(readline())
dp = [[0] * 3 for _ in range(n + 1)]
for i in range(1, n + 1): # i日目の最大幸福度,1-indexed
a, b, c = list(map(int, input().split()))
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a
dp[i][1] = max(dp[i - 1][2], dp[i - 1][0]) + b
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + c
print((max(dp[n])))
if __name__ == '__main__':
main()
| def main():
import sys
readline = sys.stdin.readline
n = int(readline())
dp = [[0] * 3 for _ in range(n + 1)]
for i in range(1, n + 1): # i日目の最大幸福度,1-indexed
a, b, c = list(map(int, readline().split()))
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a
dp[i][1] = max(dp[i - 1][2], dp[i - 1][0]) + b
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + c
print((max(dp[n])))
if __name__ == '__main__':
main()
| p03162 |
# import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
geta = lambda fn: list(map(fn, input().split()))
gete = lambda fn: fn(eval(input()))
def main():
N = gete(int)
p, q, r = 0,0,0
for _ in range(N):
a,b ,c = geta(int)
p,q,r = a + max(q,r), b + max(r,p), c + max(p,q)
print((max(p,q,r)))
if __name__ == "__main__":
main() | # import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
geta = lambda fn: list(map(fn, input().split()))
gete = lambda fn: fn(eval(input()))
def main():
N = gete(int)
a = [0]*(N+1)
b, c = a[:], a[:]
for i in range(N):
av, bv, cv = geta(int)
a[i+1] = av + max(b[i], c[i])
b[i+1] = bv + max(c[i], a[i])
c[i+1] = cv + max(a[i], b[i])
print((max(a[-1], b[-1], c[-1])))
if __name__ == "__main__":
main() | p03162 |
# import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
geta = lambda fn: list(map(fn, input().split()))
gete = lambda fn: fn(eval(input()))
def main():
N = gete(int)
a = [0]*(N+1)
b, c = a[:], a[:]
for i in range(N):
av, bv, cv = geta(int)
a[i+1] = max(av + b[i], av + c[i])
b[i+1] = max(bv + c[i], bv + a[i])
c[i+1] = max(cv + a[i], cv + b[i])
print((max(a[-1], b[-1], c[-1])))
if __name__ == "__main__":
main() | # copy and paste (check calc time)
import sys
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
# import numpy as np
def main():
n=int(eval(input()))
dp=[[0]*3 for _ in range(n+1)]
for i in range(n):
a,b,c=list(map(int,input().split()))
dp[i+1][0]=max(dp[i][1],dp[i][2])+a
dp[i+1][1] = max(dp[i][2], dp[i][0]) + b
dp[i+1][2] = max(dp[i][0], dp[i][1]) + c
print((max(dp[n][0],dp[n][1],dp[n][2])))
if __name__ == "__main__":
main() | p03162 |
# import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
geta = lambda fn: list(map(fn, input().split()))
gete = lambda fn: fn(eval(input()))
def main():
n=gete(int)
dp=[[0]*3 for _ in range(n+1)]
for i in range(n):
a,b,c = list(map(int, input().split()))
dp[i+1][0] = max(dp[i][1], dp[i][2]) + a
dp[i+1][1] = max(dp[i][2], dp[i][0]) + b
dp[i+1][2] = max(dp[i][0], dp[i][1]) + c
print((max(dp[n][0],dp[n][1],dp[n][2])))
if __name__ == "__main__":
main() | # import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
import sys
readline = sys.stdin.buffer.readline
geta = lambda fn: list(map(fn, readline().split()))
gete = lambda fn: fn(readline())
def main():
n=gete(int)
dp=[[0]*3 for _ in range(n+1)]
for i in range(n):
a,b,c = geta(int)
dp[i+1][0] = max(dp[i][1], dp[i][2]) + a
dp[i+1][1] = max(dp[i][2], dp[i][0]) + b
dp[i+1][2] = max(dp[i][0], dp[i][1]) + c
print((max(dp[n][0],dp[n][1],dp[n][2])))
if __name__ == "__main__":
main() | p03162 |
# import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
import sys
readline = sys.stdin.buffer.readline
geta = lambda fn: list(map(fn, readline().split()))
gete = lambda fn: fn(readline())
def main():
n=gete(int)
dp=[[0]*3 for _ in range(n+1)]
for i in range(n):
a,b,c = geta(int)
dp[i+1][0] = max(dp[i][1], dp[i][2]) + a
dp[i+1][1] = max(dp[i][2], dp[i][0]) + b
dp[i+1][2] = max(dp[i][0], dp[i][1]) + c
print((max(dp[n][0],dp[n][1],dp[n][2])))
if __name__ == "__main__":
main() | # import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
import sys
readline = sys.stdin.buffer.readline
geta = lambda fn: list(map(fn, readline().split()))
gete = lambda fn: fn(readline())
def main():
N = gete(int)
cur, prev = [0]*3, [0]*3
for _ in range(N):
a, b, c = geta(int)
prev, cur = cur, prev
cur[0] = max(prev[1], prev[2]) + a
cur[1] = max(prev[2], prev[0]) + b
cur[2] = max(prev[0], prev[1]) + c
print((max(cur)))
if __name__ == "__main__":
main() | p03162 |
import itertools,sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
abc = [LI() for _ in range(N)]
dp = [[0,0,0] for _ in range(N)]
dp[0] = abc[0]
for i,j,k in itertools.product(list(range(N)),[0,1,2],[0,1,2]):
if j==k:
continue
if i-1>=0:
dp[i][j] = max(dp[i][j],dp[i-1][k]+abc[i][j])
print((max(dp[-1])))
| import itertools,sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
abc = [LI() for _ in range(N)]
dp = [[0,0,0] for _ in range(N)]
dp[0] = abc[0]
for i,j,k in itertools.product(list(range(1,N)),[0,1,2],[0,1,2]):
if j==k:
continue
dp[i][j] = max(dp[i][j],dp[i-1][k]+abc[i][j])
print((max(dp[-1])))
| p03162 |
n = int(eval(input()))
a = [list(map(int, input().split())) for i in range(n)]
dp = [[0]*3 for i in range(n+1)]
for i in range(n):
for j in range(3):
for k in range(3):
if j==k:
continue
dp[i+1][k] = max(dp[i+1][k], dp[i][j]+a[i][k])
print((max(dp[-1]))) | n=int(eval(input()))
a=[list(map(int,input().split())) for i in range(n)]
dp=[[a[0][0],a[0][1],a[0][2]]]+[[0]*3 for i in range(n-1)]
for i in range(1,n):
for j in range(3):
if j==0:
dp[i][j]=max(dp[i-1][1],dp[i-1][2])+a[i][0]
elif j==1:
dp[i][j]=max(dp[i-1][0],dp[i-1][2])+a[i][1]
else:
dp[i][j]=max(dp[i-1][1],dp[i-1][0])+a[i][2]
print((max(dp[n-1]))) | p03162 |
N=int(eval(input()))
dp=[[0]*3 for _ in range(N+1)]
abc=[list(map(int,input().split())) for _ in range(N)]
for i in range(N):
for j in range(3): #移動元
for k in range(3): #移動先
if j==k: continue
dp[i+1][k] = max(dp[i+1][k], dp[i][j]+abc[i][k])
print((max(dp[N]))) | def main():
N=int(eval(input()))
dp=[[0]*3 for _ in range(N+1)]
abc=[list(map(int,input().split())) for _ in range(N)]
for i in range(N):
for j in range(3): #移動元
for k in range(3): #移動先
if j==k: continue
dp[i+1][k] = max(dp[i+1][k], dp[i][j]+abc[i][k])
print((max(dp[N])))
if __name__ == '__main__':
main() | p03162 |
n=int(eval(input()))
abc=[[int(i) for i in input().split()] for j in range(n)]
dp=[[abc[0][0],abc[0][1],abc[0][2]],[abc[0][0],abc[0][1],abc[0][2]]]
for i in range(1,n):
for j in range(3):
for k in range(3):
if j!=k:
dp[1][k]=max(dp[1][k] ,dp[0][j]+abc[i][k])
dp[0][0]=dp[1][0]
dp[0][1]=dp[1][1]
dp[0][2]=dp[1][2]
print((max(dp[1]))) | n=int(eval(input()))
abc=[[int(i) for i in input().split()] for j in range(n)]
dp=[[0 for i in range(3)] for j in range(n+1)]
for i in range(3):
dp[1][i]=abc[0][i]
for i in range(1,n):
dp[i+1][0]=max(dp[i][1],dp[i][2])+abc[i][0]
dp[i+1][1]=max(dp[i][2],dp[i][0])+abc[i][1]
dp[i+1][2]=max(dp[i][1],dp[i][0])+abc[i][2]
print((max(dp[-1])))
| p03162 |
from functools import lru_cache
import sys
sys.setrecursionlimit(10**8)
N = int(eval(input()))
ABC = [list(map(int, input().split(" "))) for _ in range(N)]
# l = [[0 for _ in range(3)] for _ in range(N+10)]
@lru_cache(maxsize=None)
def dp(i, use):
if i == -1:
return 0
max_num = 0
for k in range(3):
if k == use:
continue
max_num = max(max_num, dp(i-1, k)+ABC[i][use])
return max_num
print((max(dp(N-1, m) for m in range(3))))
| from functools import lru_cache
import sys
sys.setrecursionlimit(10**8)
N = int(eval(input()))
ABC = [list(map(int, input().split(" "))) for _ in range(N)]
l = [[None for _ in range(3)] for _ in range(N+10)]
# @lru_cache(maxsize=None)
def dp(i, use):
if i == -1:
return 0
if l[i][use] != None:
return l[i][use]
max_num = 0
for k in range(3):
if k == use:
continue
max_num = max(max_num, dp(i-1, k)+ABC[i][use])
l[i][use] = max_num
return max_num
print((max(dp(N-1, m) for m in range(3))))
| p03162 |
import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
a, b, c = [], [], []
# dp = [[None] * 3 for _ in range(n)]
dp = [[0] * 3 for _ in range(n)]
for i in range(n):
v1, v2, v3 = list(map(int, input().split()))
a.append(v1)
b.append(v2)
c.append(v3)
dp[0][0] = a[0]
dp[0][1] = b[0]
dp[0][2] = c[0]
def solve(idx, ptn):
if dp[idx][ptn] > 0:
return dp[idx][ptn]
# Select A(0)
if ptn == 0:
if idx == 0:
return a[0]
a1 = solve(idx - 1, 1) + a[idx]
a2 = solve(idx - 1, 2) + a[idx]
dp[idx][0] = max(a1, a2)
return dp[idx][0]
# Select B(1)
if ptn == 1:
if idx == 0:
return b[0]
b1 = solve(idx - 1, 0) + b[idx]
b2 = solve(idx - 1, 2) + b[idx]
dp[idx][1] = max(b1, b2)
return dp[idx][1]
# Select C(2)
if ptn == 2:
if idx == 0:
return c[0]
c1 = solve(idx - 1, 0) + c[idx]
c2 = solve(idx - 1, 1) + c[idx]
dp[idx][2] = max(c1, c2)
return dp[idx][2]
ans1 = solve(n-1, 0)
ans2 = solve(n-1, 1)
ans3 = solve(n-1, 2)
print((max(ans1, ans2, ans3))) | import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
a, b, c = [], [], []
# dp = [[None] * 3 for _ in range(n)]
dp = [[0] * 3 for _ in range(n)]
for i in range(n):
v1, v2, v3 = list(map(int, input().split()))
a.append(v1)
b.append(v2)
c.append(v3)
dp[0][0] = a[0]
dp[0][1] = b[0]
dp[0][2] = c[0]
for idx in range(1, n):
# Select A(0)
a1 = dp[idx - 1][1] + a[idx]
a2 = dp[idx - 1][2] + a[idx]
dp[idx][0] = max(a1, a2)
# Select B(1)
b1 = dp[idx - 1][0] + b[idx]
b2 = dp[idx - 1][2] + b[idx]
dp[idx][1] = max(b1, b2)
# Select C(2)
c1 = dp[idx - 1][0] + c[idx]
c2 = dp[idx - 1][1] + c[idx]
dp[idx][2] = max(c1, c2)
print((max(dp[n-1][0], dp[n-1][1], dp[n-1][2]))) | p03162 |
N = int(eval(input()))
v = [list(map(int,input().split())) for _ in range(N)]
dp = [[0]*3 for _ in range(N+1)]
for i in range(N):
for j in range(3):
for k in range(3):
if j==k:continue
dp[i+1][k] = max(dp[i+1][k],dp[i][j]+v[i][k])
print((max(dp[N][i] for i in range(3)))) | def main():
N = int(eval(input()))
v = [list(map(int,input().split())) for _ in range(N)]
dp = [[0]*3 for _ in range(N+1)]
for i in range(N):
for j in range(3):
for k in range(3):
if j==k:continue
dp[i+1][k] = max(dp[i+1][k],dp[i][j]+v[i][k])
print((max(dp[N][i] for i in range(3))))
main() | p03162 |
N=int(eval(input()))
a=[]
for _ in range(N):
b=list(map(int,input().split()))
a.append(b)
dp=[]
for _ in range(N):
dp.append([0,0,0])
dp[0][0]=a[0][0]
dp[0][1]=a[0][1]
dp[0][2]=a[0][2]
for i in range(1,N):
dp[i][0]=max(dp[i-1][1]+a[i][0],dp[i-1][2]+a[i][0])
dp[i][1]=max(dp[i-1][0]+a[i][1],dp[i-1][2]+a[i][1])
dp[i][2]=max(dp[i-1][0]+a[i][2],dp[i-1][1]+a[i][2])
print((max(dp[N-1][0],dp[N-1][1],dp[N-1][2]))) | import sys
input = sys.stdin.readline
n = int(eval(input()))
abc = [[int(x) for x in input().split()] for _ in range(n)]
dp = [[0] * 3 for _ in range(n)]
dp[0][0] = abc[0][0]
dp[0][1] = abc[0][1]
dp[0][2] = abc[0][2]
for i in range(1, n):
a, b, c = abc[i]
dp[i][0] = max(dp[i - 1][1] + a, dp[i - 1][2] + a)
dp[i][1] = max(dp[i - 1][0] + b, dp[i - 1][2] + b)
dp[i][2] = max(dp[i - 1][0] + c, dp[i - 1][1] + c)
print((max(dp[-1]))) | p03162 |
N = int(eval(input()))
A = [0]*N
B = [0]*N
C = [0]*N
for i in range(N):
A[i], B[i], C[i] = list(map(int, input().split()))
pointA = [0]*N; pointB = [0]*N; pointC = [0]*N
pointA[0] = A[0]; pointB[0] = B[0]; pointC[0] = C[0]
for i in range(1, N):
pointA[i] = max(pointB[i-1], pointC[i-1]) + A[i]
pointB[i] = max(pointA[i-1], pointC[i-1]) + B[i]
pointC[i] = max(pointA[i-1], pointB[i-1]) + C[i]
print((max((pointA[N-1], pointB[N-1], pointC[N-1])))) | N = int(eval(input()))
A = [0]*N; B = [0]*N; C = [0]*N
for i in range(N):
A[i], B[i], C[i] = list(map(int, input().split()))
lisA = [0]*N; lisB = [0]*N; lisC = [0]*N
lisA[0] = A[0]; lisB[0] = B[0]; lisC[0] = C[0];
for i in range(1, N):
lisA[i] = max(lisB[i-1], lisC[i-1]) + A[i]
lisB[i] = max(lisA[i-1], lisC[i-1]) + B[i]
lisC[i] = max(lisA[i-1], lisB[i-1]) + C[i]
print((max(lisA[N-1], lisB[N-1], lisC[N-1]))) | p03162 |
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(eval(input())) #整数読み込み
def ifn(): return float(eval(input())) #浮動小数点読み込み
def isn(): return input().split() #文字列読み込み
def imn(): return list(map(int, input().split())) #整数map取得
def fmn(): return list(map(float, input().split())) #浮動小数点map取得
def iln(): return list(map(int, input().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln(): return list(map(float, input().split())) # 浮動小数点リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
def m_add(a,b): return (a+b) % MOD
N = iin()
abc = [iln() for _ in range(N)]
dp = [[0 for _ in range(3)] for _ in range(N+1)]
for i in range(N):
for j in range(3):
for k in range(3):
if j == k: continue
dp[i+1][k] = max(dp[i+1][k], dp[i][j]+abc[i][k])
print((max(dp[N])))
| # python3.4.2用
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') #無限大
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(sys.stdin.readline()) #整数読み込み
def ifn(): return float(sys.stdin.readline()) #浮動小数点読み込み
def isn(): return sys.stdin.readline().split() #文字列読み込み
def imn(): return map(int, sys.stdin.readline().split()) #整数map取得
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) #整数-1map取得
def fmn(): return map(float, sys.stdin.readline().split()) #浮動小数点map取得
def iln(): return list(map(int, sys.stdin.readline().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln(): return list(map(float, sys.stdin.readline().split())) # 浮動小数点リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
def m_add(a,b): return (a+b) % MOD
def lprint(l): print(*l, sep='\n')
def sieves_of_e(n):
is_prime = [True] * (n+1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n**0.5)+1):
if not is_prime[i]: continue
for j in range(i * 2, n+1, i): is_prime[j] = False
return is_prime
N = iin()
abc = [iln() for _ in range(N)]
dp = [[0 for _ in range(3)] for _ in range(N+1)]
for i in range(N):
for j in range(3):
for k in range(3):
if j == k: continue
dp[i+1][j] = max(dp[i+1][j], dp[i][k]+abc[i][j])
print(max(dp[N]))
| p03162 |
import sys
N = int(eval(input()))
A = [0] * N
B = [0] * N
C = [0] * N
for i, e in enumerate(sys.stdin):
A[i], B[i], C[i] = list(map(int, e.split()))
dp = [[0] * 3 for _ in range(N + 1)]
for i in range(N):
dp[i][0] = max(dp[i - 1][1] + A[i], dp[i - 1][2] + A[i])
dp[i][1] = max(dp[i - 1][0] + B[i], dp[i - 1][2] + B[i])
dp[i][2] = max(dp[i - 1][0] + C[i], dp[i - 1][1] + C[i])
print((max(dp[N - 1]))) | import sys
N = int(eval(input()))
x, y, z = 0, 0, 0
for i, e in enumerate(sys.stdin):
a, b, c = list(map(int, e.split()))
nx = max(y, z) + a
ny = max(x, z) + b
nz = max(x, y) + c
x, y, z = nx, ny, nz
print((max(x, y, z))) | p03162 |
N=int(eval(input()))
#dp[i]...i日間で得られる幸福度の最大値
INF = 10**18
dp =[]
for _ in range(N):
dp.append([INF] * (N+1))
dp[0] = list(map(int,input().split()))
#print(dp)
for i in range(1, N):
#変えたいのはdp[1][0〜2]
day = list(map(int,input().split()))
d_temp = [dp[i-1][k]+day[j] for j in range(3) for k in range(3) if k!=j]
#print(d_temp)
dp[i]=[max(d_temp[2*x:2*x+2]) for x in range(3)]
print((max(dp[N-1])))
| N=int(eval(input()))
dp =[[0]*3 for _ in range(N)]
dp[0]= list(map(int,input().split()))
for i in range(1,N):
a,b,c=list(map(int,input().split()))
dp[i][0] = a+max(dp[i-1][1], dp[i-1][2])
dp[i][1] = b+max(dp[i-1][2], dp[i-1][0])
dp[i][2] = c+max(dp[i-1][0], dp[i-1][1])
print((max(dp[N-1])))
| p03162 |
n=int(eval(input()))
satis=[]
for i in range(n):
A=list(map(int,input().split()))
satis.extend(A)
tempA=satis[0]
tempB=satis[1]
tempC=satis[2]
if n > 1:
for i in range(n-1):
tempA2=satis[3*i+3]+max([tempB,tempC])
tempB2=satis[3*i+4]+max([tempA,tempC])
tempC2=satis[3*i+5]+max([tempA,tempB])
tempA=tempA2
tempB=tempB2
tempC=tempC2
print((max([tempA,tempB,tempC])))
else:
print((max([tempA,tempB,tempC]))) | n=int(eval(input()))
satis=[]
for i in range(n):
satis.extend(list(map(int,input().split())))
tempA=satis[0]
tempB=satis[1]
tempC=satis[2]
if n > 1:
for i in range(n-1):
tempA2=satis[3*i+3]+max([tempB,tempC])
tempB2=satis[3*i+4]+max([tempA,tempC])
tempC2=satis[3*i+5]+max([tempA,tempB])
tempA=tempA2
tempB=tempB2
tempC=tempC2
print((max([tempA,tempB,tempC])))
else:
print((max([tempA,tempB,tempC]))) | p03162 |
# -*- coding: utf-8 -*-
N = int(eval(input()))
Z = []
for i in range(N):
Z.append(list(map(int, input().split())))
dp = [[0] * N for _ in range(N)]
#print(dp)
dp[0] = Z[0]
for i in range(1,N):
dp[i][0] = max(dp[i-1][1], dp[i-1][2]) + Z[i][0]
dp[i][1] = max(dp[i-1][0], dp[i-1][2]) + Z[i][1]
dp[i][2] = max(dp[i-1][0], dp[i-1][1]) + Z[i][2]
#print(dp)
print((max(dp[-1])))
| # -*- coding: utf-8 -*-
N = int(eval(input()))
Z = []
for i in range(N):
Z.append(list(map(int, input().split())))
dp = [[0] * 3 for _ in range(N)]
#print(dp)
dp[0] = Z[0]
for i in range(1,N):
dp[i][0] = max(dp[i-1][1], dp[i-1][2]) + Z[i][0]
dp[i][1] = max(dp[i-1][0], dp[i-1][2]) + Z[i][1]
dp[i][2] = max(dp[i-1][0], dp[i-1][1]) + Z[i][2]
#print(dp)
print((max(dp[-1])))
| p03162 |
n,*l=list(map(int,open(0).read().split()))
a=l[::3]
b=l[1::3]
c=l[2::3]
dp=[[0]*3 for _ in range(n)]
dp[0]=[a[0],b[0],c[0]]
A,B,C=dp[0]
for i in range(1,n):
dp[i]=[ a[i]+max(B,C) , b[i]+max(C,A) , c[i]+max(A,B) ]
A,B,C=dp[i]
print((max(dp[-1]))) | n,*l=list(map(int,open(0).read().split()))
a=l[::3];b=l[1::3];c=l[2::3]
A,B,C=a[0],b[0],c[0]
M=max
for i in range(1,n):
A,B,C=a[i]+M(B,C),b[i]+M(C,A),c[i]+M(A,B)
print((M(A,B,C))) | p03162 |
n = int(eval(input()))
a = [0]*(n+1)
b = [0]*(n+1)
c = [0]*(n+1)
for i in range(1,n+1): a[i],b[i],c[i] = list(map(int,input().split()))
dp = [[0,0,0] for i in range(n+1)]
for i in range(1,n+1):
for j in range(3):
if j == 0: dp[i][j] = max(dp[i-1][1]+a[i],dp[i-1][2]+a[i])
elif j == 1: dp[i][j] = max(dp[i-1][0]+b[i],dp[i-1][2]+b[i])
else: dp[i][j] = max(dp[i-1][0]+c[i],dp[i-1][1]+c[i])
print((max(dp[n]))) | n = int(eval(input()))
a = [0]*(n+1)
b = [0]*(n+1)
c = [0]*(n+1)
for i in range(1,n+1): a[i],b[i],c[i] = list(map(int,input().split()))
dp = [[0,0,0] for i in range(n+1)]
for i in range(1,n+1):
for j in range(3):
if j == 0: dp[i][j] = max(dp[i-1][1],dp[i-1][2])+a[i]
elif j == 1: dp[i][j] = max(dp[i-1][0],dp[i-1][2])+b[i]
else: dp[i][j] = max(dp[i-1][0],dp[i-1][1])+c[i]
print((max(dp[n]))) | p03162 |
N = int(eval(input()))
A = [0]*N
for i in range(N):
A[i] = list(map(int, input().split()))
def solve(N,A):
dp = [[0]*3 for i in range(N)]
dp[0][0] = A[0][0]
dp[0][1] = A[0][1]
dp[0][2] = A[0][2]
for i in range(1,N):
dp[i][0] = max(dp[i-1][1],dp[i-1][2])+A[i][0]
dp[i][1] = max(dp[i-1][0],dp[i-1][2])+A[i][1]
dp[i][2] = max(dp[i-1][0],dp[i-1][1])+A[i][2]
ans = max(dp[-1])
return ans
print((solve(N,A))) | def solve():
N = int(eval(input()))
dp = [[float('inf')]*3 for _ in range(N)]
dp[0] = list(map(int, input().split()))
for i in range(1,N):
a, b, c = list(map(int, input().split()))
dp[i][0] = max(dp[i-1][1],dp[i-1][2])+a
dp[i][1] = max(dp[i-1][0],dp[i-1][2])+b
dp[i][2] = max(dp[i-1][0],dp[i-1][1])+c
ans = max(dp[-1])
return ans
print((solve())) | p03162 |
n = int(eval(input()))
l = [list(map(int, input().split())) for _ in range(n)]
dp = [[0,0,0] for _ in range(n)]
dp[0][0], dp[0][1], dp[0][2] = l[0][0], l[0][1], l[0][2]
for i in range(1, n):
for j in range(3):
for k in range(3):
if j != k:
dp[i][k] = max(dp[i][k], dp[i-1][j] + l[i][k])
print((max(dp[-1]))) | n = int(eval(input()))
l = [list(map(int, input().split())) for _ in range(n)]
dp = [[0,0,0] for _ in range(n)]
dp[0] = l[0]
for i in range(1, n):
for j in range(3):
for k in range(3):
if j != k:
dp[i][j] = max(dp[i][j], dp[i-1][k] + l[i][j])
print((max(dp[-1]))) | p03162 |
n = int(eval(input()))
l = [list(map(int, input().split())) for _ in range(n)]
dp = [[0,0,0] for _ in range(n)]
dp[0] = l[0]
for i in range(1, n):
for j in range(3):
for k in range(3):
if j != k:
dp[i][j] = max(dp[i][j], dp[i-1][k] + l[i][j])
print((max(dp[-1]))) | n = int(eval(input()))
abc = [[], [], []]
abc = [list(map(int, input().split())) for _ in range(n)] # DB取得方法のみ違う, 分かればどっちでもok
#print(abc)
dp = [[0,0,0] for _ in range(n)]
dp[0] = abc[0]
#print(dp)
for i in range(1, n):
for j in range(3):
for k in range(3):
if j != k:
dp[i][j] = max(dp[i][j], dp[i-1][k] + abc[i][j]) # ここのDB指定方法に影響
print((max(dp[-1]))) | p03162 |
N=int(eval(input()))
ABC=[]
for i in range(N):
l=list(map(int,input().split()))
ABC=ABC+[l]
dp=[[0,0,0] for i in range(N)]#dp[i][j]はi+1日目にアクティビティjを選んだ時の活動終了時の幸福量
for i in range(3):
dp[0][i]=ABC[0][i]
for i in range(1,N):
dp[i][1]=max(dp[i-1][2]+ABC[i][1],dp[i-1][0]+ABC[i][1])
dp[i][0]=max(dp[i-1][1]+ABC[i][0],dp[i-1][2]+ABC[i][0])
dp[i][2]=max(dp[i-1][1]+ABC[i][2],dp[i-1][0]+ABC[i][2])
ans=max(dp[N-1])
print(ans) | N=int(eval(input()))
A=[]
B=[]
C=[]
for i in range(N):
l1,l2,l3=list(map(int,input().split()))
A+=[l1]
B+=[l2]
C+=[l3]
dp=[[0,0,0] for i in range(N)]#dp[i][j]はi+1日目にアクティビティjを選んだ時の活動終了時の幸福量
dp[0][0]=A[0]
dp[0][1]=B[0]
dp[0][2]=C[0]
for i in range(1,N):
dp[i][1]=max(dp[i-1][2]+B[i],dp[i-1][0]+B[i])
dp[i][0]=max(dp[i-1][1]+A[i],dp[i-1][2]+A[i])
dp[i][2]=max(dp[i-1][1]+C[i],dp[i-1][0]+C[i])
ans=max(dp[N-1])
print(ans) | p03162 |
n = int(eval(input()))
ls = [(0,0,0)]
for _ in range(n):
a,b,c=list(map(int, input().split()))
ls.append((a,b,c))
dpa = [0]*(n+1)
dpb = [0]*(n+1)
dpc = [0]*(n+1)
for x in range(1,n+1):
a,b,c = ls[x]
dpa[x] = max(dpc[x-1]+a,dpb[x-1]+a)
dpb[x] = max(dpa[x-1]+b,dpc[x-1]+b)
dpc[x] = max(dpa[x-1]+c,dpb[x-1]+c)
print((max(dpa[-1],dpb[-1],dpc[-1])))
| n = int(eval(input()))
ls = [(0,0,0)]
for _ in range(n):
a,b,c=list(map(int, input().split()))
ls.append((a,b,c))
dpa = 0
dpb = 0
dpc = 0
for x in range(1,n+1):
a,b,c = ls[x]
dpa, dpb, dpc = max(dpc+a,dpb+a), max(dpa+b,dpc+b), max(dpa+c,dpb+c)
print((max(dpa,dpb,dpc))) | p03162 |
#最初に置いておくもの
import sys
sys.setrecursionlimit(500000)
input=sys.stdin.readline
N=int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
inf=float('inf')
dp=[[-inf]*3 for j in range(N+1)]
dp[0][0]=0
dp[0][1]=0
dp[0][2]=0
def chmax(a,b):
return max(a,b)
def rec(n,m):
if n==0:
return 0
for i in range(3):
if (m == i):
continue
dp[n][m]=chmax(dp[n][m], rec(n-1,i) + A[n-1][m])
return dp[n][m]
re=max(rec(N,0),rec(N,1),rec(N,2))
print(re) | #最初に置いておくもの
import sys
sys.setrecursionlimit(500000)
input=sys.stdin.readline
N=int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
inf=float('inf')
dp=[[0]*3 for j in range(N+1)]
def chmax(a,b):
return max(a,b)
def rec(n,m):
if n==0:
return 0
if dp[n][m]>0:
return dp[n][m]
for i in range(3):
if (i == m):
continue
dp[n][m]=chmax(dp[n][m], rec(n-1,i) + A[n-1][m])
return dp[n][m]
re=max(rec(N,0),rec(N,1),rec(N,2))
print(re) | p03162 |
N = int(eval(input()))
a = [list(map(int,input().split())) for _ in range(N)]
dp = [[0]*3 for _ in range(100010)]
# dp[i][j] : i日目にj番目の活動をしたときの幸福度の総和
idx = [[1,2],[2,0],[0,1]]
for i in range(3):
dp[0][i] = a[0][i]
for i in range(1,N):
for j in range(3):
dp[i][j] = max(dp[i-1][idx[j][0]],dp[i-1][idx[j][1]])+a[i][j]
print((max(dp[N-1]))) | import sys
def input():
return sys.stdin.readline()[:-1]
N = int(eval(input()))
ABC = [list(map(int,input().split())) for _ in range(N)]
inf = 10**9+7
dp = [[0] * 3 for _ in range(N+10)]
dp[0] = [ABC[0][0],ABC[0][1],ABC[0][2]]
for i in range(N-1):
for j in range(3):
for k in range(3):
if j==k:continue
dp[i+1][j] = max(dp[i+1][j],dp[i][k]+ABC[i+1][j])
print((max(dp[N-1][:])))
| p03162 |
import sys
def input():
return sys.stdin.readline()[:-1]
N = int(eval(input()))
ABC = [list(map(int,input().split())) for _ in range(N)]
inf = 10**9+7
dp = [[0] * 3 for _ in range(N+10)]
dp[0] = [ABC[0][0],ABC[0][1],ABC[0][2]]
for i in range(N-1):
for j in range(3):
for k in range(3):
if j==k:continue
dp[i+1][j] = max(dp[i+1][j],dp[i][k]+ABC[i+1][j])
print((max(dp[N-1][:])))
|
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
N = int(eval(input()))
abc = [list(map(int,input().split())) for _ in range (N)]
dp = [[0]*3 for _ in range(N+10)]
for i in range(N):
for j in range(3):
for k in range(3):
if j==k:continue
dp[i+1][j] = max(dp[i+1][j], dp[i][k] + abc[i][j])
print((max(dp[N])))
| p03162 |
import sys
sys.setrecursionlimit(10 ** 6)
n = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(n)]
def recur(i, last_index, v):
if i == n:
return v
res = -1
for j in range(3):
if j == last_index:
continue
res = max(res, recur(i + 1, j, v + abc[i][j]))
return res
print((recur(0, -1, 0)))
| import sys
sys.setrecursionlimit(10 ** 6)
n = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(n)]
dp = [[0, 0, 0] for _ in range(n)]
dp[0] = abc[0]
for i in range(1, n):
dp[i][0] = abc[i][0] + max(dp[i-1][1], dp[i-1][2])
dp[i][1] = abc[i][1] + max(dp[i-1][0], dp[i-1][2])
dp[i][2] = abc[i][2] + max(dp[i-1][0], dp[i-1][1])
print((max(dp[-1])))
| p03162 |
"C Vacation"
N = int(eval(input()))
summer = []
for i in range(N):
active = list(map(int, input().split()))
summer.append(active)
dp = [[0]*3 for i in range(N+1)]
# dp = [[0, 0, 0]] * (N+1)
# print(dp)
for i in range(N):
dp[i+1][0] = max((max(dp[i][1], dp[i][2])+summer[i][0]), dp[i+1][0])
dp[i+1][1] = max((max(dp[i][0], dp[i][2])+summer[i][1]), dp[i+1][1])
dp[i+1][2] = max((max(dp[i][0], dp[i][1])+summer[i][2]), dp[i+1][2])
print((max(dp[-1])))
| N = int(eval(input()))
S = [list(map(int, input().split())) for _ in range(N)] # N日間の夏休み
dp = [[0]*3 for _ in range(N)] # i日目の状態, (幸福度の合計, 前日の遊んだ内容3種類のテーブル)
# print(S)
# print(dp)
# 初期値
dp[0][0] = (S[0][0], 'a')
dp[0][1] = (S[0][1], 'b')
dp[0][2] = (S[0][2], 'c')
# print(dp)
for i in range(1, N): # N日間の遷移
# aの予定を実行する場合
if dp[i-1][1][0]+S[i][0] > dp[i-1][2][0]+S[i][0]:
dp[i][0] = (dp[i-1][1][0]+S[i][0], 'a')
else:
dp[i][0] = (dp[i-1][2][0]+S[i][0], 'a')
# bの予定を実行する場合
if dp[i-1][0][0]+S[i][1] > dp[i-1][2][0]+S[i][1]:
dp[i][1] = (dp[i-1][0][0]+S[i][1], 'b')
else:
dp[i][1] = (dp[i-1][2][0]+S[i][1], 'b')
# cの予定を実行する場合
if dp[i-1][0][0]+S[i][2] > dp[i-1][1][0]+S[i][2]:
dp[i][2] = (dp[i-1][0][0]+S[i][2], 'c')
else:
dp[i][2] = (dp[i-1][1][0]+S[i][2], 'c')
# print(dp)
print((max(dp[N-1])[0]))
| p03162 |
days = int(eval(input()))
prev = [0, 0, 0]
while days:
nxt = [0, 0, 0]
a, b, c = list(map(int, input().split()))
nxt[0] = a + max(prev[1], prev[2])
nxt[1] = b + max(prev[0], prev[2])
nxt[2] = c + max(prev[0], prev[1])
prev = nxt
days -= 1
print((max(prev))) | import sys
# read = sys.stdin.read
input = sys.stdin.readline
# readlines = sys.stdin.readlines
days = int(eval(input()))
prev = [0, 0, 0]
while days:
nxt = [0, 0, 0]
a, b, c = list(map(int, input().split()))
nxt[0] = a + max(prev[1], prev[2])
nxt[1] = b + max(prev[0], prev[2])
nxt[2] = c + max(prev[0], prev[1])
prev = nxt
days -= 1
print((max(prev))) | p03162 |
#c
n=int(eval(input()))
N=100100
happy=[[0]*3 for i in range(N)]
dp=[[0]*3 for i in range(N)]
for i in range(1,n+1):
x,y,z=list(map(int,input().split()))
happy[i][0]=x
happy[i][1]=y
happy[i][2]=z
ans=0
for i in range(1,n+1):
for place in range(3):
for place_y in range(3):
if place==place_y:
continue
else:
dp[i][place]=max(dp[i][place],dp[i-1][place_y]+happy[i][place])
for place in range(3):
ans=max(ans,dp[n][place])
print(ans)
| n=int(eval(input()))
x=[[0]*3 for i in range(n)]
for i in range(n):
a,b,c=list(map(int,input().split()))
if i==0:
x[i][0]=a
x[i][1]=b
x[i][2]=c
else:
x[i][0]=max(x[i-1][1],x[i-1][2])+a
x[i][1]=max(x[i-1][0],x[i-1][2])+b
x[i][2]=max(x[i-1][0],x[i-1][1])+c
print((max(x[n-1]))) | p03162 |
n=int(eval(input()))
k=3
l=[]
for _ in range(n):
l.append(list(map(int,input().split())))
dp=[l[0]]
for i,s in enumerate(l):
if not i:continue
t=[t for t in dp[-1]]
d=[]
for i in range(k):
d.append(max(t[j]for j in range(k)if i!=j)+s[i])
dp.append(d)
print((max(dp[-1]))) | n=int(eval(input()))
l=[list(map(int,input().split()))for _ in[0]*n]
dp=l[0]
for i,s in enumerate(l):
if not i:continue
d=[]
for i,t in enumerate(s):
d.append(max(t for j,t in enumerate(dp)if i!=j)+t)
dp=d
print((max(dp))) | p03162 |
N=int(eval(input()))
l1=[[] for i in range(N)]
for i in range(N):
l=list(map(int,input().split()))
for j in range(len(l)):
l1[i].append(l[j])
pos=-1
f=-1
suma=0
for i in range(N):
f=i
if l1[i][0]>=l1[i][1] and l1[i][0]>=l1[i][2]:
s=l1[i][0]
# print(s)
pos=0
elif l1[i][1]>=l1[i][0] and l1[i][1]>=l1[i][2]:
s=l1[i][1]
# print(s)
pos=1
else:
s=l1[i][2]
# print(s)
pos=2
m=pos
for j in range(i-1,-1,-1):
if m==0:
if l1[j][1]>=l1[j][2]:
s=s+l1[j][1]
#print(l1[j][1])
m=1
else:
s=s+l1[j][2]
#print(l1[j][2])
m=2
elif m==1:
if l1[j][0]>=l1[j][2]:
s=s+l1[j][0]
#print(l1[j][0])
m=0
else:
s=s+l1[j][2]
#print(l1[j][2])
m=2
else:
if l1[j][0]>=l1[j][1]:
s=s+l1[j][0]
#print(l1[j][0])
m=0
else:
s=s+l1[j][1]
#print(l1[j][1])
m=1
if suma<s:
suma=s
for j in range(i+1,N):
if pos==0:
if l1[j][1]>=l1[j][2]:
s=s+l1[j][1]
#print(l1[j][1])
pos=1
else:
s=s+l1[j][2]
#print(l1[j][2])
pos=2
elif pos==1:
if l1[j][0]>=l1[j][2]:
s=s+l1[j][0]
#print(l1[j][0])
pos=0
else:
s=s+l1[j][2]
#print(l1[j][2])
pos=2
else:
if l1[j][0]>=l1[j][1]:
s=s+l1[j][0]
#print(l1[j][0])
pos=0
else:
s=s+l1[j][1]
#print(l1[j][1])
pos=1
#print(s)
if suma<s:
suma=s
print(suma)
| N=int(eval(input()))
l1=[[] for i in range(N)]
for i in range(N):
l=list(map(int,input().split()))
for j in range(len(l)):
l1[i].append(l[j])
l2=[[] for i in range(N)]
for j in l1[0]:
l2[0].append(j)
for j in range(1,N):
l2[j].append(l1[j][0]+max(l2[j-1][1],l2[j-1][2]))
l2[j].append(l1[j][1]+max(l2[j-1][0],l2[j-1][2]))
l2[j].append(l1[j][2]+max(l2[j-1][0],l2[j-1][1]))
#print(l2)
print((max(l2[N-1][0],l2[N-1][1],l2[N-1][2])))
| p03162 |
N = int(eval(input()))
dp = [[0]*3 for i in range(N)]
dp[0] = list(map(int,input().split()))
for i in range(1,N):
a,b,c = list(map(int,input().split()))
dp[i][0] = max(dp[i-1][1],dp[i-1][2]) + a
dp[i][1] = max(dp[i-1][0],dp[i-1][2]) + b
dp[i][2] = max(dp[i-1][0],dp[i-1][1]) + c
print((max(dp[N-1]))) | import sys
readline = sys.stdin.readline
N = int(readline())
dp = [[0]*3 for i in range(N)]
dp[0] = list(map(int,readline().split()))
for i in range(1,N):
a,b,c = list(map(int,readline().split()))
dp[i][0] = max(dp[i-1][1],dp[i-1][2]) + a
dp[i][1] = max(dp[i-1][0],dp[i-1][2]) + b
dp[i][2] = max(dp[i-1][0],dp[i-1][1]) + c
print((max(dp[N-1])))
| p03162 |
import sys
readline = sys.stdin.readline
N = int(readline())
dp = [[0]*3 for i in range(N)]
dp[0] = list(map(int,readline().split()))
for i in range(1,N):
a,b,c = list(map(int,readline().split()))
dp[i][0] = max(dp[i-1][1],dp[i-1][2]) + a
dp[i][1] = max(dp[i-1][0],dp[i-1][2]) + b
dp[i][2] = max(dp[i-1][0],dp[i-1][1]) + c
print((max(dp[N-1])))
| import sys
readline = sys.stdin.readline
N = int(readline())
dp = [[0,0,0] for i in range(N)]
dp[0] = list(map(int,readline().split()))
for i in range(1,N):
a,b,c = list(map(int,readline().split()))
dp[i][0] = max(dp[i-1][1],dp[i-1][2]) + a
dp[i][1] = max(dp[i-1][0],dp[i-1][2]) + b
dp[i][2] = max(dp[i-1][0],dp[i-1][1]) + c
print((max(dp[N-1])))
| p03162 |
import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n = int(input().rstrip('\n'))
dp = [[0] * 3 for _ in range(n)]
for i in range(n):
a, b, c = list(map(int, input().rstrip('\n').split()))
if i == 0:
dp[i][0] = a
dp[i][1] = b
dp[i][2] = c
else:
dp[i][0] = max(dp[i-1][1] + a, dp[i-1][2] + a)
dp[i][0] = max(dp[i-1][1] + a, dp[i-1][2] + a)
dp[i][1] = max(dp[i-1][0] + b, dp[i-1][2] + b)
dp[i][1] = max(dp[i-1][0] + b, dp[i-1][2] + b)
dp[i][2] = max(dp[i-1][0] + c, dp[i-1][1] + c)
dp[i][2] = max(dp[i-1][0] + c, dp[i-1][1] + c)
print((max(dp[-1])))
if __name__ == '__main__':
solve()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n = int(readline())
dp = [[0] * 3 for _ in range(n)]
for i in range(n):
a, b, c = list(map(int, readline().split()))
if i == 0:
dp[i][0] = a
dp[i][1] = b
dp[i][2] = c
else:
dp[i][0] = max(dp[i-1][1] + a, dp[i-1][2] + a)
dp[i][1] = max(dp[i-1][0] + b, dp[i-1][2] + b)
dp[i][2] = max(dp[i-1][0] + c, dp[i-1][1] + c)
print((max(dp[-1])))
if __name__ == '__main__':
solve()
| p03162 |
import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n = int(readline())
dp = [[0] * 3 for _ in range(n)]
for i in range(n):
a, b, c = list(map(int, readline().split()))
if i == 0:
dp[i][0] = a
dp[i][1] = b
dp[i][2] = c
else:
dp[i][0] = max(dp[i-1][1] + a, dp[i-1][2] + a)
dp[i][1] = max(dp[i-1][0] + b, dp[i-1][2] + b)
dp[i][2] = max(dp[i-1][0] + c, dp[i-1][1] + c)
print((max(dp[-1])))
if __name__ == '__main__':
solve()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n = int(readline())
a = [0] * n
b = [0] * n
c = [0] * n
for i in range(n):
av, bv, cv = list(map(int, readline().split()))
if i == 0:
a[i] = av
b[i] = bv
c[i] = cv
else:
a[i] = max(b[i-1] + av, c[i-1] + av)
b[i] = max(a[i-1] + bv, c[i-1] + bv)
c[i] = max(a[i-1] + cv, b[i-1] + cv)
print((max(a[-1], b[-1], c[-1])))
if __name__ == '__main__':
solve()
| p03162 |
n = int(eval(input()))
days=[]
dp = [0]*3
for _ in range(n):
a = list(map(int,input().split()))
days.append(a)
for i in range(3):
dp[i]=days[0][i]
#rint(dp)
for cday in range(1,n):
pday = cday-1
t = [0]*3
for i in range(3):
max_val = dp[i]
for j in range(3):
if i!=j:
cur_val = dp[j] + days[cday][i]
if cur_val>max_val:
max_val=cur_val
t[i] = max_val
dp=t
#rint(dp)
print((max(dp)))
| n = int(eval(input()))
days = []
for _ in range(n):
temp = list(map(int,input().split()))
days.append(temp)
dp = [0]*3
for i in range(3):
dp[i]= days[0][i]
#print(dp)
for cur_day in range(1,n):
m = [0]*3
for i in range(3):
for j in range(3):
if i!=j:
m[i] = max(m[i],dp[j]+days[cur_day][i])
dp = m
# print(dp)
print((max(dp)))
| p03162 |
#import
#import math
#import numpy as np
N = int(eval(input()))
#= input()
#= map(int, input().split())
#= list(map(int, input().split()))
#= [input(), input()]
a = []
# dp[i][0]:Aを選んだ dp[i][1]:Bを選んだ dp[i][2]:Cを選んだ
dp = [[0]*3 for _ in range(N+1)]
for _ in range(N):
aa = list(map(int, input().split()))
a.append(aa)
for i in range(1, N+1):
for j in range(3):
for k in range(3):
if j != k:
dp[i][k] = max(dp[i][k], dp[i-1][j]+a[i-1][k])
print((max(dp[-1]))) | #!/usr/bin/env python3
#import
#import math
#import numpy as np
N = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(N)]
dp = [[0] * 3 for _ in range(N)]
for i in range(N):
if i == 0:
dp[i][0] = abc[i][0]
dp[i][1] = abc[i][1]
dp[i][2] = abc[i][2]
continue
for j in range(3):
for k in range(3):
if j != k:
dp[i][j] = max(dp[i][j], dp[i - 1][k] + abc[i][j])
print((max(dp[-1]))) | p03162 |
N = int(eval(input()))
src = [tuple(map(int,input().split())) for i in range(N)]
dp = [[0]*3 for i in range(N+1)]
for i in range(N):
for j in range(3):
for k in range(3):
if j==k: continue
dp[i+1][k] = max(dp[i+1][k], dp[i][j] + src[i][k])
print((max(dp[-1]))) | N = int(eval(input()))
src = [tuple(map(int,input().split())) for i in range(N)]
dp = [[0]*3 for i in range(N)]
dp[0] = src[0]
for i,(a,b,c) in enumerate(src[1:]):
dp[i+1][0] = a + max(dp[i][1], dp[i][2])
dp[i+1][1] = b + max(dp[i][2], dp[i][0])
dp[i+1][2] = c + max(dp[i][0], dp[i][1])
print((max(dp[-1]))) | p03162 |
import copy
N = int(eval(input()))
*abc, = [list(map(int, input().split())) for _ in range(N)]
dp = [[0] * 3 for _ in range(N)]
for i, l in enumerate(abc):
if i == 0:
dp[i] = copy.deepcopy(l)
else:
mx = 0
ex = [0, 1, 2]
ext = copy.deepcopy(ex)
for j, m in enumerate(l):
ext.remove(j)
mx1 = max(mx, abc[i][ext[0]] + dp[i - 1][j])
mx2 = max(mx, abc[i][ext[1]] + dp[i - 1][j])
mx = max(mx1, mx2)
ext = copy.deepcopy(ex)
dp[i][j] = mx
print((max(dp[-1]))) | N = int(eval(input()))
la, lb, lc = [0] * 3
for i in range(N):
a, b, c = [int(x) for x in input().split()]
aa = a + max(lb, lc)
bb = b + max(lc, la)
cc = c + max(lb, la)
la = aa
lb = bb
lc = cc
print((max(la, lb, lc)))
| p03162 |
def inpl(): return list(map(int, input().split()))
N = int(eval(input()))
A, B, C = [0]*N, [0]*N, [0]*N
for i in range(N):
A[i], B[i], C[i] = inpl()
DP = [[0]*3 for _ in range(N)]
DP[0] = [A[0], B[0], C[0]]
for i in range(1, N):
DP[i][0] = max(DP[i-1][1] + A[i], DP[i-1][2] + A[i])
DP[i][1] = max(DP[i-1][0] + B[i], DP[i-1][2] + B[i])
DP[i][2] = max(DP[i-1][0] + C[i], DP[i-1][1] + C[i])
print((max(DP[-1]))) | def inpl(): return list(map(int, input().split()))
N = int(eval(input()))
sa, sb, sc = 0, 0, 0
for i in range(N):
a, b, c = inpl()
sa, sb, sc = max(sb+a, sc+a), max(sa+b, sc+b), max(sa+c, sb+c)
print((max(sa, sb, sc)))
| p03162 |
n=int(eval(input()))
mat=[]
dp=[]
for i in range(n):
l=list(map(int,input().split()))
mat.append(l)
dp.append([0]*3)
dp[0][0]=mat[0][0]
dp[0][1]=mat[0][1]
dp[0][2]=mat[0][2]
for i in range(1,n):
dp[i][0]=max(dp[i-1][1], dp[i-1][2])+mat[i][0]
dp[i][1]=max(dp[i-1][0], dp[i-1][2])+mat[i][1]
dp[i][2]=max(dp[i-1][0], dp[i-1][1])+mat[i][2]
print((max(dp[n-1][0], dp[n-1][1], dp[n-1][2])))
| n=int(eval(input()))
mat=[]
dp=[]
for i in range(n):
l=list(map(int,input().split()))
mat.append(l)
dp.append([0]*3)
dp[0][0]=mat[0][0]
dp[0][1]=mat[0][1]
dp[0][2]=mat[0][2]
for i in range(1,n):
dp[i][0]=max(dp[i-1][1],dp[i-1][2])+mat[i][0]
dp[i][1]=max(dp[i-1][0],dp[i-1][2])+mat[i][1]
dp[i][2]=max(dp[i-1][0],dp[i-1][1])+mat[i][2]
print((max(dp[n-1]))) | p03162 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
a=[[0],[0],[0]]
n = int(eval(input()))
for i in range(n):
A,B,C = list(map(int,input().split()))
a[0].append(A)
a[1].append(B)
a[2].append(C)
dp = []
for j in range(n+1):
dp.append([0,0,0])
dp[1][0] = a[0][1]
dp[1][1] = a[1][1]
dp[1][2] = a[2][1]
for i in range(2,n+1):
for j in range(3):
x = dp[i-1][(j+1)%3]+a[j][i]
y = dp[i-1][(j+2)%3]+a[j][i]
dp[i][j] = max(x,y)
print((max(dp[n][0],dp[n][1],dp[n][2])))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
a,b,c = 0,0,0
n = int(eval(input()))
for i in range(n):
x,y,z = list(map(int,input().split()))
a,b,c = max(b,c)+x,max(a,c)+y,max(a,b)+z
print((max(a,b,c)))
| p03162 |
from functools import lru_cache
n = int(eval(input()))
action = []
for i in range(n):
action.append(list(map(int,input().split())))
@lru_cache(maxsize=1000000)
def dp(i, a):
if i == 0:
return action[0][a]
else:
return max(dp(i-1, (a+1)%3), dp(i-1, (a+2)%3)) + action[i][a]
import sys
sys.setrecursionlimit(1000000)
print((max([dp(n-1,a) for a in range(3)])))
| from functools import lru_cache
n = int(eval(input()))
action = []
for i in range(n):
action.append(list(map(int,input().split())))
@lru_cache(maxsize=None)
def dp(i, a):
if i == 0:
return action[0][a]
else:
return max(dp(i-1, (a+1)%3), dp(i-1, (a+2)%3)) + action[i][a]
import sys
sys.setrecursionlimit(1000000)
print((max([dp(n-1,a) for a in range(3)])))
| p03162 |
def main():
n = int(eval(input()))
abc = [list(map(int,input().split())) for i in range(n)]
dp = [[0] * 3 for _ in range(n)]
dp[0][0] = abc[0][0]
dp[0][1] = abc[0][1]
dp[0][2] = abc[0][2]
for i in range(n-1):
today = dp[i]
tomorrow = abc[i+1]
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i+1][j] = max(dp[i+1][j], today[k] + tomorrow[j])
print((max(dp[n-1])))
if __name__ == "__main__":
main() | def main():
n = int(eval(input()))
abc = [list(map(int,input().split())) for i in range(n)]
dp = [[0] * 3 for _ in range(n)]
dp[0][0] = abc[0][0]
dp[0][1] = abc[0][1]
dp[0][2] = abc[0][2]
for i in range(n-1):
for j in range(3):
dp[i+1][j] = max(dp[i][(j+1) % 3], dp[i][(j+2) % 3]) + abc[i+1][j]
print((max(dp[n-1])))
if __name__ == "__main__":
main() | p03162 |
from sys import stdin,stdout,setrecursionlimit
from collections import Counter as C
setrecursionlimit(10**6)
M = 1000000007
input = stdin.readline
def write(n,sep="\n"):
stdout.write(str(n))
stdout.write(sep)
def gil():
return list(map(int, input().split()))
n = int(eval(input()))
a, b, c = [], [], []
for i in range(n):
x,y,z = gil()
a.append(x)
b.append(y)
c.append(z)
mem = {}
def rp(i, p, h):
global a,b,c,n
if i >= n:
return h
av = [rp(i+1, 0, h+a[i]), rp(i+1, 1, h+b[i]), rp(i+1, 2, h+c[i])]
if p != -1:
av[p] = 0
ans = max(av)
return ans
ans = rp(0, -1, 0)
print(ans)
| from sys import stdin,stdout,setrecursionlimit
from collections import Counter as C
setrecursionlimit(10**6)
M = 1000000007
input = stdin.readline
def write(n,sep="\n"):
stdout.write(str(n))
stdout.write(sep)
def gil():
return list(map(int, input().split()))
n = int(eval(input()))
a, b, c = [], [], []
for i in range(n):
x,y,z = gil()
a.append(x)
b.append(y)
c.append(z)
mem = [[-1 for _ in range(3)] for _ in range(n+1)]
def rp(i, p):
global a,b,c,n
if i >= n:
return 0
if mem[i][p] != -1:
return mem[i][p]
av = [a[i] + rp(i+1, 0), b[i] + rp(i+1, 1), c[i] + rp(i+1, 2)]
if p != -1:
av[p] = 0
ans = max(av)
mem[i][p] = ans
return ans
ans = rp(0, -1)
print(ans)
# on recursive mem sols, build the solution from the base case,
# ie, return 0 on basecase, and build up the solution.
# maybe because the values that come later on decide more on what you choose?
| p03162 |
from sys import stdin,stdout,setrecursionlimit
from collections import Counter as C
setrecursionlimit(10**6)
M = 1000000007
input = stdin.readline
def write(n,sep="\n"):
stdout.write(str(n))
stdout.write(sep)
def gil():
return list(map(int, input().split()))
n = int(eval(input()))
a, b, c = [], [], []
for i in range(n):
x,y,z = gil()
a.append(x)
b.append(y)
c.append(z)
mem = [[-1 for _ in range(3)] for _ in range(n+1)]
def rp(i, p):
global a,b,c,n
if i >= n:
return 0
if mem[i][p] != -1:
return mem[i][p]
av = [a[i] + rp(i+1, 0), b[i] + rp(i+1, 1), c[i] + rp(i+1, 2)]
if p != -1:
av[p] = 0
ans = max(av)
mem[i][p] = ans
return ans
ans = rp(0, -1)
print(ans)
# on recursive mem sols, build the solution from the base case,
# ie, return 0 on basecase, and build up the solution.
# because state-cases below will not carry values from above, they only take values from below
| from sys import stdin,stdout,setrecursionlimit
from collections import Counter as C
setrecursionlimit(10**6)
M = 1000000007
input = stdin.readline
def write(n,sep="\n"):
stdout.write(str(n))
stdout.write(sep)
def gil():
return list(map(int, input().split()))
n = int(eval(input()))
d = []
for i in range(n):
d.append(gil())
dp = [[0,0,0]]
for dz in range(n):
ndp = [0] * 3
for i in range(3):
for j in range(3):
if i != j:
ndp[i] = max(ndp[i], dp[dz][j] + d[dz][i])
dp.append(ndp)
#print(dp)
print((max(dp[-1])))
# tabular approach
| p03162 |
N=int(eval(input()))
H=[[0,0,0]]+[ list(map(int, input().split())) for _ in range(N) ]
#print(N,H)
def chmax(dp, n, k, a):
b = (dp[n][k]<a)
if b: dp[n][k]=a
return b
#dp=[[0,0,0,0,0,0] for _ in range(N+1)]
dp=[[0,0,0] for _ in range(N+1)]
for i in range(1,N+1):
for j in range(3):
for k in range(3):
if j==k: continue
chmax(dp,i,k, dp[i-1][j] + H[i][k])
print(( max(dp[N]) ))
| INF = float("inf") # 正の無限大
N = int(eval(input())) # 5
A=[0]*N
B=[0]*N
C=[0]*N
for i in range(N):
a,b,c = list(map(int, input().split())) # 5 7 2
A[i] = a
B[i] = b
C[i] = c
dp = [[0,0,0] for _ in range(N)]
for i in range(N):
dp[i][0] = A[i] + (max(dp[i-1][1], dp[i-1][2]) if i>0 else 0)
dp[i][1] = B[i] + (max(dp[i-1][2], dp[i-1][0]) if i>0 else 0)
dp[i][2] = C[i] + (max(dp[i-1][0], dp[i-1][1]) if i>0 else 0)
print(( max(dp[-1][0], dp[-1][1], dp[-1][2]) ))
#print(dp)
| p03162 |
N = int(eval(input()))
plans = [list(map(int, input().split())) for _ in range(N)]
dp = [[0] * (3) for _ in range(N+1)]
def chmax(a, b):
if a >= b:
return a
else:
return b
for i in range(N):
for j in range(3):
for k in range(3):
if j == k:
continue
else:
dp[i+1][k] = chmax(dp[i+1][k], dp[i][j] + plans[i][k])
res = 0
for j in range(3):
res = chmax(res, dp[-1][j])
print(res) | N = int(eval(input()))
h = [list(map(int, input().split())) for _ in range(N)] #1-index
def chmax(a,b):
if a >= b:
return a
else:
return b
dp = [[0]*(3) for _ in range(N+2)]
for i in range(N):
for j in range(3):
for k in range(3):
if (j == k): continue
dp[i+1][k] = chmax(dp[i+1][k], dp[i][j] + h[i][k])
print((max(dp[N]))) | p03162 |
n = int(eval(input()))
a = [[int(i) for i in input().split()] for j in range(n)]
def happy(n, a):
d = [[0] * 3 for j in range(n)]
for i in range(3):
d[0][i] = a[0][i]
for i in range(1, n):
d[i][0] = max(d[i - 1][1], d[i - 1][2]) + a[i][0]
d[i][1] = max(d[i - 1][0], d[i - 1][2]) + a[i][1]
d[i][2] = max(d[i - 1][0], d[i - 1][1]) + a[i][2]
return max(d[n - 1])
print((happy(n, a)))
| import sys
input = sys.stdin.readline
n = int(eval(input()))
abc = [[int(i) for i in input().split()] for j in range(n)]
def happy(n, abc):
da, db, dc = 0, 0, 0
for a, b, c in abc:
na = max(db, dc) + a
nb = max(dc, da) + b
nc = max(da, db) + c
da, db, dc = na, nb, nc
return max(da, db, dc)
print((happy(n, abc)))
| p03162 |
n = int(eval(input()))
INF = 1 << 20
dp = [[INF] * (n + 1) for _ in range(3)]
# dp初期化
for i in range(3):
dp[i][-1] = 0
for i in range(n):
a, b, c = list(map(int, input().split()))
dp[0][i] = max(dp[1][i - 1], dp[2][i - 1]) + a
dp[1][i] = max(dp[2][i - 1], dp[0][i - 1]) + b
dp[2][i] = max(dp[0][i - 1], dp[1][i - 1]) + c
print((max(list(zip(*dp))[n - 1]))) | n = int(eval(input()))
INF = 1 << 60
dp = [[INF] * n + [0] for _ in range(3)]
# 直前の行動と次の行動だけシミュレーションすればよい
for i in range(n):
a, b, c = list(map(int, input().split()))
dp[0][i] = max(dp[1][i - 1], dp[2][i - 1]) + a
dp[1][i] = max(dp[2][i - 1], dp[0][i - 1]) + b
dp[2][i] = max(dp[0][i - 1], dp[1][i - 1]) + c
print((max(list(zip(*dp))[n - 1]))) | p03162 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations
#from itertools import accumulate, product
from bisect import bisect_left,bisect_right
from math import floor, ceil
#from operator import itemgetter
#mod = 1000000007
N = int(eval(input()))
l = [list(map(int, input().split())) for _ in range(N)]
dp = [[0]*3 for _ in range(N+1)]
dp[1] = l[0]
for i in range(1, N):
for j in range(3):
a = (j+1)%3
b = (j+2)%3
dp[i+1][j] = max(dp[i][a], dp[i][b]) + l[i][j]
print((max(dp[N])))
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
n = int(eval(input()))
a = [0]*n
b = [0]*n
c = [0]*n
for i in range(n):
a[i],b[i],c[i] = list(map(int,input().split()))
dpa = [a[0]]+[0]*(n-1)
dpb = [b[0]]+[0]*(n-1)
dpc = [c[0]]+[0]*(n-1)
for i in range(1,n):
dpa[i] = max(dpb[i-1],dpc[i-1]) + a[i]
dpb[i] = max(dpc[i-1],dpa[i-1]) + b[i]
dpc[i] = max(dpa[i-1],dpb[i-1]) + c[i]
print((max(dpa[-1],dpb[-1],dpc[-1]))) | p03162 |
def main():
N = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(N)]
DP = [[0, 0, 0] for _ in range(N)]
DP[0] = abc[0]
for i in range(1, N):
for j in range(3):
tmp = [abc[i][j] + DP[i-1][k] for k in range(3) if k != j]
DP[i][j] = max(tmp)
print((max(DP[-1])))
main()
| def main():
N = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(N)]
DP = [[0, 0, 0] for _ in range(N)]
DP[0] = abc[0]
for i in range(1, N):
for j in range(3):
tmp = [abc[i][j] + DP[i-1][k] for k in range(3) if k != j]
DP[i][j] = max(tmp)
print((max(DP[-1])))
if __name__ == '__main__':
main() | p03162 |
N = int(eval(input()))
abc = [[int(i) for i in input().split()] for i in range(N)]
for i in range(1,N):
for g in range(3):
abc[i][g] += max(abc[i-1][g-1], abc[i-1][g-2])
print((max(abc[-1]))) | n=int(eval(input()))
abc=[list(map(int,input().split())) for _ in range(n)]
for i in range(1,n):
abc[i][0]=abc[i][0]+max(abc[i-1][1],abc[i-1][2])
abc[i][1]=abc[i][1]+max(abc[i-1][0],abc[i-1][2])
abc[i][2]=abc[i][2]+max(abc[i-1][0],abc[i-1][1])
print((max(abc[-1]))) | p03162 |
N = int(eval(input()))
L = []
for i in range(N) :
L.append(list(map(int,input().split())))
dp = [[0,0,0] for i in range(N+1)]
for i in range(N) :
for j in range(3) :
for k in range(3) :
if j == k :
continue
dp[i+1][k] = max(dp[i+1][k], dp[i][j] + L[i][k])
print((max(dp[-1])))
| N = int(eval(input()))
L = [list(map(int,input().split())) for i in range(N)]
NOW = [0,0,0]
NEXT = [None,None,None]
for i in range(N) :
NEXT[0] = max(NOW[1],NOW[2]) + L[i][0]
NEXT[1] = max(NOW[2],NOW[0]) + L[i][1]
NEXT[2] = max(NOW[0],NOW[1]) + L[i][2]
NOW = NEXT.copy()
print((max(NOW)))
| p03162 |
N = int(eval(input()))
A = [list(map(int,input().split())) for _ in range(N)]
dp = [[0]*3 for _ in range(N+1)]
for i in range(N):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i+1][k] = max(dp[i+1][k], dp[i][j]+A[i][k])
print((max(dp[N]))) | N = int(eval(input()))
A = [list(map(int,input().split())) for _ in range(N)]
x = y = z = 0
for a,b,c in A:
x,y,z = max(y,z)+a,max(x,z)+b,max(x,y)+c
print((max(x,y,z))) | p03162 |
N = int(eval(input()))
A = [[int(i) for i in input().split()] for _ in range(N)]
x = y = z = 0
for a, b, c in A:
x, y, z = max(y, z)+a, max(x,z)+b, max(x,y)+c
print((max(x, y, z))) | N = int(eval(input()))
x = y = z = 0
for _ in range(N):
a, b, c = list(map(int,input().split()))
x, y, z = max(y, z)+a, max(x,z)+b, max(x,y)+c
print((max(x, y, z))) | p03162 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.