input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
# ===================================
# (c) MidAndFeed aka ASilentVoice
# ===================================
# import math
# import collections
# import string
# ===================================
n = int(eval(input()))
q = [int(x) for x in input().split()]
ans = [None for _ in range(n)]
ans[0] = 0
# # Top down
# def dp(current):
# if ans[current] != None: return ans[current]
# if current < 0: return 0
# else:
# t1 = t2 = int(1e9)
# if current-1 >= 0: t1 = abs(q[current] - q[current-1]) + dp(current-1)
# if current-2 >= 0: t2 = abs(q[current] - q[current-2]) + dp(current-2)
# ans[current] = min(t1, t2)
# return ans[current]
# dp(n-1)
for i in range(1, n):
t1 = t2 = int(1e9)
if i-1 >= 0: t1 = ans[i-1] + abs(q[i-1] - q[i])
if i-2 >= 0: t2 = ans[i-2] + abs(q[i-2] - q[i])
ans[i] = min(t1, t2)
# print(ans)
print((ans[n-1]))
| # ===================================
# (c) MidAndFeed aka ASilentVoice
# ===================================
# import math
# import collections
# import string
# ===================================
n = int(eval(input()))
q = [int(x) for x in input().split()]
ans = [None for _ in range(n)]
ans[0] = 0
for i in range(1, n):
t1 = t2 = int(1e9)
if i-1 >= 0: t1 = ans[i-1] + abs(q[i-1] - q[i])
if i-2 >= 0: t2 = ans[i-2] + abs(q[i-2] - q[i])
ans[i] = min(t1, t2)
print((ans[n-1]))
| p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [0, abs(h[1] - h[0])]
for i in range(n - 2):
a = dp[i] + abs(h[i + 2] - h[i])
b = dp[i + 1] + abs(h[i + 2] - h[i + 1])
dp.append(min(a, b))
print((dp[-1])) | n = int(eval(input()))
h = list(map(int, input().split()))
dp = [0, abs(h[1] - h[0])]
for i in range(n - 2):
dp.append(min(dp[i] + abs(h[i + 2] - h[i]), dp[i + 1] + abs(h[i + 2] - h[i + 1])))
print((dp[-1])) | p03160 |
N = int(input())
h_str = input()
h = []
for h_i in h_str.split(" "):
h.append(int(h_i))
dp = [10 ** 9 + 1] * N
dp[0] = 0
for i in range(N):
for j in (i + 1, i + 2):
if j < N:
dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]))
print((dp[N-1])) | N = int(input())
h = list(map(int, input().split()))
dp = [10 ** 9 + 1] * N
dp[0] = 0
for i in range(N):
for j in (i + 1, i + 2):
if j < N:
dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]))
print((dp[N-1])) | p03160 |
# coding: utf-8
def dp_flog(N, lst):
lst_cost = [0] * N
for i in range(N):
if i==0:
lst_cost[i]=0
elif i==1:
lst_cost[i] = abs(lst[0] - lst[1])
else:
lst_cost[i] = min(lst_cost[i-2] + abs(lst[i-2] - lst[i]), lst_cost[i-1] + abs(lst[i-1] - lst[i]))
return lst_cost
N = int(eval(input()))
lst_flog = list(map(int, input().split()))
print((dp_flog(N, lst_flog)[N-1])) | # coding: utf-8
def dp_flog(N, lst):
lst_cost = [0] * N
lst_cost[1] = abs(lst[0] - lst[1])
for i in range(2, N):
lst_cost[i] = min(lst_cost[i-2] + abs(lst[i-2] - lst[i]), lst_cost[i-1] + abs(lst[i-1] - lst[i]))
return lst_cost
N = int(eval(input()))
lst_flog = list(map(int, input().split()))
print((dp_flog(N, lst_flog)[N-1])) | p03160 |
# coding: utf-8
n = int(eval(input()))
h = list(map(int, input().split()))
inf = pow(10, 10)
# current_shortests = [0] + [inf] * (n-1)
in_processing = [0] # node-number
in_processing_len = [0]
shortest_fixed = [] # node-number
shortest_fixed_len = []
def argmin(l):
output = 0
for i in range(len(l)):
if l[i] < l[output]:
output = i
return output
def search(l, v):
for i in range(len(l)):
if l[i] == v:
return i
def fun():
k = argmin(in_processing_len)
node = in_processing[k]
while node != n-1:
# print("---------")
# print(in_processing)
# print(in_processing_len)
# print(shortest_fixed)
# print(shortest_fixed_len)
# print(k)
# print(node)
# print("---------")
# if node == n-1:
# return in_processing_len[k]
shortest_fixed.append(node)
shortest_fixed_len.append(in_processing_len[k])
del in_processing[k]
del in_processing_len[k]
if node+1 < n and node+1 not in shortest_fixed:
if node+1 not in in_processing:
in_processing.append(node+1)
in_processing_len.append(
shortest_fixed_len[-1] + abs(h[node+1] - h[node]))
else:
idx = search(in_processing, node+1)
if in_processing_len[idx] > shortest_fixed_len[-1] + abs(h[node+1] - h[node]):
in_processing_len[idx] = shortest_fixed_len[-1] + abs(h[node+1] - h[node])
if node+2 < n and node+2 not in shortest_fixed:
if node+2 not in in_processing:
in_processing.append(node+2)
in_processing_len.append(
shortest_fixed_len[-1] + abs(h[node+2] - h[node]))
else:
idx = search(in_processing, node+2)
if in_processing_len[idx] > shortest_fixed_len[-1] + abs(h[node+2] - h[node]):
in_processing_len[idx] = shortest_fixed_len[-1] + abs(h[node+2] - h[node])
k = argmin(in_processing_len)
node = in_processing[k]
return in_processing_len[k]
print((fun()))
| # coding: utf-8
"""
20191116
"""
N = int(eval(input()))
h = list(map(int, input().split()))
cost = [0, abs(h[1]-h[0])] + [None for _ in range(N-2)]
for i in range(2, N):
cost[i] = min(cost[i-1] + abs(h[i]-h[i-1]), cost[i-2] + abs(h[i]-h[i-2]))
print((cost[N-1]))
| p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
h.append(9999)
dp = [[0]*(n+1) for _ in range(n)]
def do_dp():
for i in range(1,n):
for j in range(n-1):
#print("i:{} j:{}".format(i, j))
if dp[i][j+1] == 0:
dp[i][j+1] = dp[i-1][j] + abs(h[j] - h[j+1])
else:
dp[i][j+1] = min(dp[i][j+1],dp[i-1][j] + abs(h[j] - h[j+1]))
if dp[i][j+2] == 0:
dp[i][j+2] = dp[i-1][j] + abs(h[j] - h[j+2])
else:
dp[i][j+2] = min(dp[i][j+2],dp[i-1][j] + abs(h[j] - h[j+2]))
#print(dp)
return dp[n-1][n-1]
r = do_dp()
print(r) | n = int(eval(input()))
h = list(map(int, input().split()))
dp=[0] * n
for i in range(1, n):
if i - 2 < 0:
dp[i] = dp[i-1] + abs(h[i] - h[i-1])
else:
dp[i] = min(dp[i-2]+abs(h[i] - h[i-2]) ,dp[i-1]+abs(h[i]-h[i-1]) )
print((dp[n-1])) | p03160 |
def main():
n = int(eval(input()))
h = list(map(int,input().split()))
dp = [0] * n
dp[1] = abs(h[0]-h[1])
for i in range(2, n):
dp[i] = min(dp[i-1] + abs(h[i] - h[i-1]), dp[i-2] + abs(h[i]-h[i-2]))
print((dp[n-1]))
if __name__ == '__main__':
main() | def main():
n = int(eval(input()))
h = tuple(map(int, input().split()))
dp = [0] * n
dp[1] = abs(h[0] - h[1])
for i1 in range(2, n):
dp[i1] = min(dp[i1-2]+abs(h[i1]-h[i1-2]),dp[i1-1]+abs(h[i1]-h[i1-1]))
print((dp[n - 1]))
if __name__ == '__main__':
main()
| p03160 |
n = int(eval(input()))
dat_n = list(map(int, input().split()))
dp = [0] * n
dp [0]
for i in range(1, n):
if i > 1:
dp[i] = min(dp[i - 1] + abs(dat_n[i] - dat_n[i-1]),dp[i - 2] + abs(dat_n[i] - dat_n[i-2]) )
else:
dp[i] = dp[i - 1] + abs(dat_n[i] - dat_n[i-1])
print((dp[n-1]))
| n = int(eval(input()))
dat = list(map(int, input().split()))
inf = 10**10
dp = [inf] * (n + 10)
dp[0] = 0
for i in range(n):
if i+1 > n-1:
continue
dp[i+1] = min(dp[i+1], dp[i] + abs(dat[i] - dat[i+1]))
if i+2 > n-1:
continue
dp[i+2] = min(dp[i+2], dp[i] + abs(dat[i] - dat[i+2]))
print((dp[n-1]))
| p03160 |
import sys
sys.setrecursionlimit(10**5-10)
N = int(eval(input()))
h = list(map(int,input().split()))
memo = [-1]*N
def func(i):
# メモのロード
if memo[i]!=-1:
return memo[i]
# 初期値の部分
if i==0:
return 0
elif i==1:
return abs(h[1]-h[0])
# 二択の部分
a = func(i-1)+abs(h[i]-h[i-1])
b = func(i-2)+abs(h[i]-h[i-2])
memo[i] = min(a,b) # メモのセーブ
return memo[i]
print((func(N-1)))
| N = int(eval(input()))
h = list(map(int,input().split()))
dp = [-1]*N
dp[0] = 0
dp[1] = abs(h[1]-h[0])
for i in range(2,N):
a = dp[i-1]+abs(h[i]-h[i-1])
b = dp[i-2]+abs(h[i]-h[i-2])
dp[i] = min(a,b)
print((dp[N-1]))
| p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
# dp[i][j]: 足場iまで見た時 jまでの最小コスト
dp = [[0 for j in range(n)] for i in range(n)]
dp[1][1] = abs(h[1] - h[0])
for i in range(n):
if i == 0 or i == 1:
continue
dp[i] = dp[i - 1]
cost1jump = dp[i - 1][i - 1] + abs(h[i] - h[i - 1])
cost2jump = dp[i - 1][i - 2] + abs(h[i] - h[i - 2])
dp[i][i] = min(cost1jump, cost2jump)
print((dp[-1][-1]))
| n = int(eval(input()))
h = list(map(int, input().split()))
# dp[i][j]: 足場iまで見た時 jまでの最小コスト
dp = [0 for i in range(n)]
dp[1] = abs(h[1] - h[0])
for i in range(n):
if i == 0 or i == 1:
continue
cost1jump = dp[i - 1] + abs(h[i] - h[i - 1])
cost2jump = dp[i - 2] + abs(h[i] - h[i - 2])
dp[i] = min(cost1jump, cost2jump)
print((dp[-1]))
| p03160 |
# EduDPA - Frog 1
n = int(eval(input()))
lst = list(map(int, input().rstrip().split()))
ans = [0] + [float("inf")] * (n - 1)
for i in range(1, n):
ans[i] = min(ans[i], ans[i - 1] + abs(lst[i] - lst[i - 1]))
if i == 1:
continue
ans[i] = min(ans[i], ans[i - 2] + abs(lst[i] - lst[i - 2]))
print((ans[-1])) | # EduDPA - Frog 1
n = int(eval(input()))
lst = list(map(int, input().rstrip().split()))
ans = [0, abs(lst[0] - lst[1])] + [float("inf")] * (n - 2)
for i in range(2, n):
ans[i] = min(ans[i], ans[i - 1] + abs(lst[i] - lst[i - 1]))
ans[i] = min(ans[i], ans[i - 2] + abs(lst[i] - lst[i - 2]))
print((ans[-1])) | p03160 |
# EduDPA - Frog 1
def main():
n = int(eval(input()))
A = tuple(map(int, input().rstrip().split()))
dp = [0, abs(A[1] - A[0])] + [float("inf")] * (n - 2)
for i in range(2, n):
dif1 = dp[i - 2] + abs(A[i] - A[i - 2])
dif2 = dp[i - 1] + abs(A[i] - A[i - 1])
dp[i] = min(dif1, dif2)
print((dp[-1]))
if __name__ == "__main__":
main() | # dpA - Frog 1
def main():
n = int(eval(input()))
A = tuple(map(int, input().rstrip().split()))
x, y = 0, abs(A[1] - A[0])
for i in range(2, n):
dif1 = x + abs(A[i] - A[i - 2])
dif2 = y + abs(A[i] - A[i - 1])
x, y = y, min(dif1, dif2)
print(y)
if __name__ == "__main__":
main() | p03160 |
# dpA - Frog 1
def main():
n = int(eval(input()))
A = tuple(map(int, input().rstrip().split()))
x, y = 0, abs(A[1] - A[0])
for i in range(2, n):
dif1 = x + abs(A[i] - A[i - 2])
dif2 = y + abs(A[i] - A[i - 1])
x, y = y, min(dif1, dif2)
print(y)
if __name__ == "__main__":
main() | # dpA - Frog 1
"""
Example:
x y
x y
x y ...
x y (y: answer)
"""
def main():
n = int(eval(input()))
A = tuple(map(int, input().split()))
x, y = 0, abs(A[1] - A[0])
for i in range(2, n):
dif1 = x + abs(A[i] - A[i - 2])
dif2 = y + abs(A[i] - A[i - 1])
x = y
y = dif1 if dif1 <= dif2 else dif2
print(y)
if __name__ == "__main__":
main() | p03160 |
# A - Frog 1
from collections import defaultdict
def main():
N, *H = list(map(int, open(0).read().split()))
H = [0] + H + [0, 0]
dp = defaultdict(lambda: 1 << 30)
dp[1] = 0
for i, a in enumerate(H[1:N + 1], 1):
for j, b in enumerate(H[i + 1:i + 3], i + 1):
dp[j] = min(dp[j], dp[i] + abs(a - b))
print((dp[N]))
if __name__ == "__main__":
main()
| # A - Frog 1
def main():
N, *H = list(map(int, open(0).read().split()))
H = [0] + H + [0, 0]
dp = [1 << 30] * (N + 3)
dp[1] = 0
for i, a in enumerate(H[1:N + 1], 1):
for j, b in enumerate(H[i + 1:i + 3], i + 1):
dp[j] = min(dp[j], dp[i] + abs(a - b))
print((dp[N]))
if __name__ == "__main__":
main()
| p03160 |
N = int(eval(input()))
h = list(map(int,input().split()))
dp = [float('inf') for i in range(N)]
dp[0] = 0
for i in range(N-1):
dp[i+1] = min(dp[i+1],dp[i] + abs(h[i+1]-h[i]))
if i < N-2:
dp[i+2] = min(dp[i+2],dp[i] + abs(h[i+2]-h[i]))
print((dp[N-1]))
| N = int(eval(input()))
A = list(map(int,input().split()))
ans = [float('inf')]*N
ans[0] = 0
ans[1] = abs(A[0]-A[1])
for i in range(2,N):
ans[i] = min(ans[i-1]+abs(A[i]-A[i-1]), ans[i-2]+abs(A[i]-A[i-2]))
print((ans[N-1])) | p03160 |
n = int(eval(input()))
hl = list(map(int, input().split()))
cost = [0] * n
cost[0] = 0
cost[1] = abs(hl[0] - hl[1])
for i in range(2, n):
cost[i] = (min(cost[i-1] + abs(hl[i] - hl[i-1]),
(cost[i-2] + abs(hl[i] - hl[i-2]))))
print((cost[-1])) | n = int(eval(input()))
h = list(map(int, input().split()))
cost = [1001001001] * n
cost[0] = 0
cost[1] = abs(h[1] - h[0])
for i in range(2, n):
cost[i] = min((cost[i-2] + abs(h[i] - h[i-2])),
cost[i-1] + abs(h[i] - h[i-1]))
print((cost[-1])) | p03160 |
def main():
n = int(eval(input()))
h = [int(i) for i in input().split()]
cost = [0 for _ in range(n)]
cost[0] = 0
cost[1] = abs(h[1] - h[0])
for i in range(2, n):
cost[i] = min(cost[i-1]+abs(h[i] - h[i-1]), cost[i-2]+abs(h[i] - h[i-2]))
print((cost[-1]))
main()
| def main():
n = int(eval(input()))
h = tuple(map(int, input().split()))
cost = [0 for _ in range(n)]
cost[0] = 0
cost[1] = abs(h[1] - h[0])
for i in range(2, n):
cost[i] = min(cost[i-1]+abs(h[i] - h[i-1]), cost[i-2]+abs(h[i] - h[i-2]))
print((cost[-1]))
main()
| p03160 |
n = int(eval(input()))
H = [int(h)for h in input().split()]
A = [0]*n
A[0] = 0
A[1] = abs(H[1]-H[0])
for i in range(2, n):
A[i] = min(A[i-1]+abs(H[i]-H[i-1]), A[i-2]+abs(H[i]-H[i-2]))
print((A.pop()))
| n = int(eval(input()))
H = list(map(int, input().split()))
C = [0]*(n)
for i in range(1, n):
if i == 1:
C[i] = abs(H[i]-H[i-1])
else:
C[i] = min(C[i-1]+abs(H[i]-H[i-1]), C[i-2]+abs(H[i]-H[i-2]))
print((C.pop())) | p03160 |
n = int(eval(input()))
H = list(map(int, input().split()))
C = [0]*(n)
for i in range(1, n):
if i == 1:
C[i] = abs(H[i]-H[i-1])
else:
C[i] = min(C[i-1]+abs(H[i]-H[i-1]), C[i-2]+abs(H[i]-H[i-2]))
print((C.pop())) | n = int(eval(input()))
H = [0]+list(map(int, input().split()))
dp = [0]*(n+1)
dp[2] = abs(H[2]-H[1])
for i in range(3, n+1):
dp[i] = min(dp[i-1]+abs(H[i]-H[i-1]), dp[i-2]+abs(H[i]-H[i-2]))
print((dp[-1])) | p03160 |
from sys import stdin
input=stdin.readline
n=int(eval(input()))
cost=[0 for i in range(n)]
s=list(map(int,input().split()))
cost[1]=abs(s[1]-s[0])
for i in range(2,n):
cost[i]=min(cost[i-1]+abs(s[i]-s[i-1]),cost[i-2]+abs(s[i]-s[i-2]))
print((cost[-1]))
| n=int(eval(input()))
cost=[0 for i in range(n)]
s=list(map(int,input().split()))
cost[1]=abs(s[1]-s[0])
for i in range(2,n):
cost[i]=min(cost[i-1]+abs(s[i]-s[i-1]),cost[i-2]+abs(s[i]-s[i-2]))
print((cost[-1]))
| p03160 |
n = int(eval(input()))
*h, = list(map(int, input().split()))
dp = [float('inf')] * n
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(2, n):
dp[i] = min(dp[i-1] + abs(h[i]-h[i-1]), dp[i-2] + abs(h[i]-h[i-2]))
print((dp[n-1])) | import sys
input = sys.stdin.readline
n = int(eval(input()))
*h, = list(map(int, input().split()))
dp = [0]*n
dp[1] = abs(h[1]-h[0])
for i in range(2, n):
dp[i] = min(abs(h[i]-h[i-1])+dp[i-1], abs(h[i]-h[i-2])+dp[i-2])
print((dp[-1])) | p03160 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N = int(eval(input()))
H = [int(x) for x in input().split()]
dp = [0] * N
dp[1] = abs(H[1]-H[0])
for i in range(2,N):
dp[i] = min(dp[i-k] + abs(H[i]-H[i-k]) for k in [1,2])
answer = dp[-1]
print(answer) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,*H = list(map(int,read().split()))
dp = [0]*N
for i in range(1,N):
x = dp[i-1] + abs(H[i]-H[i-1])
if i > 1:
y = dp[i-2] + abs(H[i]-H[i-2])
if x>y: x=y
dp[i] = x
answer = dp[-1]
print(answer) | p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [10 ** 9 + 7 for i in range(100010)]
dp[0] = 0
for i in range(1,n):
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
if i > 1:
dp[i] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]))
print((dp[n-1]))
| n = int(eval(input()))
h = list(map(int, input().split()))
INF = 10 ** 12
dp = [INF] * (n+1) # 初期化
dp[0] = 0 # 初期条件
for i in range(1,n):
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
if i > 1:
dp[i] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]))
print((dp[n-1])) | p03160 |
N = int(eval(input()))
h = list(map(int,input().split()))
dp = []
for i in range(N):
dp.append(float("inf"))
for i in range(N):
if i ==0:
dp[i] = 0
else:
dp[i] = min(dp[i],dp[i-1]+abs(h[i]-h[i-1]))
if i > 1:
dp[i] = min(dp[i], dp[i-2]+abs(h[i]-h[i-2]))
print((dp[-1])) | N = int(eval(input()))
h = list(map(int,input().split()))
dp = []
for i in range(N):
dp.append(float("inf"))
dp[0] = 0
for i in range(N):
if not i+1 > N -1:
dp[i+1] = min(dp[i+1], dp[i]+abs(h[i+1]-h[i]))
if not i+2 > N -1:
dp[i+2] = min(dp[i+2], dp[i]+abs(h[i+2]-h[i]))
print((dp[-1])) | p03160 |
N = int(eval(input()))
h = list(map(int,input().split()))
dp = [0] * (N + 1)
dp[0] = 0
dp[1] = abs(h[1]-h[0])
for i in range(2,N):
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
print((dp[N-1])) | N = int(eval(input()))
H = list(map(int,input().split()))
dp = [0] * N
for i in range(1,N):
if i == 1:
dp[i] = dp[i-1] + abs(H[i] - H[i-1])
else:
dp[i] = min(dp[i-1] + abs(H[i] - H[i-1]),dp[i-2] + abs(H[i] - H[i-2]))
print((dp[-1])) | p03160 |
import sys
sys.setrecursionlimit(10**6)
def rec(i):
if i == 0:
C[i] = 0
return C[i]
elif i == 1:
C[i] = rec(i-1)+abs(H[i]-H[i-1])
return C[i]
# print(i, rec(i-1), rec(i-2))
C[i] = min(rec(i-1)+abs(H[i]-H[i-1]), rec(i-2)+abs(H[i]-H[i-2]))
return C[i]
INFTY = 10**13
N = int(eval(input()))
H = list(map(int, input().split()))
C = [INFTY for i in range(N)]
# C[0] = 0
# for i in range(N):
# if i+1 < N:
# C[i+1] = min(C[i] + abs(H[i+1]-H[i]), C[i+1])
# if i+2 < N:
# C[i+2] = min(C[i] + abs(H[i+2]-H[i]), C[i+2])
# print(C[-1])
print((rec(N-1)))
| import sys
sys.setrecursionlimit(10**6)
def rec(i):
if C[i] != INFTY:
return C[i]
if i == 0:
C[i] = 0
return C[i]
elif i == 1:
C[i] = rec(i-1)+abs(H[i]-H[i-1])
return C[i]
C[i] = min(rec(i-1)+abs(H[i]-H[i-1]), rec(i-2)+abs(H[i]-H[i-2]))
return C[i]
INFTY = 10**13
N = int(eval(input()))
H = list(map(int, input().split()))
C = [INFTY for i in range(N)]
print((rec(N-1)))
| p03160 |
n=int(eval(input()))
l=list(map(int, input().split()))
inf=10**12
dp=[inf]*n
dp[0]=0
dp[1]=abs(l[0]-l[1])
for i in range(n-2):
dp[i+2]=min(dp[i]+abs(l[i+2]-l[i]),dp[i+1]+abs(l[i+2]-l[i+1]))
print((dp[-1])) | n = int(eval(input()))
l=list(map(int ,input().split()))
dp=[float("inf")]*n
dp[0]=0
dp[1]=abs(l[0]-l[1])
for i in range(n-2):
dp[i+2]=min(dp[i]+abs(l[i]-l[i+2]),dp[i+1]+abs(l[i+1]-l[i+2]))
print((dp[-1])) | p03160 |
n = int(eval(input()))
l=list(map(int ,input().split()))
dp=[float("inf")]*n
dp[0]=0
dp[1]=abs(l[0]-l[1])
for i in range(n-2):
dp[i+2]=min(dp[i]+abs(l[i]-l[i+2]),dp[i+1]+abs(l[i+1]-l[i+2]))
print((dp[-1])) | n = int(eval(input()))
l = list(map(int, input().split()))
dp = [float("inf")]*n
dp[0] = 0
dp[1] = abs(l[0]-l[1])
for i in range(2,n):
dp[i]=(min(dp[i-1]+(abs(l[i]-l[i-1])),dp[i-2]+(abs(l[i]-l[i-2]))))
print((dp[-1])) | p03160 |
n = int(eval(input()))
l = list(map(int, input().split()))
dp = [float("inf")]*n
dp[0] = 0
dp[1] = abs(l[0]-l[1])
for i in range(2,n):
dp[i]=(min(dp[i-1]+(abs(l[i]-l[i-1])),dp[i-2]+(abs(l[i]-l[i-2]))))
print((dp[-1])) | n = int(eval(input()))
h = list(map(int, input().split()))
dp=[0]*(n+1)
dp[1]=0
dp[2]=abs(h[0]-h[1])
for i in range(3,n+1):
dp[i]=min(dp[i-2]+abs(h[i-3]-h[i-1]),dp[i-1]+abs(h[i-2]-h[i-1]))
print((dp[-1])) | p03160 |
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [100000] * N
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(2,N):
dp[i] = min(dp[i-2] + abs(h[i-2] - h[i]), dp[i-1] + abs(h[i-1] - h[i]))
print((dp[N-1]))
| N = int(eval(input()))
h = list(map(int, input().split()))
inf = 10**4 +1
dp = [inf]* N
dp[0] = 0
dp[1] = abs(h[0] - h[1])
for i in range(2,N):
dp[i] = min(dp[i-1] + abs(h[i]- h[i-1]), dp[i-2] + abs(h[i-2] - h[i]))
print((dp[N-1]))
| p03160 |
import sys
sys.setrecursionlimit(10**7)
N=int(sys.stdin.readline())
H=list(map(int,sys.stdin.readline().split()))
dp=[0]*N
def rec(i):
if dp[i]:
return dp[i]
if i==N-1:
return 0
elif i==N-2:
return abs(H[i]-H[i+1])
o=min(rec(i+1)+abs(H[i]-H[i+1]),rec(i+2)+abs(H[i]-H[i+2]))
dp[i]=o
return o
print((rec(0)))
| import sys
N=int(sys.stdin.readline())
H=list(map(int,sys.stdin.readline().split()))
dp=[0]*N
dp[1]=abs(H[0]-H[1])
for i in range(2,N):
dp[i]=min(dp[i-1]+abs(H[i-1]-H[i]),dp[i-2]+abs(H[i-2]-H[i]))
print((dp[-1]))
| p03160 |
#dp-a
n=int(eval(input()))
h=list(map(int,input().split()))
dp=[0]*n
for i in range(n):
if i==0:dp[0]=0
elif i==1:dp[1]=abs(h[0]-h[1])
else:
dp[i]=min(dp[i-2]+abs(h[i]-h[i-2]),dp[i-1]+abs(h[i]-h[i-1]))
print((dp[n-1])) | n = int(eval(input()))
l = list(map(int,input().split()))
cost = [float('inf')]*(n+1)
cost[0]= 0
cost[1]=abs(l[0]-l[1])
for i in range(n):
if i==1:
cost[i]=abs(l[i-1]-l[i])
if i>1:
cost[i]=min(cost[i],cost[i-2]+abs(l[i]-l[i-2]),cost[i-1]+abs(l[i]-l[i-1]))
print((cost[n-1]))
| p03160 |
import sys
sys.setrecursionlimit(100000)
eval(input())
stones = tuple(map(int, input().split()))
tracker = {}
def min_cost(remaining_stones):
if len(remaining_stones) == 1:
return 0
if len(remaining_stones) == 2:
return abs(remaining_stones[0] - remaining_stones[1])
jump_1 = remaining_stones[1:]
if jump_1 not in tracker:
tracker[jump_1] = min_cost(jump_1)
jump_2 = remaining_stones[2:]
if jump_2 not in tracker:
tracker[jump_2] = min_cost(jump_2)
score_1 = abs(remaining_stones[0] - remaining_stones[1]) + tracker[jump_1]
score_2 = abs(remaining_stones[0] - remaining_stones[2]) + tracker[jump_2]
return min(score_1, score_2)
print((min_cost(stones))) | import sys
sys.setrecursionlimit(100000)
n = int(eval(input()))
stones = list(map(int, input().split()))
stones.reverse()
bottum_up = [-1 for i in range(n)]
bottum_up[0] = 0
bottum_up[1] = abs(stones[0] - stones[1])
for i in range(2,len(stones)):
score_1 = abs(stones[i] - stones[i-1]) + bottum_up[i-1]
score_2 = abs(stones[i] - stones[i-2]) + bottum_up[i-2]
bottum_up[i] = min(score_1, score_2)
print((bottum_up[-1])) | p03160 |
N=int(eval(input()))
H=list(map(int,input().split()))
cost=0
t1,t2=0,0
A=[0]*(N)
i=1
while i<N:
if i==1:
A[i]=abs(H[i]-H[i-1])
#print(i,A[i])
elif i==2:
t1=abs(H[i]-H[i-2])
t2=abs(H[i]-H[i-1])+abs(H[i-2]-H[i-1])
A[i]=min(t1,t2)
#print(i,A[i],t1,t2)
else:
t1=abs(H[i]-H[i-1])+A[i-1]
t2=abs(H[i]-H[i-2])+A[i-2]
A[i]=min(t1,t2)
#print(i,A[i],t1,t2)
i=i+1
#print(A)
print((A[N-1])) | N=int(eval(input()))
H=list(map(int,input().split()))
DP=[0]*N
DP[0]=0
DP[1]=abs(H[1]-H[0])
for i in range(2,N):
DP[i]=min((abs(H[i]-H[i-1])+DP[i-1]),(abs(H[i]-H[i-2])+DP[i-2]))
print((DP[N-1])) | p03160 |
n=int(eval(input()))
h=[int(i) for i in input().split()]
h.append(10000)
dp=[float('inf') for i in range(n+1)]
dp[0]=0
for i in range(n-1):
dp[i+1]=min(dp[i+1],dp[i]+abs(h[i]-h[i+1]))
if(i<n-2):
dp[i+2]=min(dp[i+2],dp[i]+abs(h[i]-h[i+2]))
print((dp[n-1])) | n=int(eval(input()))
h=[int(i) for i in input().split()]
h.append(10000)
dp=[float('inf') for i in range(n+1)]
dp[0]=0
for i in range(n-1):
dp[i+1]=min(dp[i+1],dp[i]+abs(h[i]-h[i+1]))
dp[i+2]=min(dp[i+2],dp[i]+abs(h[i]-h[i+2]))
print((dp[n-1])) | p03160 |
##https://atcoder.jp/contests/dp/tasks/dp_a
N = int(eval(input()))
##N, M = map(int, input().split())
H = list(map(int, input().split()))
F = [0]*N#それぞれに対する回答を格納する箇所
C = [0]*N#Nに飛ぶ時の最小コストの格納
F[0] = 1
F[1] = 1
C[0] = 0
C[1] = abs(H[0] - H[1])
for i in range(2, N):
if C[i-2] + abs(H[i] - H[i-2]) > C[i-1] + abs(H[i] - H[i-1]):
F[i] = F[i-1]
C[i] = C[i-1] + abs(H[i] - H[i-1])
elif C[i-2] + abs(H[i] - H[i-2]) < C[i-1] + abs(H[i] - H[i-1]):
F[i] = F[i-2]
C[i] = C[i-2] + abs(H[i] - H[i-2])
else:
F[i] = F[i-2] + F[i-1]
C[i] = C[i-2] + abs(H[i] - H[i-2])
print((C[N-1]))
| ##https://atcoder.jp/contests/dp/tasks/dp_a
N = int(eval(input()))
##N, M = map(int, input().split())
H = list(map(int, input().split()))
C = [0]*N#Nに飛ぶ時の最小コストの格納
C[0] = 0
C[1] = abs(H[0] - H[1])
for i in range(2, N):
if C[i-2] + abs(H[i] - H[i-2]) > C[i-1] + abs(H[i] - H[i-1]):
C[i] = C[i-1] + abs(H[i] - H[i-1])
elif C[i-2] + abs(H[i] - H[i-2]) < C[i-1] + abs(H[i] - H[i-1]):
C[i] = C[i-2] + abs(H[i] - H[i-2])
else:
C[i] = C[i-2] + abs(H[i] - H[i-2])
print((C[N-1]))
| p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [0]*n
dp[1] = abs(h[1]-h[0])
for i in range(2, n):
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]), dp[i-2]+abs(h[i]-h[i-2]))
print((dp[-1])) | n = int(eval(input()))
h = list(map(int, input().split()))
dp = [0]*n
dp[0] = 0
dp[1] = abs(h[1]-h[0])
for i in range(2,n):
dp[i] = min(dp[i-1] + abs(h[i-1] - h[i]), dp[i-2] + abs(h[i-2] - h[i]))
print((dp[-1])) | p03160 |
N = int(eval(input()))
h = list(map(int , input().split()))
dp = [[-1]*10000 for i in range(N)]
import sys
sys.setrecursionlimit(10000000)
def dfs(i,c):
if i == N:
return 10000
if dp[i][c] != -1:
return dp[i][c]
else:
if i == N-1:
return abs(h[i] - c)
dp[i][c] = min(dfs(i+1, h[i])+abs(h[i]-c),dfs(i+2, h[i])+abs(h[i]-c))
return dp[i][c]
print((dfs(0,h[0]))) | N = int(eval(input()))
h = list(map(int , input().split()))
dp = [10**9+1]*N
dp[0] = 0
dp[1] = abs(h[1]-h[0])
for i in range(2,N):
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]), dp[i-2]+abs(h[i]-h[i-2]))
print((dp[N-1]))
| p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
INF = 10**8
dp = [INF]*n
dp[0] = 0
for i in range(n-1):
if i == 0:
dp[i+1] = abs(h[i+1]-h[i])
else:
dp[i+1] = min(dp[i]+abs(h[i+1]-h[i]), dp[i-1]+abs(h[i+1]-h[i-1]))
print((dp[n-1]))
| n = int(eval(input()))
h = list(map(int, input().split()))
INF = 10**8
dp = [INF]*n
dp[0] = 0
for i in range(1, n):
if i == 1:
dp[i] = abs(h[i]-h[i-1])
else:
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]), dp[i-2]+abs(h[i]-h[i-2]))
print((dp[n-1]))
| p03160 |
N = int(eval(input()))
h = list(map(int,input().split()))
dp = [[] for i in range(N)]
dp[0] = 0
dp[1] = abs(h[0]-h[1])
for i in range(1,N-1):
dp[i+1] = min( dp[i] + abs(h[i+1] - h[i]), dp[i-1] + abs(h[i+1] - h[i-1]))
print((dp[-1])) | n = int(eval(input()))
cost = [int(i) for i in input().split()]
dp = [0]*n
dp[1] = abs(cost[1] - cost[0])
for i in range(2, n):
be1 = abs(cost[i]-cost[i-1])
be2 = abs(cost[i]-cost[i-2])
dp[i] = min(dp[i-1]+be1, dp[i-2]+be2)
print((dp[-1])) | p03160 |
import sys
sys.setrecursionlimit(100000)
n = int(eval(input()))
h = list(map(int,input().split()))
dp_ = [-1]*n
def dp(i):
if dp_[i]!=-1:
return dp_[i]
if i == 0:
dp_[i] = 0
elif i == 1:
dp_[i] = abs(h[1]-h[0])
else:
dp_[i] = min(dp(i-2)+abs(h[i]-h[i-2]),dp(i-1)+abs(h[i]-h[i-1]))
return dp_[i]
print((dp(n-1))) | #A
n = int(eval(input()))
h = list(map(int,input().split()))
cost = [0]*n
for i in range(n):
if i == 0:
continue
if i == 1:
cost[i] = abs(h[i]-h[i-1])
continue
cost[i] = min(cost[i-1]+abs(h[i]-h[i-1]),cost[i-2]+abs(h[i]-h[i-2]))
print((cost[n-1])) | p03160 |
import sys
sys.setrecursionlimit(10**6)
#import numpy as np
#N = map(int, input().split())
N = int(eval(input()))
h = list(map(int,input().split()))
# メモ化再帰
#memo = np.full(N, -1)
memo = [-1]*N
def func(i):
if memo[i] != -1:
return memo[i]
if i == 0:
return 0
elif i == 1:
return abs(h[1]-h[0])
a = func(i-1) + abs(h[i]-h[i-1])
b = func(i-2) + abs(h[i]-h[i-2])
memo[i] = min(a,b)
return min(a,b)
print((func(N-1)))
# pythonの問題はfuncの呼び出し回数
# 10^50に耐えられない
# sys.setrecursionlimit(10**6)で回避可能 | N = int(eval(input()))
h = list(map(int,input().split()))
memo = [-1]*N
memo[0] = 0
memo[1] = abs(h[1]-h[0])
for i in range(2,N):
a = memo[i-1] + abs(h[i]-h[i-1])
b = memo[i-2] + abs(h[i]-h[i-2])
memo[i] = min(a,b)
print((memo[N-1])) | p03160 |
import sys
from functools import lru_cache
sys.setrecursionlimit(10**6)
INF = sys.maxsize
N = int(input().strip())
h = [int(x) for x in input().split()]
@lru_cache()
def solve(i):
if i >= N - 1:
return 0
return min(
solve(i + 1) + abs(h[i] - h[i + 1]) if i + 1 < N else INF,
solve(i + 2) + abs(h[i] - h[i + 2]) if i + 2 < N else INF
)
print((solve(0))) | import sys
INF = sys.maxsize
N = int(input().strip())
h = [int(x) for x in input().split()]
memo = [INF] * N
for i in range(N - 1, -1, -1):
if i == N -1:
memo[i] = 0
else:
memo[i] = min(
memo[i + 1] + abs(h[i] - h[i + 1]) if i + 1 < N else INF,
memo[i + 2] + abs(h[i] - h[i + 2]) if i + 2 < N else INF
)
print((memo[0])) | p03160 |
n = int(eval(input()))
h = [int(i) for i in input().split()]
dp = [1e9] * n
dp[0] = 0
for i in range(1,n):
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
if i > 1:
dp[i] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]))
print((dp[-1])) | n = int(eval(input()))
h = [int(i) for i in input().split()]
dp = [float('inf')] * n
dp[0] = 0
for i in range(1, n):
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
if i > 0:
dp[i] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]))
print((dp[-1])) | p03160 |
# _*_ coding:utf-8 _*_
# Atcoder_EducationDP_ContestX-1
# TODO https://atcoder.jp/contests/dp/tasks/dp_a
# 参考文献 https://qiita.com/drken/items/dc53c683d6de8aeacf5a#%E8%A7%A3%E6%B3%95
# C++ バージョンを上から書き下す
# 貰う型DP
import sys
# 初期化
# 足場の数となる要素数は足場の値の最大値であるMAX
blockMAXElement = 100010
blockElementRange = list(range(0,blockMAXElement,+1))
# DPテーブルの中身は今回は最小値を求めるため最大値を利用
dp = list()
for _ in blockElementRange:
dp.append(sys.maxsize)
N = int(input().strip())
blockRange = list(range(0,N,+1))
h = list(map(int,input().strip().split(' ')))
# 初期の条件 0歩の時は値が与えられていないのでDPは0にセット
dp[0] = 0
for position in range(1,N,+1):
# 一つ手前の足場までで最適な値のはず、のコスト
previousMinCost = dp[position-1]
# 一つ手前から来た場合の足場positionでのコスト計
# pM = previousMin
pMNowCost = dp[position-1]+abs(h[position]-h[position-1])
# 今の足場で設定されている足場へのコストより小さくなるならそれを改めて入れる
if pMNowCost <= dp[position]:
dp[position] = pMNowCost
# これは二つ手前から来たケースを考えるのでpositon = 1の場合を除いて考える
# それ以降は一個手前からと同じ
if 1 < position:
previous2MinCost = dp[position-2]
pM2NowCost = dp[position-2]+abs(h[position]-h[position-2])
if pM2NowCost <= dp[position]:
dp[position] = pM2NowCost
print(("{}".format(dp[N-1])))
| # _*_ coding:utf-8 _*_
# Atcoder_EducationDP_ContestX-1_other1
# TODO https://atcoder.jp/contests/dp/tasks/dp_a
# 参考文献 https://qiita.com/drken/items/dc53c683d6de8aeacf5a#%E8%A7%A3%E6%B3%95
# C++ バージョンを上から書き下す
# TODO 配る型DP https://qiita.com/drken/items/dc53c683d6de8aeacf5a#%E5%88%A5%E8%A7%A3-1-%E9%85%8D%E3%82%8B-dp
import sys
# 初期化
# 足場の数となる要素数は足場の値の最大値であるMAX
blockMAXElement = 100010
blockElementRange = list(range(0,blockMAXElement,+1))
# DPテーブルの中身は今回は最小値を求めるため最大値を利用
dp = [sys.maxsize] * blockMAXElement
# コスト
# 参考文献のC++では配列は宣言時に初期化されるがpythonはそれがないのでまずはあえて0で初期化
h = [0] * blockMAXElement
N = int(input().strip())
inputh = list(map(int,input().strip().split(' ')))
# h配列を入力データから取り出した物に置き換える
for i in range(0,len(inputh),+1):
h[i] = inputh[i]
# 初期の条件 0歩の時だけはコストがないので、0にセット
dp[0] = 0
# 現在の位置から最後の一歩手前(N-2歩き目)まで(仮にそこで2歩進んだ場合もDPテーブルはあるのでエラーにはならず)
for position in range(0,N-1,+1):
# 現在の岩場で最適な値のコスト
nowMinCost = dp[position]
# 1歩進んだときのコスト計
nextOneCost = nowMinCost+abs(h[position+1]-h[position])
# 一歩次の足場で設定されている足場へのコストより小さくなるならそれを改めて入れる
if nextOneCost < dp[position+1]:
dp[position+1]=nextOneCost
# 2歩足場をまたいだケースを考える。貰う場合と異なるのはpositionは0から始めて良いし
# 逆にN-2の石の足場から2歩飛んでもプログラム上ではエラーにならない
# それ以降は1個手前からと同じ
nextTwoCost = dp[position]+abs(h[position+2]-h[position])
if nextTwoCost < dp[position+2]:
dp[position+2] = nextTwoCost
print(("{}".format(dp[N-1]))) | p03160 |
n = int(eval(input()))
h = list(map(int,input().split()))
dp = [0] * n
for i in range(1,n):
if i == 1:
dp[i] = abs(h[i]-h[0])
continue
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
print((dp[-1])) | n = int(eval(input()))
h = list(map(int, input().split()))
dp = [float('inf')] * n
dp[0] = 0
for i in range(n):
if i < n - 2:
dp[i+2] = min(dp[i+2], dp[i]+abs(h[i] - h[i+2]))
dp[i+1] = min(dp[i+1], dp[i]+abs(h[i] - h[i+1]))
elif i == n - 2:
dp[i+1] = min(dp[i+1], dp[i]+abs(h[i] - h[i+1]))
print((dp[-1])) | p03160 |
N = int(eval(input()))
h = list(map(int,input().split()))
H = [0]*N
for i in range(1,N):
if i == 1:
H[i] = abs(h[1]-h[0])
else:
H[i] = min(H[i-1]+abs(h[i]-h[i-1]),H[i-2]+abs(h[i]-h[i-2]))
print((H[N-1])) | N = int(eval(input()))
h = list(map(int,input().split()))
H = [0]*N
for i in range(1,N):
if i == 1:
H[i] = abs(h[1]-h[0])
else:
H[i] = H[i-1]+abs(h[i]-h[i-1])
if H[i] > H[i-2]+abs(h[i]-h[i-2]):
H[i] = H[i-2]+abs(h[i]-h[i-2])
print((H[N-1]))
| p03160 |
n=int(eval(input()))
h=list(map(int,input().split()))
dp = [float("inf")]*n #最小値求めるのでinfで初期化
dp[0]=0
for i in range(1,n):
dp[i]=min(dp[i],dp[i-1]+abs(h[i]-h[i-1]))
if i-2>=0:
dp[i]=min(dp[i],dp[i-2]+abs(h[i]-h[i-2]))
print((dp[-1])) | n=int(eval(input()))
h=list(map(int,input().split()))
dp = [float("inf")]*n #最小値求めるのでinfで初期化
dp[0]=0
dp[1]=abs(h[1]-h[0])
for i in range(2,n):
dp[i]=min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
print((dp[-1])) | p03160 |
N = int(eval(input()))
H = list(map(int, input().split()))
dp = [0 for _ in range(N)]
dp[1] = abs(H[1] - H[0])
for i in range(2, N):
dp[i] = min(dp[i - 2] + abs(H[i] - H[i - 2]),
dp[i - 1] + abs(H[i] - H[i - 1]))
print((dp[N - 1]))
| n = int(eval(input()))
H = list(map(int, input().split()))
dp = [0] * n
for i in range(n):
if i == 0:
dp[i] = 0
elif i == 1:
dp[i] = abs(H[0] - H[i])
else:
dp[i] = min(
dp[i - 2] + abs(H[i - 2] - H[i]),
dp[i - 1] + abs(H[i - 1] - H[i])
)
print((dp[-1])) | p03160 |
inf = 10**9 + 7
n = int(eval(input()))
nodes = list(map(int, input().split()))
dp = [inf] * n
dp[0] = 0
for i in range(1, n):
dp[i] = min(dp[i], dp[i-1]+abs(nodes[i]-nodes[i-1]))
if i > 1:
dp[i] = min(dp[i], dp[i-2]+abs(nodes[i]-nodes[i-2]))
print((dp[n-1]))
| N = int(eval(input()))
h = list(map(int, input().split()))
dp = [0] * N
dp[1] = abs(h[1]-h[0])
for i in range(2, N):
dp[i] = min(dp[i-1] + abs(h[i]-h[i-1]), dp[i-2] + abs(h[i]-h[i-2]))
print((dp[N-1]))
| p03160 |
import sys
sys.setrecursionlimit(100001)
N = int(eval(input()))
memo = [[-1]*(N-1) for i in range(N)]
def frog(h,h2,h1):
if memo[h2][h1] != -1:
return memo[h2][h1]
elif h1 <= 0:
if memo[h2][0] == -1:
memo[h2][0] = abs(h[h2] - h[0])
return memo[h2][0]
else:
memo[h2][h1] = min(frog(h,h1,h1-1) + abs(h[h2]-h[h1]),frog(h,h1,h1-2)+abs(h[h2] - h[h1]))
return memo[h2][h1]
s = input().split()
h = []
for i in range(N):
h.append(int(s[i]))
print((min(frog(h,N-1,N-2),frog(h,N-1,N-3))))
#print(memo) | N = int(eval(input()))
h = list(map(int,input().split()))
if N ==2:
print((abs(h[1] - h[0])))
else:
dp = [10**4+1]*N
dp[0] = 0
dp[1] = abs(h[0]-h[1])
for i in range(2,N):
dp[i] = min(dp[i-2]+abs(h[i] - h[i-2]), dp[i-2] + abs(h[i-2]-h[i-1]) + abs(h[i-1] - h[i]), dp[i-1]+abs(h[i-1]-h[i]))
print((dp[N-1]))
| p03160 |
n,h=int(eval(input())),list(map(int,input().split()))
dp=[0,abs(h[1]-h[0])]+[0]*(n-2)
for i in range(2,n):dp[i]=min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
print((dp[n-1])) | n,h=int(eval(input())),list(map(int,input().split()))
dp=[0]*n
dp[1]=abs(h[1]-h[0])
for i in range(2,n):dp[i]=min(dp[i-2]+abs(h[i-2]-h[i]),dp[i-1]+abs(h[i-1]-h[i]))
print((dp[n-1])) | p03160 |
n = int(eval(input()))
costs = list(map(int, input().split()))
if n == 2:
print((abs(costs[-1] - costs[-2])))
else:
best = [float("inf") for i in range(n)]
best[n - 1] = 0
best[n - 2] = abs(costs[n - 2] - costs[n - 1])
for i in range(n - 3, -1, -1):
best[i] = min(abs(costs[i] - costs[i + 1]) + best[i + 1], abs(costs[i] - costs[i + 2]) + best[i + 2])
print((best[0]))
| n = int(eval(input()))
costs = list(map(int, input().split()))
if n == 2:
print((abs(costs[-1] - costs[-2])))
else:
best = [abs(costs[n - 2] - costs[n - 1]), 0]
for i in range(n - 3, -1, -1):
current = min(abs(costs[i] - costs[i + 1]) + best[0], abs(costs[i] - costs[i + 2]) + best[1])
best[0], best[1] = current, best[0]
print((best[0]))
| p03160 |
import sys
sys.setrecursionlimit(1000000)
N = int(eval(input()))
h_list = list(map(int,input().split()))
costs = [None for _ in range(N)]
def func(stone_num):
if stone_num == 0:
return 0
if stone_num == 1:
return func(stone_num-1) + abs(h_list[stone_num-1] - h_list[stone_num])
return min(
func(stone_num-1) + abs(h_list[stone_num-1] - h_list[stone_num]),
func(stone_num-2) + abs(h_list[stone_num-2] - h_list[stone_num])
)
print((func(N-1))) | N = int(eval(input()))
h_list = list(map(int,input().split()))
costs = [None for _ in range(N)]
for i in range(N):
if i == 0:
cost = 0
elif i == 1:
cost = costs[i-1] + abs(h_list[i-1] - h_list[i])
else:
cost = min(
costs[i-1] + abs(h_list[i-1] - h_list[i]),
costs[i-2] + abs(h_list[i-2] - h_list[i])
)
costs[i] = cost
print((costs[-1])) | p03160 |
def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
H = list(map(int, input().split()))
inf = float("inf")
dp = [inf]*N
dp[0] = 0
step1, step2 = inf, inf
for i in range(1, N):
step1 = abs(H[i-1]-H[i]) + dp[i-1]
if i >= 2:
step2 = abs(H[i-2]-H[i]) + dp[i-2]
step = min(step1, step2)
dp[i] = min(dp[i], step)
print((dp[-1]))
if __name__ == "__main__":
main()
| def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
H = list(map(int, input().split()))
inf = float("inf")
dp = [inf]*N
dp[0] = 0
for i in range(N-1):
dp[i+1] = min(dp[i+1], dp[i] + abs(H[i+1]-H[i]))
if i != N-2:
dp[i+2] = min(dp[i+2], dp[i] + abs(H[i+2]-H[i]))
print((dp[-1]))
if __name__ == "__main__":
main()
| p03160 |
n = int(eval(input()))
h = [int(i) for i in input().split()]
# dpの最小値を変更する関数
def chmin(a, b):
if a > b:
return b
else:
return a
# 無限大の値
f_inf = float('inf')
# DP テーブルを初期化 (最小化問題なので INF に初期化)
dp = [f_inf] * (10**5+10)
# 初期条件
dp[0] = 0
# 足場 i から足場 i+1 へ移動する。コストは|h[i]−h[i+1]|
# 足場 i から足場 i+2 へと移動する コストは |h[i]−h[i+2]|
for i in range(n-1):
dp[i + 1] = chmin(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]))
# n-2の時は2つ先はない
if i < n-2:
dp[i + 2] = chmin(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]))
print((dp[n-1])) | N = int(eval(input()))
h = [int(i) for i in input().split()]
# dpの最小値を変更する関数
def chmin(a, b):
if a > b:
return b
else:
return a
dp=[1000000000]*N
dp[0]=0
#dp[1]=abs(h[1]-h[0])
#配るDP
for i in range(N-1):
#print(abs(h[i]-h[i+1])+dp[i],dp[i+1],abs(h[i]-h[i+2])+dp[i],dp[i+2])
dp[i+1]=chmin(abs(h[i]-h[i+1])+dp[i],dp[i+1])
if i < N-2:
dp[i+2]=chmin(abs(h[i]-h[i+2])+dp[i],dp[i+2])
print((dp[-1])) | p03160 |
n = int(eval(input()))
lst = [int(i) for i in input().split()]
dp = [1e7]*n
dp[0] = 0
dp[1] = abs(lst[1]-lst[0])
for i in range(2, len(lst)):
dp[i] = min(dp[i-1]+abs(lst[i]-lst[i-1]), dp[i-2]+abs(lst[i]-lst[i-2]))
print((dp[-1])) | N = int(eval(input()))
h = list(map(int, input().split()))
dp = [1e7]*N
dp[0] = 0
dp[1] = abs(h[1]-h[0])
for i in range(2, N):
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]), dp[i-2]+abs(h[i]-h[i-2]))
print((dp[-1]))
| p03160 |
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [0]*N
dp[1] = abs(h[1]-h[0])
for i in range(2, N):
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]), dp[i-2]+abs(h[i]-h[i-2]))
print((dp[-1])) | def main():
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [0]*N
dp[1] = abs(h[0] - h[1])
for i in range(2, N):
dp[i] = min(dp[i-1] + abs(h[i-1] - h[i]), dp[i-2] + abs(h[i-2] - h[i]))
print((dp[-1]))
if __name__ == '__main__':
main() | p03160 |
def chmin(a, b):
if a > b:
return b
else:
return a
# input
N = int(eval(input()))
h = list(map(int, input().split()))
# dp table
dp = [float('inf')]*(10**5 + 10)
# 初期条件
dp[0] = 0
for i in range(1,N):
dp[i] = chmin(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
if i > 1:
dp[i] = chmin(dp[i], dp[i-2] + abs(h[i] - h[i-2]))
# ans
print((dp[N-1])) | N = int(eval(input()))
h = list(map(int, input().split()))
dp = [float('inf')]*(10**5 + 10)
dp[0] = 0
for i in range(1,N):
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]), dp[i-2] + abs(h[i] - h[i-2]))
print((dp[N-1])) | p03160 |
import sys
from functools import lru_cache
sys.setrecursionlimit(10 ** 7)
n = int(eval(input()))
h = list(map(int, input().split()))
def f(n):
if n == 0:
return 0
elif n == 1:
return abs(h[1] - h[0])
return min(f(n-2) + abs(h[n] - h[n-2]), f(n-1) + abs(h[n] - h[n-1]))
print((f(n-1))) | import sys
from functools import lru_cache
sys.setrecursionlimit(10 ** 7)
n = int(eval(input()))
h = list(map(int, input().split()))
@lru_cache(maxsize=2)
def f(n):
if n == 0:
return 0
elif n == 1:
return abs(h[1] - h[0])
return min(f(n-2) + abs(h[n] - h[n-2]), f(n-1) + abs(h[n] - h[n-1]))
print((f(n-1))) | p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
INF = float('inf')
dp = [INF] * (1 + 10 ** 5)
dp[0] = 0
for i in range(n):
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]))
if i < 2:
continue
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]))
print((dp[n-1])) | N = int(eval(input()))
h = list(map(int, input().split()))
INF = float('inf')
dp = [INF] * N
dp[0] = 0
for i in range(1, N):
if i == 1:
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i-1]))
else:
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]))
# print(dp)
print((dp[N - 1])) | p03160 |
import sys
sys.setrecursionlimit(500*500)
N =int(eval(input()))
H = list(map(int, input().split()))
H.append(0)
#総数Nで、N番目の添字はN-1
#メモ化再帰
#今の場所からゴールまでの最小コストを出す
now = 0
memo = [-1]*N
def func(n,memo):
if n >= N:
return 99999999
if n == N-1:
memo[N-1] = 0
return 0
else:
if memo[n] != -1:
return memo[n]
else:
min_later = min(func(n+1,memo)+abs(H[n+1]-H[n]), func(n+2,memo)+abs(H[n+2]-H[n]))
memo[n] = min_later
return min_later
print((func(now,memo))) | import sys
sys.setrecursionlimit(500*500)
N =int(eval(input()))
H = list(map(int, input().split()))
memo = [-1]*N
def func(n,memo):
if n == 0:
memo[0] = 0
return memo[n]
elif n == 1:
memo[1] = abs(H[1]-H[0])
return memo[n]
else:
if memo[n] != -1:
return memo[n]
else:
min_c = min(func(n-1,memo)+abs(H[n]-H[n-1]), func(n-2,memo)+abs(H[n]-H[n-2]))
memo[n] = min_c
return min_c
print((func(N-1,memo))) | p03160 |
import sys
sys.setrecursionlimit(10 ** 6)
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [float('inf')] * n
def rec(i):
if i == 0:
return 0
if dp[i] < 100000000000:
return dp[i]
else:
res = min(dp[i], rec(i - 1) + abs(h[i] - h[i - 1]))
if i > 1:
res = min(res, rec(i - 2) + abs(h[i] - h[i - 2]))
dp[i] = res
return res
print((rec(n - 1))) | # 配るdp
n = int(eval(input()))
h = list(map(int, input().split()))
# dp[i]で今までの計算結果を保存してる
dp = [float('inf')] * n
dp[0] = 0
for i in range(1, n):
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]))
if i > 1:
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]))
print((dp[n - 1]))
| p03160 |
import sys
sys.setrecursionlimit(10**7)
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [-1] * N # dp[i] := i から N-1 までの移動にかかる最小コスト
dp[N-1] = 0
def rec_memo(i):
if dp[i] >= 0:
return dp[i]
if i == N-2:
dp[i] = rec_memo(i+1) + abs(h[i+1] - h[i])
return dp[i]
else:
dp[i] = min(rec_memo(i+1) + abs(h[i+1] - h[i]), rec_memo(i+2) + abs(h[i+2] - h[i]))
return dp[i]
print((rec_memo(0))) | import sys
sys.setrecursionlimit(10**7)
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [-1] * N # dp[i] := i から N-1 までの移動にかかる最小コスト
dp[N-1] = 0
for i in reversed(list(range(N - 1))):
if i == N - 2:
dp[i] = dp[i + 1] + abs(h[i + 1] - h[i])
else:
dp[i] = min(dp[i + 2] + abs(h[i + 2] - h[i]), dp[i + 1] + abs(h[i + 1] - h[i]))
print((dp[0])) | p03160 |
n = int(eval(input()))
h = [ num for num in map(int, input().split(' '))]
dp = [float('inf')] * n
# print(n, h, dp)
def chmin(arr, index_a, val):
if arr[index_a] > val:
arr[index_a] = val
return True
return False
def chmax(arr, index_a, val):
if arr[index_a] < val:
arr[index_a] = val
return True
return False
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(2, n):
chmin(dp, i, dp[i-1] + abs(h[i] - h[i-1]))
chmin(dp, i, dp[i-2] + abs(h[i] - h[i-2]))
print((dp[n-1])) | n = int(eval(input()))
h = [num for num in map(int, input().split())]
dp = [0] * n
dp[1] = abs(h[1] - h[0])
for i in range(2, n):
dp[i] = min(dp[i-2] + abs(h[i] - h[i-2]), dp[i-1] + abs(h[i] - h[i-1]))
print((dp[n-1])) | p03160 |
n = int(eval(input()))
h_L = list(map(int,input().split()))
#dp = [float("inf")] * (10**4 + 1)
dp = [10**9] * n
dp[0] = 0
dp[1] = abs(h_L[0]-h_L[1])
for i in range(2,n):
#dp[i]
# 1
tmp1 = dp[i-1] + abs(h_L[i-1] - h_L[i])
#dp[i] = min(dp[i],tmp1)
# 2
tmp2 = dp[i-2] + abs(h_L[i-2] - h_L[i])
dp[i] = min(dp[i],tmp1,tmp2)
#print(dp)
print((dp[n-1])) | n = int(eval(input()))
h_L = list(map(int,input().split()))
dp = [0] * (n+1)
dp[1] = abs(h_L[1]-h_L[0])
for i in range(n-2):
dp[i+2] = min(dp[i+1]+abs(h_L[i+2]-h_L[i+1]),dp[i] + abs(h_L[i+2]-h_L[i]))
print((dp[n-1])) | p03160 |
N = int(eval(input()))
h = list(map(int, input().split()))
# print(N, h)
# dpの最小値を変更する関数
def chmin(a, b):
if a > b:
return b
else:
return a
# 無限大の値
f_inf = float('inf')
# DP テーブルを初期化 (最小化問題なので INF に初期化)
dp = [f_inf] * (10 ** 5 + 10)
# 初期条件
dp[0] = 0
# 足場 i-1 から足場 i へ移動する。コストは|h[i]−h[i-1]|
# 足場 i-2 から足場 i へと移動する コストは |h[i]−h[i-2]|
for i in range(1, N):
dp[i] = chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]))
# 一番目の足場では一つ前しか存在しない
if i > 1:
dp[i] = chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]))
print((dp[N - 1])) | N = int(eval(input()))
h = list(map(int, input().split()))
dp = [float('inf')]*N
dp[0] = 0
for i in range(1, N):
if i == 1:
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
else:
dp[i] = min(dp[i-1] + abs(h[i] - h[i-1]), dp[i-2] + abs(h[i] - h[i-2]))
print((dp[N-1]))
| p03160 |
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
# dp[i] = min(abs(h[i]-h[i-1])+dp[i-1], abs(h[i]-h[i-2])+dp[i-2])
N = read_int()
h = read_ints()
dp = [0, abs(h[1]-h[0])]
for i in range(2, N):
dp.append(min(abs(h[i]-h[i-1])+dp[i-1], abs(h[i]-h[i-2])+dp[i-2]))
return dp[-1]
if __name__ == '__main__':
print((solve()))
|
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
# dp[i] = min(abs(h[i]-h[i-1])+dp[i-1], abs(h[i]-h[i-2])+dp[i-2])
N = read_int()
h = read_ints()
a, b = 0, abs(h[1]-h[0])
for i in range(2, N):
b, a = min(abs(h[i]-h[i-1])+b, abs(h[i]-h[i-2])+a), b
return b
if __name__ == '__main__':
print((solve()))
| p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
c = [0 for i in range(n)]
c[0] = 0
c[1] = abs(h[1] - h[0])
# c[2] = c[0] + abs(h[2]-h[0])
# c[2] = c[1] + abs(h[2]-h[1])
# c[3] = c[1] + abs(h[3]-h[1])
# c[3] = c[2] + abs(h[3]-h[1])
for i in range(2, n):
c[i] = min(c[i-1]+abs(h[i]-h[i-1]), c[i-2]+abs(h[i]-h[i-2]))
print((c[-1]))
|
# n,k = map(int, input().split())
n = int(eval(input()))
h = list(map(int,input().split()))
dp = [0] * n
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(2,n):
dp[i] = min(abs(h[i]-h[i-1])+dp[i-1], abs(h[i]-h[i-2])+dp[i-2])
# dp[2] = min((h[2] - h[1])+dp[1], (h[2]-h[0])+dp[0])
# dp[3] = min((h[3] - h[2])+dp[2], (h[3]-h[1])+dp[1])
print((dp[-1])) | p03160 |
# coding: utf-8
n = int(eval(input())) # 2 <= n <= 10^5
h = list(map(int, input().rstrip().split()))
cost = lambda f, t: abs(h[t] - h[f])
# dp[j][i]
# j 回目のジャンプでiにいるために必要な最低コストを格納
dp = [[float('inf')] * n for _ in range(n)]
for i in dp:
i[0] = 0
for j in range(1, n):
for i in range(1, n):
dp[j][i] = min( \
dp[j - 1][i], \
float('inf') if i < 1 else \
dp[j - 1][i - 1] + abs(h[i - 1] - h[i]), \
float('inf') if i < 2 else \
dp[j - 1][i - 2] + abs(h[i - 2] - h[i]))
print((dp[n - 1][n - 1]))
| # coding: utf-8
n = int(eval(input())) # 2 <= n <= 10^5
h = list(map(int, input().rstrip().split()))
dp = [0]
for i in range(1, n):
dp.append(min( \
dp[i - 1] + abs(h[i - 1] - h[i]), \
float('inf') if i < 2 else dp[i - 2] + abs(h[i - 2] - h[i])))
print((dp[- 1])) | p03160 |
def main():
n=int(eval(input()))
h=list(map(int,input().split()))
dp=[None]*n
dp[0]=0
dp[1]=abs(h[1]-h[0])
for i in range(2,n):
temp2=dp[i-2]+abs(h[i]-h[i-2])
temp1=dp[i-1]+abs(h[i]-h[i-1])
dp[i]=min(temp1,temp2)
print((dp[n-1]))
if __name__=='__main__':
main()
|
def main():
n = int(eval(input()))
h = list(map(int,input().split()))
dp = [0] * (n + 1)
dp[1] = abs(h[1]-h[0])
for i in range(2,n):
dp[i] = min(dp[i-2] + abs(h[i] - h[i-2]), dp[i-1] + abs(h[i] - h[i-1]))
print((dp[n-1]))
if __name__=='__main__':
main()
| p03160 |
N = int(eval(input()))
H = list(map(int,input().split()))
dp = [0,abs(H[1]-H[0])]
for i in range(2,N):
h = H[i]
dp.append(min(dp[-2]+abs(H[i-2]-h), dp[-1]+abs(H[i-1]-h)))
print((dp[-1])) | N = int(eval(input()))
H = list(map(int,input().split()))
dp = [0]*N
dp[1] = abs(H[0]-H[1])
for i in range(2,N):
dp[i] = min(abs(H[i]-H[i-1]) + dp[i-1], abs(H[i]-H[i-2]) + dp[i-2])
print((dp[-1])) | p03160 |
n = int(eval(input()))
dp = [10 ** 9 for _ in range(n + 2)] # ちょっと大きめに
dp[0] = 0
h = [int(x) for x in input().split()]
for i in range(1, n):
total_cost = dp[i-1] + abs(h[i] - h[i-1])
dp[i] = min(dp[i], total_cost)
if i > 1:
total_cost = dp[i-2] + abs(h[i] - h[i - 2])
dp[i] = min(dp[i], total_cost)
print((dp[n-1])) | n = int(eval(input()))
h = list(map(int, input().split()))
dp = [10 ** 9 for _ in range(n+1)]
# スタート位置
dp[0] = 0
for i in range(n):
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
if i > 1:
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i-2]))
print((dp[n-1])) | p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [10 ** 9 for _ in range(n+1)]
# スタート位置
dp[0] = 0
for i in range(n):
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
if i > 1:
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i-2]))
print((dp[n-1])) | n = int(eval(input()))
h = list(map(int, input().split()))
h = [0] + h
dp = [10 ** 9] * (n+1)
dp[1] = 0
for i in range(1, n+1):
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]))
if i > 1:
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]))
print((dp[n])) | p03160 |
n = int(eval(input()))
H = [0] + list(map(int, input().split()))
dp = [0] * (n+1)
#dp[1] = 0
dp[2] = abs(H[2] - H[1])
for i in range(3, n+1):
dp[i] = min(dp[i-1] + abs(H[i] - H[i-1]), dp[i-2] + abs(H[i] - H[i-2]))
print((dp[n])) | n = int(eval(input()))
H = list(map(int, input().split()))
C = [0] * n
C[1] = abs(H[0] - H [1])
for i in range(n-2):
C[i+2] = min(C[i+1] + abs(H[i+2] - H[i+1]), C[i] + abs(H[i+2] - H[i]))
print((C[-1])) | p03160 |
n = int(eval(input()))
h = [int(i) for i in input().split()]
#dp[i] = そこに辿り着くまでのコスト
#初期条件 dp[0] = 0, dp[1] = |h[1] - h[0]|, dp[2以上] = 10 ** 9 + 7
dp = [10**9+7] * n
dp[0] = 0
dp[1] = abs(h[1] - h[0])
if n == 2:
print((dp[1]))
else:
for i in range(2,n):
dp[i] = min(dp[i-1] + abs(h[i] - h[i-1]),dp[i-2] + abs(h[i]-h[i-2]))
print((dp[n-1]))
| n = int(eval(input()))
h = [int(i) for i in input().split()]
dp = [0,abs(h[1]-h[0])]
for i in range(2,n):
dp.append(min(dp[-2] + abs(h[i] - h[i-2]),dp[-1] + abs(h[i] - h[i-1])))
print((dp[n-1]))
| p03160 |
N = int(eval(input()))
H = list(map(int, input().split()))
# memo = [0] + [abs(H[i] - H[i-1]) for i in range(1, N)]
# memo = [H[i] - H[i-1] for i in range(1, N)]
memo = [sum(H)] * (N+2)
memo[0] = 0
for i in range(N):
memo[i+1] = min(memo[i+1], memo[i] + abs(H[i+1] - H[i]))
if i > N-3:
break
memo[i+2] = min(memo[i+2], memo[i] + abs(H[i+2] - H[i]))
print((memo[N-1])) | N = int(eval(input()))
H = list(map(int, input().split()))
dp = [0] * N
dp[1] = abs(H[1] - H[0])
for i in range(2, N):
dp[i] = min(dp[i-1] + abs(H[i] - H[i-1]), dp[i-2] + abs(H[i] - H[i-2]))
print((dp[N-1]))
| p03160 |
INF = float('inf')
n = int(eval(input()))
h = [int(i) for i in input().split()]
dp = [0, abs(h[1] - h[0])] + [INF] * (n - 2)
for i in range(2, n):
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]))
print((dp[n - 1])) | INF = float('inf')
n = int(eval(input()))
h = [int(i) for i in input().split()]
dp = [0, abs(h[1] - h[0])]
for i in range(2, n):
dp += [min(dp[-1] + abs(h[i] - h[i - 1]), dp[-2] + abs(h[i] - h[i - 2]))]
print((dp[-1])) | p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
cost = [float('inf')] * n
cost[0] = 0
for i in range(n - 2):
cost[i + 1] = min(cost[i + 1], cost[i] + abs(h[i + 1] - h[i]))
cost[i + 2] = min(cost[i + 2], cost[i] + abs(h[i + 2] - h[i]))
cost[n - 1] = min(cost[n - 1], cost[n - 2] + abs(h[n - 1] - h[n - 2]))
print((cost[n - 1]))
| n = int(eval(input()))
h = list(map(int, input().split()))
cost = [0] * n
cost[1] = abs(h[1] - h[0])
for i in range(2, n):
cost[i] = min(abs(h[i] - h[i - 1]) + cost[i - 1], abs(h[i] - h[i - 2]) + cost[i - 2])
print((cost[n - 1]))
| p03160 |
# DP(配るDP)
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [float('inf')] * N
dp[0] = 0
for i in range(N - 2):
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]))
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]))
i = N - 2
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]))
print((dp[N - 1]))
| # DP(配るDP)
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [float('inf')] * N
dp[0] = 0
for i in range(N - 2):
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]))
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]))
dp[N - 1] = min(dp[N - 1], dp[N - 2] + abs(h[N - 1] - h[N - 2]))
print((dp[N - 1]))
| p03160 |
N = int(eval(input()))
h = list(map(int,input().split()))
INF = 10**9
dp = [INF]*N
dp[0] = 0
dp[1] = abs(h[0]-h[1])
for i in range(2,N):
dp1 = abs(h[i]-h[i-1])+dp[i-1]
dp2 = abs(h[i]-h[i-2])+dp[i-2]
dp[i] = min([dp1,dp2])
print((dp[N-1])) | def main():
INF = 10**9
N = int(eval(input()))
h = list(map(int,input().split()))
dp = [INF]*N
dp[0] = 0
dp[1] = abs(h[0]-h[1])
for i in range(2,N):
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
print((dp[N-1]))
if __name__ == '__main__':
main() | p03160 |
n = int(eval(input()))
h = [0] + list(map(int, input().split()))
cost = {1:0,2: abs(h[2] - h[1])}
for i in range(1, n):
cost[i + 1] = min(cost[i + 1], cost[i] + abs(h[i + 1] - h[i]))
if i==n-1:break
cost[i + 2] = cost[i] + abs(h[i + 2] - h[i])
print((cost[n]))
| n = int(eval(input()))
h = list(map(int, input().split()))
dp = [0] * n
dp[1] = abs(h[1] - h[0])
for i, (h, h1, h2) in enumerate(zip(h[2:], h[1:], h)):
dp[i + 2] = min(dp[i + 1] + abs(h - h1), dp[i] + abs(h - h2))
print((dp[-1]))
| p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [float("inf") for i in range(n)]
dp[0] = 0
dp[1] = dp[0] + (h[1] - h[0])
for i in range(1, n):
dp[i] = min(dp[i - 2] + (abs(h[i] - h[i - 2])), dp[i - 1] + (abs(h[i] - h[i - 1])))
print((dp[n - 1])) | import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
sys.setrecursionlimit(1000000)
# do magic here
n = int(eval(input()))
heights = [int(x) for x in input().split()]
dp = [0 for x in range(n+1)]
dp[1] = abs(heights[1]-heights[0])
for x in range(2, n):
a = abs(heights[x]-heights[x-1]) + dp[x-1]
b = abs(heights[x]-heights[x-2]) + dp[x-2]
dp[x] = min(a, b)
print((dp[n-1]))
| p03160 |
N = int(eval(input()))
*h, = list(map(int, input().split()))
dp = [float("inf") for _ in range(N)]
dp[0] = 0
for i in range(N - 1):
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]))
if i < N - 2:
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]))
print((dp[N - 1])) | n = int(eval(input()))
h=list(map(int,input().split()))
dp=[0]*(n)
dp[1]=abs(h[1]-h[0])
for i in range(2,n):
dp[i]=min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
print((dp[n-1]))
| p03160 |
import sys
sys.setrecursionlimit(1000000)
def solve(n,l,pos):
ans=0
if(pos==n):
return 0
if(pos==n-1):
return abs(l[-1]-l[-2])
ans+=min(abs(l[pos-1]-l[pos])+solve(n,l,pos+1),abs(l[pos-1]-l[pos+1])+solve(n,l,pos+2))
return ans
n=int(eval(input()))
l=list(map(int,input().split()))
print((solve(n,l,1))) | import sys
sys.setrecursionlimit(1000000)
def solve(n,l,pos):
if(pos==n):
return 0
if(pos==n-1):
return abs(l[-1]-l[-2])
if(t[pos]!=-1):
return t[pos]
t[pos]=min(abs(l[pos-1]-l[pos])+solve(n,l,pos+1),abs(l[pos-1]-l[pos+1])+solve(n,l,pos+2))
return t[pos]
n=int(eval(input()))
l=list(map(int,input().split()))
global t
t=[-1]*(n+1)
print((solve(n,l,1))) | p03160 |
"""
author : halo2halo
date : 4, Feb, 2020
"""
import sys
# import itertools
# import math
# import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, *H = list(map(int, read().split()))
dp = [0] * N
dp[1] = abs(H[1] - H[0])
for i in range(2, N):
dp[i] = min(dp[i - k] + abs(H[i] - H[i - k]) for k in [1, 2])
ans = dp[-1]
print(ans)
| """
author : halo2halo
date : 4, Feb, 2020
"""
import sys
# import itertools
# import math
# import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, *H = list(map(int, read().split()))
dp = [0] * N
for i in range(1, N):
x = dp[i - 1] + abs(H[i] - H[i - 1])
if i > 1:
y = dp[i - 2] + abs(H[i] - H[i - 2])
if x > y:
x = y
dp[i] = x
ans = dp[-1]
print(ans)
| p03160 |
import sys
from io import StringIO
import unittest
sys.setrecursionlimit(10 ** 7)
def memoize(f):
cache={}
def helper(*args):
if args not in cache:
cache[args] = f(*args)
return cache[args]
return helper
def resolve():
n = int(eval(input()))
h = list(map(int, input().split()))
inf = n * 10 ** 7
"""
ボトムアップ型: for loopを使う
ans = [inf for _ in range(n)]
ans[0] = 0
ans[1] = abs(h[1] - h[0])
for i in range(2, n):
ans[i] = min(ans[i], ans[i - 1] + abs(h[i] - h[i - 1]), ans[i - 2] + abs(h[i] - h[i - 2]))
print(ans[-1])
"""
# トップダウン(メモ再帰型)
memo = [inf for _ in range(n)]
# @memoize
def dp(n: int) -> int:
if n == 0:
return 0
elif n == 1:
return abs(h[1] - h[0])
else:
return min(dp(n - 1) + abs(h[n] - h[n - 1]), dp(n - 2) + abs(h[n] - h[n - 2]))
print((dp(n - 1)))
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """4
10 30 40 20"""
output = """30"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """2
10 10"""
output = """0"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """6
30 10 60 10 60 50"""
output = """40"""
self.assertIO(input, output)
if __name__ == "__main__":
# unittest.main()
resolve() | import sys
from io import StringIO
import unittest
sys.setrecursionlimit(10 ** 7)
def memoize(f):
cache={}
def helper(*args):
if args not in cache:
cache[args] = f(*args)
return cache[args]
return helper
def resolve():
n = int(eval(input()))
h = list(map(int, input().split()))
inf = n * 10 ** 7
"""
ボトムアップ型: for loopを使う
ans = [inf for _ in range(n)]
ans[0] = 0
ans[1] = abs(h[1] - h[0])
for i in range(2, n):
ans[i] = min(ans[i], ans[i - 1] + abs(h[i] - h[i - 1]), ans[i - 2] + abs(h[i] - h[i - 2]))
print(ans[-1])
"""
# トップダウン(メモ再帰型)
memo = [inf for _ in range(n)]
# @memoize
def dp(n: int) -> int:
if n == 0:
return 0
elif n == 1:
return abs(h[1] - h[0])
elif memo[n] != inf:
return memo[n]
else:
memo[n] = min(dp(n - 1) + abs(h[n] - h[n - 1]), dp(n - 2) + abs(h[n] - h[n - 2]))
return memo[n]
print((dp(n - 1)))
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """4
10 30 40 20"""
output = """30"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """2
10 10"""
output = """0"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """6
30 10 60 10 60 50"""
output = """40"""
self.assertIO(input, output)
if __name__ == "__main__":
#unittest.main()
resolve() | p03160 |
def minjump(li , lir):
#print(li,lir)
if tuple(li) in list(lir.keys()):
return lir[tuple(li)]
else:
if(len(li)<2):
return 0
elif(len(li) == 2):
lir[tuple(li)] = abs(li[0]-li[1])
return lir[tuple(li)]
else:
val1 = abs(li[0]-li[1])+minjump(li[1:],lir)
val2 = abs(li[0]-li[2])+minjump(li[2:],lir)
lir[tuple(li)] = min(val1,val2)
#print(li,lir[tuple(li)])
return lir[tuple(li)]
t= int(eval(input()))
num = list(map(int,input().split()))
listi = dict()
print((minjump(num,listi)))
| n = int(eval(input()))
k = 2
num = list(map(int,input().split()))
numval = list()
for data in range(n):
numval.append(1000000000)
numval[0] = 0
i = 0
if(n<k):
k = n-1
for i in range(0,n):
for data in range(1,k+1):
if(i+data)>=n:
break
numval[i+data] = min(numval[i+data],numval[i]+abs(num[i]-num[i+data]))
i += 1
print((numval[n-1])) | p03160 |
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N = int(eval(input()))
H = list(map(int, input().split()))
d = [float('inf')]*N
if N <= 3:
print((abs(H[0]-H[-1])))
else:
d[0] = 0
d[1] = abs(H[1]-H[0])
d[2] = abs(H[2]-H[0])
for i in range(3, N):
d[i] = min(d[i-1]+abs(H[i]-H[i-1]), d[i-2]+abs(H[i]-H[i-2]))
print((d[-1]))
| # python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N = int(eval(input()))
H = list(map(int, input().split()))
d = [float('inf')]*N
def solve():
if N <= 3:
print((abs(H[0]-H[-1])))
else:
d[0] = 0
d[1] = abs(H[1]-H[0])
d[2] = abs(H[2]-H[0])
for i in range(3, N):
d[i] = min(d[i-1]+abs(H[i]-H[i-1]), d[i-2]+abs(H[i]-H[i-2]))
print((d[-1]))
def solve2():
a = 0
b = abs(H[1]-H[0])
for i in range(2, N):
a, b = b, min(abs(H[i]-H[i-1])+b, abs(H[i]-H[i-2])+a)
print(b)
solve2()
| p03160 |
N = int(eval(input()))
h = list(map(int, input().split()))
INF = 10 ** 9
dp = [0] + [INF for _ in range(N - 1)]
for i in range(1, N):
if i == 1:
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1])
else:
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]))
print((dp[N - 1])) | N = int(eval(input()))
h = list(map(int, input().split()))
INF = 10 ** 9
dp = [0] + [INF for _ in range(N - 1)]
dp[1] = dp[0] + abs(h[1] - h[0])
for i in range(2, N):
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]))
print((dp[N - 1])) | p03160 |
#!/usr/bin/env python3
import sys
def solve(N: int, h: "List[int]"):
INF = 1000000000
dp = [INF] * (N+100)
dp[0] = 0
for i in range(N-1):
dp[i+1] = min(dp[i+1], dp[i] + abs(h[i+1]-h[i]))
if(i < N-2):
dp[i+2] = min(dp[i+2], dp[i] + abs(h[i+2]-h[i]))
print((dp[N-1]))
return
# 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
h = [ int(next(tokens)) for _ in range(N) ] # type: "List[int]"
solve(N, h)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
INF = 1<<32
def solve(N: int, h: "List[int]"):
dp = [INF] * (N+2)
dp[0] = 0
dp[1] = abs(h[1]-h[0])
for i in range(N):
if(i+1 < N):
dp[i+1] = min(dp[i+1], dp[i]+abs(h[i+1]-h[i]))
if(i+2 < N):
dp[i+2] = min(dp[i+2], dp[i]+abs(h[i+2]-h[i]))
print((dp[N-1]))
return
# Generated by 1.1.6 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
h = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, h)
if __name__ == '__main__':
main()
| p03160 |
n = int(eval(input()))
arr = list(map(int,input().split()))
tmp = [float('inf') for i in range(n)]
tmp[0] = 0
tmp[1] = abs(arr[0] - arr[1])
for j in range(2,n):
tmp[j] = min(tmp[j],tmp[j-2]+abs(arr[j-2]-arr[j]))
tmp[j] = min(tmp[j],tmp[j-1]+abs(arr[j-1]-arr[j]))
print((tmp[-1]))
| n = int(eval(input()))
arr = list(map(int,input().split()))
dp = [float('inf')] * n
dp[0] = 0
dp[1] = abs(arr[0] - arr[1])
for i in range(2,n):
dp[i] = min(abs(arr[i-1] - arr[i]) + dp[i -1],abs(arr[i-2]-arr[i])+dp[i-2])
print((dp[-1]))
| p03160 |
#!/usr/bin/env python
import string
import sys
from itertools import chain, dropwhile, takewhile
def read(
f, *shape, it=chain.from_iterable(sys.stdin), whitespaces=set(string.whitespace)
):
def read_word():
w = lambda c: c in whitespaces
nw = lambda c: c not in whitespaces
return f("".join(takewhile(nw, dropwhile(w, it))))
if not shape:
return read_word()
elif len(shape) == 1:
return [read_word() for _ in range(shape[0])]
elif len(shape) == 2:
return [[read_word() for _ in range(shape[1])] for _ in range(shape[0])]
def arr(*shape, fill_value=0):
if len(shape) == 1:
return [fill_value] * shape[fill_value]
elif len(shape) == 2:
return [[fill_value] * shape[1] for _ in range(shape[0])]
def dbg(**kwargs):
print(
", ".join("{} = {}".format(k, repr(v)) for k, v in kwargs.items()),
file=sys.stderr,
)
def main():
n = read(int)
hs = read(int, n)
dp = arr(n)
dp[1] = abs(hs[1] - hs[0])
for i in range(2, n):
dp[i] = min(
dp[i - 1] + abs(hs[i] - hs[i - 1]), dp[i - 2] + abs(hs[i] - hs[i - 2])
)
print(dp[-1])
if __name__ == "__main__":
main()
| n = int(eval(input()))
hs = [int(s) for s in input().split()]
dp = [0] * n
dp[0], dp[1] = 0, abs(hs[1] - hs[0])
for i in range(2, n):
dp[i] = min(
dp[i-1] + abs(hs[i] - hs[i-1]),
dp[i-2] + abs(hs[i] - hs[i-2]),
)
print((dp[-1])) | p03160 |
n = int(eval(input()))
li = list(map(int,input().split()))
p = [abs(li[i]-li[i+1]) for i in range(n-1)]
q = [abs(li[i]-li[i+2]) for i in range(n-2)]
dp = [0,p[0]]
for i in range(2,n):
dp.append(min(dp[i-1]+p[i-1], dp[i-2]+q[i-2]))
print((dp[-1]))
| n = int(eval(input()))
h = [int(i) for i in input().split()]
dp = [0]*n
dp[1] = abs(h[1] - h[0])
for i in range(2, n):
dp[i] = min(dp[i-2] + abs(h[i]-h[i-2]), dp[i-1] + abs(h[i]-h[i-1]))
print((dp[-1]))
| p03160 |
from functools import lru_cache
import sys
sys.setrecursionlimit(10**6)
N = int(eval(input()))
h = list(map(int, input().split()))
@lru_cache(maxsize=None)
def recur(i):
if i == N - 1:
return 0
return min(abs(h[i] - h[i + 1]) + recur(i + 1), abs(h[i] - h[min(N - 1, i + 2)]) + recur(min(N - 1, i + 2)))
print((recur(0)))
# dp = [0]*(N + 1)
# for i in range(N):
| from functools import lru_cache
import sys
sys.setrecursionlimit(10**6)
N = int(eval(input()))
h = list(map(int, input().split()))
# @lru_cache(maxsize=None)
# def recur(i):
# if i == N - 1:
# return 0
# return min(abs(h[i] - h[i + 1]) + recur(i + 1), abs(h[i] - h[min(N - 1, i + 2)]) + recur(min(N - 1, i + 2)))
#
# print(recur(0))
dp = [float("inf")]*(N + 2)
dp[0] = 0
for i in range(N - 1):
dp[i + 1] = min(dp[i + 1], abs(h[i] - h[i + 1]) + dp[i])
if i < N - 2:
dp[i + 2] = min(dp[i + 2], abs(h[i] - h[i + 2]) + dp[i])
print((dp[N - 1]))
| p03160 |
import sys
sys.setrecursionlimit(1000100)
n = int(sys.stdin.readline())
H = list(map(int, sys.stdin.readline().split()))
ans = []
def frog(pnt, pos):
if pos ==n-1:
ans.append(pnt)
elif pos ==n-2:
frog(pnt + abs(H[pos+1]-H[pos]), pos+1)
else:
frog(pnt + abs(H[pos+1]-H[pos]), pos+1)
frog(pnt + abs(H[pos+2]-H[pos]), pos+2)
frog(0, 0)
print((min(ans))) | import sys
n = int(sys.stdin.readline())
H = list(map(int, sys.stdin.readline().split()))
P =[0 for _ in range(n)]
P[1] = abs(H[1]-H[0])
for pos in range(2, n):
a = abs(H[pos]-H[pos-1])
b = abs(H[pos]-H[pos-2])
P[pos] = min((P[pos-1] + a), (P[pos-2] + b))
print((P[n-1])) | p03160 |
import sys
n = int(sys.stdin.readline())
H = list(map(int, sys.stdin.readline().split()))
P =[0 for _ in range(n)]
P[1] = abs(H[1]-H[0])
for pos in range(2, n):
a = abs(H[pos]-H[pos-1])
b = abs(H[pos]-H[pos-2])
P[pos] = min((P[pos-1] + a), (P[pos-2] + b))
print((P[n-1])) | #EDP-A
import sys
n = int(sys.stdin.readline())
H = list(map(int, sys.stdin.readline().split()))
dp = [0 for _ in range(n)]
#print(H)
dp[1] = abs(H[1]-H[0])
#print(dp)
for i in range(2, n):
dp[i] = min(abs(H[i]-H[i-2])+dp[i-2], abs(H[i]-H[i-1])+dp[i-1])
print((dp[-1])) | p03160 |
N=int(eval(input()))
*h,=list(map(int,input().split()))
INF=10**12
dp = [0]*N
for i in range(1,N):
if i == 1:
dp[i] = dp[0] + abs(h[i]-h[0])
continue
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]), dp[i-2]+abs(h[i]-h[i-2]))
print((dp[-1])) | N=int(eval(input()))
*h,=list(map(int,input().split()))
dp = [0]*N
for i in range(1,N):
if i == 1:
dp[i] = dp[0]+abs(h[i]-h[0])
else:
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
print((dp[-1])) | p03160 |
N = int(eval(input()))
h = list(map(int, input().split()))
INF = float('inf')
DP = [INF] * N
DP[0] = 0
DP[1] = abs(h[1] - h[0])
for i in range(2,N):
one = abs(h[i] - h[i-1]) + DP[i-1]
two = abs(h[i] - h[i-2]) + DP[i-2]
DP[i] = min(one,two)
print((DP[N-1])) | N = int(eval(input()))
h = list(map(int, input().split()))
DP = []
for i in range(N):
if i == 0:
DP.append(0)
elif i == 1:
DP.append(abs(h[0] - h[1]))
else:
one_hop = abs(h[i-1] - h[i]) + DP[i-1]
two_hop = abs(h[i-2] - h[i]) + DP[i-2]
if one_hop <= two_hop:
DP.append(one_hop)
else:
DP.append(two_hop)
print((DP[-1]))
| p03160 |
if __name__ == "__main__":
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [0] * N
dp[1] = abs(h[1] - h[0])
for i in range(2, N):
dp[i] = min(dp[i-1] + abs(h[i] - h[i-1]), dp[i-2] + abs(h[i] - h[i-2]))
print((dp[N-1]))
| def main():
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [0] * (N+5)
dp[1] = abs(h[1]-h[0])
for i in range(2, N):
dp[i] = min(dp[i-1] + abs(h[i]-h[i-1]), dp[i-2]+abs(h[i]-h[i-2]))
print((dp[N-1]))
if __name__ == "__main__":
main()
| p03160 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.