input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N=int(eval(input()))
A=list(map(int,input().split()))
A+=[0]
A+=[0]
dp=[float("INF")]*(N+2)
dp[0]=0
dp[1]=abs(A[1]-A[0])
for i in range(N):
dp[i+1]=min(dp[i+1],abs(A[i+1]-A[i])+dp[i])
dp[i+2]=min(dp[i+2],abs(A[i+2]-A[i])+dp[i])
print((dp[N-1])) | N=int(eval(input()))
A=list(map(int,input().split()))
dp=[float("INF")]*N
dp[0]=0
dp[1]=abs(A[0]-A[1])
for i in range(2,N):
dp[i]=min(dp[i],abs(A[i]-A[i-1])+dp[i-1],abs(A[i-2]-A[i])+dp[i-2])
print((dp[-1]))
| p03160 |
N = int(eval(input()))
hs = list(map(int, input().split()))
if N == 2:
print((abs(hs[1] - hs[0])))
exit()
total_cost = [-1 for _ in range(N)]
total_cost[0] = 0
total_cost[1] = abs(hs[1]-hs[0])
for i in range(2, N):
total_cost[i] = min(abs(hs[i]-hs[i-1]) + total_cost[i-1], abs(hs[i]-hs[i-2]) + total_cost[i-2])
print((total_cost[N-1]))
| N = int(eval(input()))
hs = list(map(int, input().split()))
costs = [0 for _ in range(N)]
costs[0] = 0
costs[1] = abs(hs[0] - hs[1])
for i in range(2, N):
costs[i] = min(costs[i-2] + abs(hs[i] - hs[i-2]), \
costs[i-1] + abs(hs[i] - hs[i-1]))
print((costs[N-1]))
| p03160 |
N=int(eval(input()))
h=list(map(int,input().split()))
a=[0]*N
a[1] = abs(h[0]-h[1])
for i in range(2,N):
a[i]=min(a[i-2]+abs(h[i-2]-h[i]),a[i-1]+abs(h[i-1]-h[i]))
print((a[N-1]))
| # coding: utf-8
# Your code here!
N = int(eval(input()))
h = list(map(int,input().split()))
dp = [-1 for i in range(N)]
dp[0] = 0
dp[1] = abs(h[0]-h[1])
for i in range(N-2):
dp[i+2] = min(dp[i+1] + abs(h[i+1]-h[i+2]), dp[i] + abs(h[i] - h[i+2]))
print((dp[N-1])) | p03160 |
N = int(eval(input()))
hs = list(map(int, input().split()))
INF = 10 ** 10
dp = [INF] * N
dp[0] = 0
dp[1] = abs(hs[1] - hs[0])
for i in range(1, N):
dp[i] = min(dp[i - 1] + (abs(hs[i] - hs[i - 1])),
dp[i - 2] + (abs(hs[i] - hs[i - 2])))
print((dp[N - 1])) | N = int(eval(input()))
hs = list(map(int, input().split()))
INF = 10 ** 10
dp = [INF] * N
dp[0] = 0
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[N - 1]))
| p03160 |
# 検証のためのACの人のパクリですごめんなさい
N = int(eval(input()))
hs = [i for i in map(int, input().split())]
INF = 10*12
dp = [INF]*N
dp[0] = 0
dp[1] = abs(hs[0]-hs[1])
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])) | def chmin(a, b):
if a > b:
return b
return a
def main():
N = int(eval(input()))
hs = [i for i in map(int, input().split())]
INF = 1e12
dp = [INF]*N
dp[0] = 0
for i in range(1, N):
dp[i] = chmin(dp[i], dp[i-1] + abs(hs[i]-hs[i-1]))
if i > 1:
dp[i] = chmin(dp[i], dp[i-2] + abs(hs[i]-hs[i-2]))
print((dp[N-1]))
return
if __name__ == '__main__':
main() | p03160 |
n = int(eval(input()))
h = [int(x) for x in input().split(" ")]
INF = 10**9
dp = [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])) | n = int(eval(input()))
h = [int(x) for x in input().split()]
INF = 10**10
dp = [INF]*n
dp[0] = 0
dp[1] = abs(h[1]-h[0])
for i in range(2,n):
dp[i] = min(dp[i], dp[i-1] + abs(h[i]-h[i-1]))
dp[i] = min(dp[i], dp[i-2] + abs(h[i]-h[i-2]))
print((dp[n-1]))
| p03160 |
from sys import setrecursionlimit
setrecursionlimit(1000000)
N = int(eval(input()))
H = list(map(int, input().split()))
def memoize(f):
cache = {}
def helper(x):
if x not in cache:
cache[x] = f(x)
return cache[x]
return helper
def jump(i):
if i == 0:
return 0
a = abs(H[i] - H[i - 1]) + jump(i - 1)
if i == 1:
return a
b = abs(H[i] - H[i - 2]) + jump(i - 2)
return min(a, b)
memoizedjump = memoize(jump)
print((memoizedjump(N - 1)))
| from sys import setrecursionlimit
setrecursionlimit(1000000)
N = int(eval(input()))
H = list(map(int, input().split()))
def memoize(f):
cache = {}
def helper(x):
if x not in cache:
cache[x] = f(x)
return cache[x]
return helper
@memoize
def jump(i):
if i == 0:
return 0
a = abs(H[i] - H[i - 1]) + jump(i - 1)
if i == 1:
return a
b = abs(H[i] - H[i - 2]) + jump(i - 2)
return min(a, b)
print((jump(N - 1)))
| p03160 |
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(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[n-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(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]))
| 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(1,n):
dp[i] = min(dp[i],dp[i-1] + abs(h[i] - h[i-1]))
if i >= 2:
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 = [10 ** 5 for i in range(n)]
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(n-2):
dp[i+2] = 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(eval(input()))
l=list(map(int,input().split()))
dp=[0]*n
dp[1]=abs(l[0]-l[1])
for i in range(2,n):
dp[i]=min(abs(l[i-1]-l[i])+dp[i-1], abs(l[i-2]-l[i])+dp[i-2])
print((dp[-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[-1])) | p03160 |
n = int(eval(input()))
l = list(map(int, input().split()))
#print(l)
dp = [0]*n
dp[1] = abs(l[1]-l[0])
for i in range(1,n-1):
dp[i+1] = min(dp[i]+abs(l[i+1]-l[i]), dp[i-1]+abs(l[i+1]-l[i-1]))
print((dp[-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[-1])) | p03160 |
import sys
sys.setrecursionlimit(500000)
N = int(eval(input()))
*H, = list(map(int, input().split()))
dp = [-1]*N
def dfs(n):#足場nまでにたどり着くための最小コスト
if n==0:
return 0
if n-1==0:
return abs(H[n]-H[n-1])
if dp[n]!=-1:
return dp[n]
ans = min(abs(H[n]-H[n-1])+dfs(n-1), abs(H[n]-H[n-2])+dfs(n-2))
dp[n] = ans
return ans
print((dfs(N-1))) | import sys
sys.setrecursionlimit(500000)
def dfs(n):
global N
if n==0:
return 0
if n-1==0:
return abs(H[n]-H[n-1]) + dfs(n-1)
if dp[n]!=-1:
return dp[n]
ans = 0
ans = min(abs(H[n]-H[n-1]) + dfs(n-1), abs(H[n]-H[n-2]) + dfs(n-2))
dp[n] = ans
return ans
N = int(eval(input()))
*H, = list(map(int, input().split()))
dp = [-1]*N
print((dfs(N-1))) | p03160 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
h = list(map(int, input().split()))
def main():
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[-1]))
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
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[-1]))
if __name__ == "__main__":
main() | p03160 |
import sys
sys.setrecursionlimit(10**7)
N = int(eval(input()))
h = list(map(int, input().split()))
cost = [0, abs(h[1]-h[0])]
def dp(i):
if i >= len(cost):
cost.append(min(dp(i-1)+abs(h[i]-h[i-1]), dp(i-2)+abs(h[i]-h[i-2])))
return cost[i]
print((dp(N-1))) | N = int(eval(input()))
h = list(map(int, input().split()))
def dp(n):
a, b = 0, abs(h[1]-h[0])
if n == 0:
return a
for i in range(2, n+1):
a, b = b, min(a+abs(h[i]-h[i-2]), b+abs(h[i]-h[i-1]))
return b
print((dp(N-1))) | p03160 |
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-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= [10 ** 9 + 7] * (n + 10)
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=[int(i) for i in input().split()]
dp=[0]*(N+5)
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()))
#print(H)
INF=1000000000
dp=[INF]*(N+1)
#print(dp)
dp[0]=0
#print(dp[0])
#print(H[1],H[0])
dp[1]=dp[0]+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()))
h=[int(i) for i in input().split()]
def frog(x):
if len(x)<=3:
return(abs(x[0]-x[-1]))
else:
step1=abs(x[0]-x[1])
step2=abs(x[0]-x[2])
return min(step1+frog(x[1:]),step2+frog(x[2:]))
print((frog(h)))
| n=int(eval(input()))
h=[int(i) for i in input().split()]
dp=[0]*n
dp[1]=abs(h[0]-h[1])
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()))
h = list(map(int, input().split()))
INF = int(1e20)
dp = [INF] * (N)
dp[0] = 0
for i in range(N-1):
if i == N-2:
dp[i+1] = min(dp[i+1], dp[i] + abs(h[i+1] - h[i]))
else:
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]))
print((dp[N-1])) | N = int(eval(input()))
h = list(map(int, input().split()))
# DP
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] - 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
inf = float("inf")
dp = [inf for _ in range(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-2] + abs(h[i] - h[i-2]), dp[i-1] + abs(h[i] - h[i-1]))
print((dp[-1])) | # Frog1
N = int(eval(input()))
h = list(map(int, input().split()))
inf = float("inf")
dp = [inf for _ in range(N)]
dp[0] = 0
for i in range(N):
for j in (1, 2):
if i + j >= N:
continue
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i+j]))
print((dp[-1])) | p03160 |
n = int(eval(input()))
h = tuple(map(int, input().split()))
INF = float('inf')
dp = [INF] * n
dp[0] = 0
# dp[i] = (足場iにたどり着いた時点でのコストの最小値)
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]))
| n = int(eval(input()))
h = tuple(map(int, input().split()))
INF = float('inf')
dp = [INF] * n
dp[0] = 0
dp[1] = abs(h[0] - h[1])
# dp[i] = (足場iにたどり着いた時点でのコストの最小値)
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 |
# 入力
# 足場の高さ
eval(input())
h = list(map(int, input().split()))
# 方針
# i番目の足場にいるという状態に対して
# その足場に最も少ないコストを記録する．
# 初期化は大きは数で
dp = [1e20 for i in range(len(h))]
# スタートはコスト0
dp[0] = 0
# i番目の足場でのコストを利用して
# i+1, i+2番目のコストを計算する
for i in range(len(h) - 1):
dp[i + 1] = (
dp[i + 1]
if dp[i + 1] < dp[i] + abs(h[i + 1] - h[i])
else dp[i] + abs(h[i + 1] - h[i])
)
if i + 2 < len(h):
dp[i + 2] = (
dp[i + 2]
if dp[i + 2] < dp[i] + abs(h[i + 2] - h[i])
else dp[i] + abs(h[i + 2] - h[i])
)
print((dp[len(h) - 1]))
| # 入力
# 足場の高さ
eval(input())
h = list(map(int, input().split()))
# 方針
# i番目の足場にいるという状態に対して
# その足場に最も少ないコストを記録する．
# スタートはコスト0
dp = [0]
# i番目の足場でのコストを
# i-1, i-2番目のコストを利用して計算する
# 1番目は手動で更新した方がコードが簡単になる．
dp.append(dp[0] + abs(h[1] - h[0]))
for i in range(2, len(h)):
dp.append(min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2])))
print((dp[len(h) - 1]))
| p03160 |
n = int(eval(input()))
height = list(map(int, input().split()))
dis = [0] * n
dis[1] = abs(height[1] - height[0])
for i in range(2,n):
dis[i] = min(dis[i-2] + abs(height[i] - height[i-2]), dis[i-1] + abs(height[i] - height[i-1]))
print((dis[-1])) | n = int(eval(input()))
k = list(map(int, input().split()))
dp = [0] * n
dp[1] = abs(k[1] - k[0])
for i in range(2, n):
dp[i] = min(abs(k[i]-k[i-1])+dp[i-1], abs(k[i]-k[i-2]) +dp[i-2])
print((dp[-1])) | p03160 |
N = int(eval(input()))
hs = list(map(int, input().split()))
"""
dp[i] i番目に到達するときの最小値
遷移
送るDP
i-1段目まで下記を実施
dp[i+1] = min(dp[i+1], dp[i]+コスト)
if (一段飛ばしできる余地があれば):
dp[i+2] = min(dp[i+2],dp[i]+コスト)
"""
INF = 10**9+7
dp = [INF]*101000
dp[0] = 0
for i in range(1,N):
if i-2 >= 0:
cost2 = abs(hs[i]-hs[i-2])
dp[i] = min(dp[i],dp[i-2]+cost2)
cost1 = abs(hs[i]-hs[i-1])
dp[i] = min(dp[i],dp[i-1]+cost1)
print((dp[N-1])) |
"""
dp[i] : 足場iに到達するにあたって、たどり着く最小回数
"""
INF = 10**10
dp = [INF]*110000
N = int(eval(input()))
hs = list(map(int, input().split())) + [INF,INF]
dp[0] = 0
for i in range(N):
dp[i+1] = min(dp[i+1], dp[i]+abs(hs[i+1]-hs[i]))
dp[i+2] = min(dp[i+2], dp[i]+abs(hs[i+2]-hs[i]))
print((dp[N-1]))
| p03160 |
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 5 15:34:44 2019
@author: avina
"""
n = int(eval(input()))
L = list(map(int, input().strip().split()))
dp = [0 for i in range(n)]
dp[1] = abs(L[1] - L[0])
for j in range(2,n):
for i in range(j,j+2):
if i < n:
dp[i] = min(dp[i-2] + abs(L[i]-L[i-2]),dp[i-1] + abs(L[i] - L[i-1]))
print((dp[-1])) | # -*- coding: utf-8 -*-
"""
Created on Tue Oct 8 08:28:30 2019
@author: avina
"""
n = int(eval(input()))
l = list(map(int, input().split()))
dp= [0]*n
for i in range(1,n):
b = 1e6
a = dp[i-1] + abs(l[i] - l[i-1])
if i -2 >-1:
b = dp[i-2] + abs(l[i] - l[i-2])
dp[i] = min(a,b)
print((dp[-1])) | p03160 |
n=int(eval(input()))
h=list(map(int,input().split()))
# nの足場までいく最小コストを a_n とする。
# a_1のコストは0, a_2のコストは(h_1からの１通りなので)\h_1-h_2\
dp=[0]*n
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-1]+abs(h[i]-h[i-1]))
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]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
print((dp[n-1])) | p03160 |
"""
k=int(input())
a=list(map(int,input().split()))
if k==1:
print(0)
else:
dp = [0] * k
dp[1] = abs(a[0]-a[1])
for i in range(2,k):
dp[i]=min(
dp[i-1]+abs(a[i]-a[i-1]),
dp[i-2]+abs(a[i]-a[i-2])
)
print(dp[-1])
"""
from collections import deque
n=int(eval(input()))
cost=list(map(int,input().split()))
if n==1:
print((0))
else:
# if we reach early step faster then terminate which makes more sense
ways = [1, 2]
ways.sort(reverse=True)
q = deque([(0, 0)]) # path,cost
min_cost = float('inf')
explore_more = 1
while q:
# print(q)
for _ in range(len(q)):
path, cost_ = q.popleft()
if path == n - 1:
min_cost = min(min_cost, cost_)
explore_more = 0
if explore_more:
for way in ways:
if path + way < n:
q.append((path + way, cost_ + abs(cost[path] - cost[path + way])))
print(min_cost)
| n=int(eval(input()))
cost=list(map(int,input().split()))
dp=[float('inf')]*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(cost[i] - cost[j]))
print((dp[n-1]))
| p03160 |
inf = float('inf')
n = int(eval(input()))
h = list(map(int, input().split())) + [inf]
dp = [inf] * (n + 1)
dp[0] = 0
# 配る
for i in range(n - 1):
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]))
print((dp[n - 1]))
| def main():
import sys
readline = sys.stdin.readline
inf = 10 ** 9
n = int(readline())
*h, = list(map(int, readline().split()))
h = [inf] + h + [inf] # 1-indexed化
dp = [inf] * (n + 2)
dp[0] = 0
dp[1] = 0
for i in range(1, n): # ジャンプ元,1-indexed
dp[i + 2] = min(
dp[i + 2],
dp[i] + abs(h[i + 2] - h[i]))
dp[i + 1] = min(
dp[i + 1],
dp[i] + abs(h[i + 1] - h[i]))
print((dp[n]))
if __name__ == '__main__':
main()
| p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [1000000000] * 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]))
| n = int(eval(input()))
h = list(map(int, input().split()))
INF = 1000000000
#最小値(コスト)を求める問題のため、DP配列を無限大に初期化
dp = [INF] * (n + 1)
#0番目の地点はコスト0
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=[float('inf')]*n
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[-1]))
| n=int(eval(input()))
h=list(map(int,input().split()))
dp=[float('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[-1])) | p03160 |
n=int(eval(input()))
a=list(map(int,input().split()))
dp=[10**9]*(n)
dp[0]=0
for i in range(1,n):
dp[i]=min(dp[i],dp[i-1]+abs(a[i]-a[i-1]))
if i==1:
continue
dp[i]=min(dp[i],dp[i-2]+abs(a[i]-a[i-2]))
print((dp[n-1])) | n=int(eval(input()))
a=list(map(int,input().split()))
dp=[float('inf')]*n
dp[0]=0
for i in range(1,n):
dp[i]=min(dp[i],dp[i-1]+abs(a[i]-a[i-1]))
if i==1:
continue
dp[i]=min(dp[i],dp[i-2]+abs(a[i]-a[i-2]))
print((dp[-1])) | p03160 |
# import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
geta = lambda fn: list(map(fn, input().split()))
gete = lambda fn: fn(eval(input()))
N = gete(int)
h = geta(int)
INF = 1 << 60
dp = [INF] * N
dp[0], dp[1] = 0, 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 - 1] + abs(h[i] - h[i - 1]))
print((dp[N - 1]))
| # import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
geta = lambda fn: list(map(fn, input().split()))
gete = lambda fn: fn(eval(input()))
N = gete(int)
h = geta(int)
dp = [0 for _ in range(N)]
dp[0], dp[1] = 0, 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 - 1] + abs(h[i] - h[i - 1]))
print((dp[N - 1]))
| p03160 |
# import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
geta = lambda fn: list(map(fn, input().split()))
gete = lambda fn: fn(eval(input()))
N = gete(int)
h = geta(int)
dp = [0 for _ in range(N)]
dp[0], dp[1] = 0, 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 - 1] + abs(h[i] - h[i - 1]))
print((dp[N - 1]))
| # 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)
h = geta(int)
dp = [0 for _ in range(N)]
dp[0], dp[1] = 0, 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 - 1] + abs(h[i] - h[i - 1]))
print((dp[N - 1]))
if __name__ == "__main__":
main() | p03160 |
def main(N, h):
dp = [2**31-1] * N
dp[0] = 0
for i in range(N):
if i+1 <= N-1:
dp[i+1] = min(dp[i+1], dp[i] + (abs(h[i+1] - h[i])))
if i+2 <= N-1:
dp[i+2] = min(dp[i+2], dp[i] + (abs(h[i+2] - h[i])))
return dp[-1]
N =int(eval(input()))
h = list(map(int,input().split()))
print((main(N, h))) | def I(): return int(eval(input()))
def LI(): return list(map(int,input().split()))
N = I()
h = LI()
dp = [float('INF')]*N
dp[0],dp[1] = 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[-1])) | p03160 |
import itertools,sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
h = [None]+LI()
dp = [float('INF')]*(N+1) #1_indexed
dp[1] = 0
for i,j in itertools.product(list(range(1,N+1)),[1,2]):
if i+j>=N+1:
continue
dp[i+j] = min(dp[i+j],dp[i]+abs(h[i+j]-h[i]))
print((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()
h = LI()
dp = [float('INF')]*N
dp[0] = 0
for i in range(N):
if i-1>=0:
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])) | p03160 |
import itertools,sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
h = LI()
dp = [float('INF')]*N
dp[0] = 0
for i in range(N):
if i-1>=0:
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])) | import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
h = LI()
dp = [float('INF')]*N
dp[0] = 0
for i in range(N):
if i-1>=0:
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])) | p03160 |
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
h = LI()
dp = [float('INF')]*N
dp[0] = 0
for i in range(N):
if i+1<=N-1:
dp[i+1] = min(dp[i+1],dp[i]+abs(h[i+1]-h[i]))
if i+2<=N-1:
dp[i+2] = min(dp[i+2],dp[i]+abs(h[i+2]-h[i]))
print((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()
h = LI()
dp = [float('INF')]*N
dp[0] = 0
for i,j in itertools.product(list(range(N)),[1,2]):
if i+j<=N-1:
dp[i+j] = min(dp[i+j],dp[i]+abs(h[i+j]-h[i]))
print((dp[-1]))
| p03160 |
n = int(eval(input()))
h = list(map(int,input().split()))
dp = [0 for i in range(n)]
dp[0] = 0
dp[1] = abs(h[0]-h[1])
for i in range(n-2):
dp[i+2] = min(dp[i+1] + abs(h[i+1]-h[i+2]),dp[i] + abs(h[i]-h[i+2]))
print((dp[n-1])) | n = int(eval(input()))
H = list(map(int,input().split()))
dp = [0]*(len(H))
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()))
dp = [0]*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]-H[i-2]),dp[i-1]+abs(H[i]-H[i-1]))
print((dp[-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[-1])) | p03160 |
import sys
sys.setrecursionlimit(10**9)
N = int(eval(input()))
h = list(map(int,input().split()))
memo = [-1]*N
def calc_cost(i):
if memo[i] != -1:
return memo[i]
if i == 0:
return 0
elif i == 1:
return abs(h[0]-h[1])
a = calc_cost(i-1)+abs(h[i]-h[i-1])
b = calc_cost(i-2)+abs(h[i]-h[i-2])
memo[i] = min(a,b)
return(memo[i])
print((calc_cost(N-1))) | import sys
sys.setrecursionlimit(10**6)
N = int(eval(input()))
h = list(map(int,input().split()))
memo = [-1]*N
def calc_cost(i):
if memo[i] != -1:
return memo[i]
if i == 0:
return 0
elif i == 1:
return abs(h[0]-h[1])
a = calc_cost(i-1)+abs(h[i]-h[i-1])
b = calc_cost(i-2)+abs(h[i]-h[i-2])
memo[i] = min(a,b)
return(memo[i])
print((calc_cost(N-1))) | p03160 |
#coding: utf-8
N = int(eval(input()))
a = list(map(int, input().split()))
dp = [float("inf") for _ in range(N)]
dp[0] = 0
for i in range(1, N):
dp[i] = min(dp[i], dp[i-1] + abs(a[i] - a[i-1]))
dp[i] = min(dp[i], dp[i-2] + abs(a[i] - a[i-2]))
print((dp[N-1]))
| #coding: utf-8
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [float("inf") for _ in range(N)]
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] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]))
print((dp[N-1])) | p03160 |
n = int(eval(input()))
a = list(map(int, input().split()))
dp = [1e9]*n
dp[0] = 0
for i in range(1, n):
dp[i] = min(dp[i], dp[i-1] + abs(a[i] - a[i-1]))
if i > 1:
dp[i] = min(dp[i], dp[i-2] + abs(a[i] - a[i-2]))
print((dp[n-1]))
| n = int(eval(input()))
a = list(map(int, input().split()))
dp = [1e9 for _ in range(n)]
#dp[i]...コストの最小
dp[0] = 0
dp[1] = abs(a[1] - a[0])
for i in range(n-2):
dp[i+2] = min(dp[i+1] + abs(a[i+2] - a[i+1]), dp[i] + abs(a[i+2] - a[i]))
print((dp[n-1]))
| p03160 |
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] = dp[0] + 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()))
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 |
n=int(eval(input()))
l=list(map(int,input().split()))
dp=[0 for _ in range(n)]
dp[1]=abs(l[1]-l[0])
for i in range(2,n):
single=abs(l[i]-l[i-1])+dp[i-1]
double=abs(l[i]-l[i-2])+dp[i-2]
dp[i]=min(single,double)
print((dp[n-1])) | n=int(eval(input()))
H=list(map(int,input().split()))
dp=[10**9]*n
dp[0]=0
dp[1]=abs(H[1]-H[0])
for i in range(2,n):
step1=dp[i-1]+abs(H[i]-H[i-1])
step2=dp[i-2]+abs(H[i]-H[i-2])
dp[i]=min(step1,step2)
print((dp[-1])) | p03160 |
n = int(eval(input()))
hs = list(map(int, input().split()))
dp = [0]*n
# cost1 = dp[i-1] + abs(dp[i-1]-dp[i])
# cost2 = dp[i-2] + abs(dp[i-2]-dp[i])
# dp[i] = min(cost1, cost2)
#for i in reversed(range(n)):
for i in range(n):
if i == 0:
dp[0] = 0
elif i == 1:
dp[1] = abs(hs[0]-hs[1])
else:
cost1 = dp[i-1] + abs(hs[i-1]-hs[i])
cost2 = dp[i-2] + abs(hs[i-2]-hs[i])
dp[i] = min(cost1, cost2)
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[0] = 0
elif i == 1:
dp[1] = abs(h[0]-h[1])
else:
cost1 = dp[i-1] + abs(h[i-1]-h[i])
cost2 = dp[i-2] + abs(h[i-2]-h[i])
dp[i] = min(cost1, cost2)
print((dp[n-1]))
| p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [[None] * 10**6 for _ in range(n)]
def solve(idx, cost):
if dp[idx][cost] is not None:
return dp[idx][cost]
if idx == n - 1:
return cost
if idx == n - 2:
return solve(idx + 1, cost + abs(h[idx] - h[idx+1]))
c1 = solve(idx + 1, cost + abs(h[idx] - h[idx + 1]))
c2 = solve(idx + 2, cost + abs(h[idx] - h[idx + 2]))
dp[idx][cost] = min(c1, c2)
return dp[idx][cost]
# return min(c1, c2)
ans = solve(0, 0)
print(ans) | import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
h = list(map(int, input().split()))
# dp = [[None] * 10**6 for _ in range(n)]
dp = [None] * (n+1)
# Return the smallest cost to reach the idx
def solve(idx):
if dp[idx] is not None:
return dp[idx]
if idx == 1:
dp[idx] = abs(h[idx] - h[idx - 1])
elif idx == 0:
dp[idx] = 0
else:
# jump from idx - 1
c1 = solve(idx - 1) + abs(h[idx] - h[idx - 1])
# jump from idx - 2
c2 = solve(idx - 2) + abs(h[idx] - h[idx - 2])
dp[idx] = min(c1, c2)
return dp[idx]
ans = solve(n-1)
print(ans) | p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [[None] * 10**6 for _ in range(n)]
def solve(idx, cost):
if dp[idx][cost] is not None:
return dp[idx][cost]
if idx == n - 1:
return cost
if idx == n - 2:
return solve(idx + 1, cost + abs(h[idx] - h[idx+1]))
c1 = solve(idx + 1, cost + abs(h[idx] - h[idx + 1]))
c2 = solve(idx + 2, cost + abs(h[idx] - h[idx + 2]))
dp[idx][cost] = min(c1, c2)
return dp[idx][cost]
# return min(c1, c2)
ans = solve(0, 0)
print(ans) | import sys
sys.setrecursionlimit(10**6)
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [None] * N
def solve(idx):
if dp[idx] is not None:
return dp[idx]
if idx == N - 1:
dp[idx] = 0
# return 0
elif idx == N - 2:
dp[idx] = abs(h[idx] - h[idx + 1])
# return abs(h[idx] - h[idx + 1])
else:
# Jump 1
v1 = solve(idx + 1) + abs(h[idx] - h[idx + 1])
# Jump 2
v2 = solve(idx + 2) + abs(h[idx] - h[idx + 2])
dp[idx] = min(v1, v2)
return dp[idx]
print((solve(0))) | p03160 |
N = int(eval(input()))
h = list(map(int, input().split()))
DP = [0, abs(h[0]-h[1])]
for i in range(N-2):
DP += [min(DP[-2] + abs(h[i]-h[i+2]), DP[-1] + abs(h[i+1]-h[i+2]))]
print((DP[-1])) | n = int(eval(input()))
h = list(map(int, 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[-1])) | p03160 |
import sys
sys.setrecursionlimit(20000000)
n=int(eval(input()))
h=list(map(int,input().split()))
def cost(place):
if place==n-1:
return 0
if place==n-2:
return abs(h[n-2]-h[n-1])
if place<=n-3:
a=abs(h[place]-h[place+2])+cost(place+2)
b=abs(h[place]-h[place+1])+cost(place+1)
x=min(a,b)
return x
print((cost(0)))
| import sys
sys.setrecursionlimit(20000000)
n=int(eval(input()))
h=list(map(int,input().split()))
memory={}
def cost(place):
if place in memory:
return memory[place]
if place==n-1:
return 0
if place==n-2:
return abs(h[n-2]-h[n-1])
if place<=n-3:
a=abs(h[place]-h[place+2])+cost(place+2)
b=abs(h[place]-h[place+1])+cost(place+1)
x=min(a,b)
memory[place]=x
return x
print((cost(0)))
| p03160 |
import sys
sys.setrecursionlimit(20000000)
n=int(eval(input()))
h=list(map(int,input().split()))
memory={}
def cost(place):
if place in memory:
return memory[place]
if place==n-1:
return 0
if place==n-2:
return abs(h[n-2]-h[n-1])
if place<=n-3:
a=abs(h[place]-h[place+2])+cost(place+2)
b=abs(h[place]-h[place+1])+cost(place+1)
x=min(a,b)
memory[place]=x
return x
print((cost(0)))
| n=int(eval(input()))
h=[int(i) for i in input().split()]
p0=0
p1=abs(h[1]-h[0])
for i in range(2,n):
p2=min(abs(h[i]-h[i-2])+p0,abs(h[i]-h[i-1])+p1)
p0,p1=p1,p2
print(p1) | p03160 |
N=eval(input())
H=list(map(int, input().split()))
dp=[ float("inf") for i in range(N) ]
dp[0]=0
for k in range(N-1):
for i in range(N,-1,-1):
if i+2<N:dp[i+2]=min(dp[i+2], dp[i]+ abs( H[i]-H[i+2] ) )
if i+1<N: dp[i+1]=min(dp[i+1], dp[i]+ abs( H[i]-H[i+1] ) )
print(dp[N-1])
| N=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):
if i+2<N:dp[i+2]=min(dp[i+2], dp[i]+ abs( H[i]-H[i+2] ) )
if i+1<N: dp[i+1]=min(dp[i+1], dp[i]+ abs( H[i]-H[i+1] ) )
print(dp[N-1]) | p03160 |
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [10**10] * 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]))
| N = int(eval(input()))
h = list(map(int, input().split()))
dp = [10**10] * N
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 + 2 < N:
dp[i+2] = min(dp[i+2], dp[i] + abs(h[i] - h[i+2]))
print((dp[N-1]))
| p03160 |
N=int(eval(input()))
*H,=list(map(int,input().split()))
D=[10**4*N]*N
D[0]=0
for i in range(N):
if 1<=i:
#print(i,H[i],H[i-1],abs(H[i]-H[i-1]))
D[i]=min(D[i],abs(H[i]-H[i-1])+D[i-1])
if 2<=i:
#print(i,H[i],H[i-2],abs(H[i]-H[i-2]))
D[i]=min(D[i],abs(H[i]-H[i-2])+D[i-2])
print((D[-1])) | N=int(eval(input()))
*H,=list(map(int,input().split()))
D=[-1]*N
D[0]=0
D[1]=abs(H[1]-H[0])
for i in range(2,N):
D[i]=min(abs(H[i]-H[i-1])+D[i-1],abs(H[i]-H[i-2])+D[i-2])
print((D[-1])) | p03160 |
n=int(eval(input()))
K=list(map(int,input().split()))
dp=[float('inf') for _ in range(n)]
dp[0]=0
for i in range(len(K)-1):
dp[i+1]=min(dp[i+1],dp[i]+abs(K[i]-K[i+1]))
if i+2<len(K):
dp[i+2]=min(dp[i+2],dp[i]+abs(K[i]-K[i+2]))
print((dp[-1])) | 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],dp[i-1]+abs(H[i]-H[i-1]))
dp[i]=min(dp[i],dp[i-2]+abs(H[i]-H[i-2]))
print((dp[-1])) | p03160 |
n = int(eval(input()))
initial_vals = list(map(int, input().split(" ")))
table = [[None for x in range(n)] for x in range(n)]
def calc(from_stone, to_stone):
if table[from_stone][to_stone] is not None:
return table[from_stone][to_stone]
elif (to_stone - from_stone) == 1:
table[from_stone][to_stone] = abs(
initial_vals[from_stone] - initial_vals[to_stone]
)
return table[from_stone][to_stone]
elif (to_stone - from_stone) == 2:
table[from_stone][to_stone] = min(
abs(initial_vals[from_stone] - initial_vals[to_stone - 1])
+ abs(initial_vals[to_stone - 1] - initial_vals[to_stone]),
abs(initial_vals[from_stone] - initial_vals[to_stone]),
)
return table[from_stone][to_stone]
else:
table[from_stone][to_stone] = min(
calc(from_stone, to_stone - 1) + calc(to_stone - 1, to_stone),
calc(from_stone, to_stone - 2) + calc(to_stone - 2, to_stone),
)
return table[from_stone][to_stone]
print((calc(0, n - 1)))
| n = int(eval(input()))
initial_vals = list(map(int, input().split(" ")))
# print(calc(0, n - 1))
arr = [0 for x in range(n)]
arr[1] = abs(initial_vals[0] - initial_vals[1])
for i in range(2, len(arr)):
arr[i] = min(
arr[i - 1] + abs(initial_vals[i - 1] - initial_vals[i]),
arr[i - 2] + abs(initial_vals[i - 2] - initial_vals[i]),
)
print((arr[n - 1]))
| p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
INF = 1 << 40
dp = [INF] * n
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(1, n - 1):
dp[i + 1] = min(dp[i-1] + abs(h[i+1] - h[i-1]), dp[i] + abs(h[i+1] - h[i]))
print((dp[-1])) | n = int(eval(input()))
h = [0] + list(map(int, input().split()))
dp = [0] * (n + 1)
dp[1] = 0
dp[2] = dp[1] + abs(h[2] - h[1])
for i in range(3, n + 1):
dp[i] = min(dp[i - 2] + abs(h[i] - h[i - 2]),
dp[i - 1] + abs(h[i] - h[i - 1]))
print((dp[n])) | p03160 |
n = int(eval(input()))
h = [0] + list(map(int, input().split()))
dp = [0] * (n + 1)
dp[1] = 0
dp[2] = dp[1] + abs(h[2] - h[1])
for i in range(3, n + 1):
dp[i] = min(dp[i - 2] + abs(h[i] - h[i - 2]),
dp[i - 1] + abs(h[i] - h[i - 1]))
print((dp[n])) | n = int(eval(input()))
h = list(map(int, input().split()))
def chmin(a, b):
if a > b: return b
else: return a
dp = [float('inf')] * n
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]))
print((dp[n-1])) | p03160 |
import sys
sys.setrecursionlimit(200000)
n = int(eval(input()))
h = [int(i) for i in input().split()]
def dp(cost, p):
if p == n-1:
return cost
if p < n-2:
return min(dp(cost+abs(h[p]-h[p+1]), p+1), dp(cost+abs(h[p]-h[p+2]), p+2))
if p == n-2:
return dp(cost+abs(h[p]-h[p+1]), p+1)
print((dp(0, 0))) | import sys
sys.setrecursionlimit(200000)
n = int(eval(input()))
h = [int(i) for i in input().split()]
d = {}
def dp(p):
if p in d:
return d[p]
if p == n-1:
return 0
if p < n-2:
m = min(dp(p+1)+abs(h[p]-h[p+1]), dp(p+2)+abs(h[p]-h[p+2]))
d[p] = m
return m
if p == n-2:
return dp(p+1)+abs(h[p]-h[p+1])
print((dp(0)))
| p03160 |
import sys
sys.setrecursionlimit(200000)
n = int(eval(input()))
h = [int(i) for i in input().split()]
d = {}
def dp(p):
if p in d:
return d[p]
if p == n-1:
return 0
if p < n-2:
m = min(dp(p+1)+abs(h[p]-h[p+1]), dp(p+2)+abs(h[p]-h[p+2]))
d[p] = m
return m
if p == n-2:
return dp(p+1)+abs(h[p]-h[p+1])
print((dp(0)))
| 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-2]+abs(h[i]-h[i-2]), dp[i-1]+abs(h[i]-h[i-1]))
print((dp[-1]))
| p03160 |
import itertools
result = 10 ** 15
N = int(eval(input()))
h = [int(x) for x in input().split()]
numbers = []
for i in range(N):
numbers.append(1)
numbers.append(2)
combination = list(dict.fromkeys([seq for i in range(len(numbers), 0, -1) for seq in itertools.combinations(numbers, i) if sum(seq) == N - 1]))
for i in range(len(combination)):
idouti = 0
for j in range(len(combination[i]) + 1):
if j == 0:
#idouti += abs(h[0] - h[combination[i][j]])
continue
a = sum(combination[i][0:j])
b = sum(combination[i][0:j - 1])
idouti += abs(h[a] - h[b])
if result > idouti:
result = idouti
print(result)
| N = int(eval(input()))
h = [int(x) for x in input().split()]
dp = []
dp1 = 0
dp2 = 0
for i in range(N):
if i == 0:
dp.append(0)
continue
if i == 1:
dp.append(abs(h[0] - h[1]))
continue
dp1 = dp[i - 1] + abs(h[i] - h[i - 1])
dp2 = dp[i - 2] + abs(h[i] - h[i - 2])
if dp1 < dp2:
dp.append(dp1)
else:
dp.append(dp2)
print((dp[-1]))
| p03160 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n = ni()
h = list(li())
cost = [float("inf")]*(n)
cost[0] = 0
for i in range(n-1):
if i == n-2:
cost[i+1] = min(cost[i+1],
cost[i] + abs(h[i+1]-h[i]))
else:
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]))
print((cost[-1]))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n = ni()
h = list(li())
dp = [0]*n
dp[1] = abs(h[1]-h[0])
for i in range(1,n-1):
dp[i+1] = min(dp[i-1] + abs(h[i+1]-h[i-1]),
dp[i] + abs(h[i+1]-h[i]))
print((dp[-1])) | p03160 |
def LI(): return list(map(int, input().split()))
n = int(eval(input()))
h = LI()
dp = [0] * n
dp[0], dp[1] = 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[-1]))
| def LI(): return list(map(int, input().split()))
n = int(eval(input()))
h = LI()
dp = [0] * n
dp[0], dp[1] = 0, abs(h[1] - h[0])
for i in range(n-2):
dp[i+2] = min(
dp[i+1] + abs(h[i+2] - h[i+1]),
dp[i] + abs(h[i+2] - h[i])
)
# print('i', i, '1step', abs(h[i+1] - h[i]), 'dp1', dp[i+1], '2step', abs(h[i+2] - h[i]), 'dp', dp[i], 'dp2', dp[i+2])
print((dp[-1]))
# print(dp)
| p03160 |
N = int(eval(input()))
stones = list(map(int,input().split()))
min_jump = [1000000000000 for i in range(N)]
min_jump[0] = 0
for i in range(1,N):
min_jump[i] = min(abs(stones[i] - stones[i-1]) + min_jump[i-1],abs(stones[i] - stones[i-2]) + min_jump[i-2])
print((min_jump[N-1]))
| N = int(eval(input()))
X = list(map(int,input().split()))
dp = [0,abs(X[1] - X[0])]
for x in range(2,N):
dp.append(min(dp[x-1] + abs(X[x-1]-X[x]),
dp[x-2] + abs(X[x-2]-X[x])
)
)
print((dp[N-1])) | p03160 |
n = int(eval(input()))
arr = list(map(int, input().split()))
dp = [0] * n
dp[1] = abs(arr[1] - arr[0])
for i in range(1, n - 1):
dp[i + 1] = min(dp[i - 1] + abs(arr[i + 1] - arr[i - 1]), dp[i] + abs(arr[i + 1] - arr[i]))
print((dp[-1])) |
t = int(eval(input()))
a = list(map(int, input().split()))
if t == 1:
print((0))
elif t == 2:
print((abs(a[0] - a[1])))
else:
dp = [-1] * (t)
dp[0] = 0
dp[1] = abs(a[0] - a[1])
for i in range(2, t):
dp[i] = min(abs(a[i] - a[i - 1]) + dp[i - 1],
abs(a[i] - a[i - 2]) + dp[i - 2])
print((dp[t - 1]))
| p03160 |
# ########## ------ Import ------- ##########
import sys
import math
from collections import Counter
from collections import deque as deq
from functools import lru_cache
# ########## ------ Define -------- #########
INT_MAX = float("inf")
INT_MIN = float("-inf")
# ########## ------ Input Functions ---- #########
input = sys.stdin.readline
def inp():
return(int(eval(input())))
def inlt():
return(list(map(int, input().split())))
def insr():
s = eval(input())
return(list(s[:len(s) - 1]))
def invr():
return(list(map(int, input().split())))
# ########## ------ Code ------- ##########
def go(i):
if i == 0:
dp[i] = 0
return dp[i]
if i == 1:
dp[i] = abs(a[0] - a[i])
return dp[i]
if dp[i] != -1:
return dp[i]
dp[i] = min(abs(a[i] - a[i - 1]) + go(i - 1),
abs(a[i] - a[i - 2]) + go(i - 2))
return dp[i]
t = inp()
a = inlt()
if t == 1:
print((0))
elif t == 2:
print((abs(a[0] - a[1])))
else:
dp=[-1]*t
dp[0] = 0
dp[1] = abs(a[0] - a[1])
for i in range(2, t):
dp[i] = min(abs(a[i] - a[i - 1]) + dp[i - 1],
abs(a[i] - a[i - 2]) + dp[i - 2])
print((dp[t - 1]))
|
# ########## ------ Import ------- ##########
import sys
import math
from collections import Counter
from collections import deque as deq
from functools import lru_cache
# ########## ------ Define -------- #########
INT_MAX = float("inf")
INT_MIN = float("-inf")
# ########## ------ Input Functions ---- #########
input = sys.stdin.readline
def inp():
return(int(eval(input())))
def inlt():
return(list(map(int, input().split())))
def insr():
s = eval(input())
return(list(s[:len(s) - 1]))
def invr():
return(list(map(int, input().split())))
# ########## ------ Code ------- ##########
t = inp()
a = inlt()
if t == 1:
print((0))
elif t == 2:
print((abs(a[0] - a[1])))
else:
dp=[-1]*t
dp[0] = 0
dp[1] = abs(a[0] - a[1])
for i in range(2, t):
dp[i] = min(abs(a[i] - a[i - 1]) + dp[i - 1],
abs(a[i] - a[i - 2]) + dp[i - 2])
print((dp[t - 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], dp[i-1] + abs(h[i] - h[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()))
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])) | p03160 |
if __name__=='__main__':
N = int(eval(input()))
hi = [int(i) for i in input().split()]
dp = [0 for i in range(N)]
dp[1] = abs(hi[0]-hi[1])
for i in range(2,N):
dp_1 = dp[i-1] + abs(hi[i]-hi[i-1])
dp_2 = dp[i-2] + abs(hi[i]-hi[i-2])
dp[i] = min(dp_1,dp_2)
print((dp[N-1])) | if __name__=='__main__':
N = int(eval(input()))
hi = list(map(int,input().split()))
dp = [0]*N
dp[1] = abs(hi[0]-hi[1])
for i in range(2,N):
dp_1 = dp[i-1] + abs(hi[i]-hi[i-1])
dp_2 = dp[i-2] + abs(hi[i]-hi[i-2])
dp[i] = dp_1 if dp_1 < dp_2 else dp_2
print((dp[-1])) | p03160 |
def ch_min(a, b):
if (a > b):
a = b
return a
if __name__ == "__main__":
N = int(eval(input()))
h = list(map(int, input().split()))
INF = 10 ** 10
dp = [INF] * 100010
dp[0] = 0
for i in range(N - 1):
dp[i + 1] = ch_min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]))
if (i < N - 2):
dp[i + 2] = ch_min(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]))
print((dp[N - 1]))
| N = int(eval(input()))
h = list(map(int, input().split()))
x = [0] * N
x[1] = x[0] + abs(h[1] - h[0])
for i in range(2, N):
x[i] = min(x[i - 1] + abs(h[i] - h[i - 1]),
x[i - 2] + abs(h[i] - h[i - 2]))
print((x[N-1]))
| p03160 |
import sys
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
nm = lambda: list(map(int, sys.stdin.readline().split()))
nms = lambda: list(map(str, sys.stdin.readline().split()))
nl = lambda: list(nm())
n = ni()
h = nl()
INF = 10 ** 9
dp = [INF for i in range(n)]
dp[0] = 0
dp[1] = abs(h[0] - h[1])
for i in range(2, n):
for j in h:
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]))
print((dp[-1])) | import sys
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
nm = lambda: list(map(int, sys.stdin.readline().split()))
nms = lambda: list(map(str, sys.stdin.readline().split()))
nl = lambda: list(nm())
n = ni()
h = nl()
INF = 10 ** 9
dp = [INF for i in range(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[-1])) | p03160 |
N = int(eval(input()))
[*h] = list(map(int, input().split()))
dp = [float('inf') for _ in range(N)]
dp[0] = 0
dp[1] = abs(h[0]-h[1])
for i in range(2, N):
dp[i] = dp[i-1]+abs(h[i]-h[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()))
dp = [float('inf') for _ in range(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])) | p03160 |
N = int(eval(input()))
[*h] = list(map(int, input().split()))
dp = [float('inf') for _ in range(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])) | N = int(eval(input()))
[*h] = list(map(int, input().split()))
dp = [0 for _ in range(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])) | p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [float('inf')]*n
dp[0] = 0
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])) | n = int(eval(input()))
h = list(map(int, input().split()))
dp = [float('inf')]*n
dp[0] = 0
dp[1] = dp[0]+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[-1])) | p03160 |
# -*- coding: utf-8 -*-
"""
Created on Sat May 2 00:21:08 2020
@author: Kanaru Sato
"""
import sys
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])
#topdown
def cost(n):
if n <= 1 or memo[n] >= 0:
return memo[n]
else:
memo[n] = min(cost(n-2)+abs(h[n]-h[n-2]),cost(n-1)+abs(h[n]-h[n-1]))
return memo[n]
print((cost(N-1))) | # -*- coding: utf-8 -*-
"""
Created on Sat May 2 18:45:39 2020
@author: Kanaru Sato
"""
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [-1]*n
for i in range(n):
if i == 0:
dp[i] = 0
elif i == 1:
dp[i] = abs(h[1]-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[n-1])) | p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
dp =[0, abs(h[1] - h[0])]
for i in range(2, n):
dp += [min(dp[i-2] + abs(h[i] - h[i-2]), dp[i-1] + abs(h[i] - h[i-1]))]
print((dp[-1])) | import sys
input = sys.stdin.readline
n = int(eval(input()))
h = tuple(map(int,input().split()))
dp = [0]*n
#print(dp)
dp[1] = abs(h[1]-h[0])
#print(dp)
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)
print((dp[-1])) | p03160 |
N = int(eval(input()))
H_ = list(map(int,input().split()))
def dp_solver(x):#x番の足場に行くための最小コスト
H = H_
dp = [0]*len(H)
dp[1] = abs(H[0]-H[1])
for i in range(len(H)-2):
dp[i+2] = min(dp[i]+abs(H[i+2]-H[i]),dp[i+1]+abs(H[i+2]-H[i+1]))
return dp[x]
print((dp_solver(N-1))) | N = int(eval(input()))
H_ = list(map(int,input().split()))
def dp_solver(x):
H = H_
dp=[float('inf')]*N
dp[0]=0
dp[1]=abs(H[1]-H[0])
for i in range(N-2):
dp[i+2] = min(dp[i+2],dp[i]+abs(H[i+2]-H[i]))
dp[i+2] = min(dp[i+2],dp[i+1]+abs(H[i+2]-H[i+1]))
return dp[x-1]
print((dp_solver(N))) | p03160 |
# coding: utf-8
N=int(eval(input()))
H=list(map(int,input().split()))
def dp(L):
dp=[0]*N
dp[1]=abs(L[1]-L[0])
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]))
return dp[N-1]
print((dp(H))) | # coding: utf-8
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])) | p03160 |
N = int(eval(input()))
H = list(map(int, input().split()))
dp = [0]*N
for i, x in enumerate(H):
if i == 0:
continue
elif i == 1:
dp[i] = 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[-1])) | N = int(eval(input()))
H = list(map(int, input().split()))
dp = [0]
for i, x in enumerate(H):
if i == 0:
continue
elif i == 1:
dp.append( abs(H[i] - H[i-1]) )
else:
dp.append( min( dp[i-2] + abs(H[i] - H[i-2]) , dp[i-1] + abs(H[i] - H[i-1]) ) )
print((dp[-1])) | p03160 |
N = int(eval(input()))
A = list(map(int, input().split()))
#コストの配列 全部無限にしておく
cost = [float("inf") for _ in range(N)]
cost[0] = 0
for i in range(N-1):
cost[i + 1] = min(cost[i + 1], cost[i] + abs(A[i+1] - A[i]))
if(i + 2 < N):
cost[i + 2] = min(cost[i+2], cost[i] + abs(A[i+2] - A[i]))
print((cost[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 |
def flog(heights,n):
#height:足場の高さのリスト
#n:heightsの長さ
dp = [0 for _ in heights]
dp [0] = 0
dp [1] = abs(heights[1]-heights[0])
for i in range(2,n):
from_one_before = dp[i-1] + abs(heights[i] - heights[i-1])
from_two_before = dp[i-2] + abs(heights[i] - heights[i-2])
dp[i] = min(from_one_before,from_two_before)
#print(dp)
return dp[n-1]
def main():
n = int(eval(input()))
heights = list(map(int,input().split()))
print((flog(heights,n)))
if __name__ == '__main__':
main()
|
def 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):
one_behind = dp[i-1] + abs(h[i-1] - h[i])
two_behind = dp[i-2] + abs(h[i-2] - h[i])
dp[i] = min(one_behind,two_behind)
print((dp[n-1]))
if __name__ == '__main__':
main()
| p03160 |
N = int(eval(input()))
A = list(map(int, input().split()))
INF = 10**9
dp = [INF]*N
def chmin(val1, val2):
if val1 < val2:
return val1
else:
return val2
for i in range(len(A)):
if i == 0:
dp[0] = 0
elif i == 1:
dp[1] = abs(A[1]-A[0])
else:
dp[i] = chmin(dp[i-1]+abs(A[i]-A[i-1]), dp[i-2]+abs(A[i]-A[i-2]))
print((dp[N-1])) | N = int(eval(input()))
A = list(map(int, input().split()))
INF = 10**9
dp = [INF]*N
for i in range(len(A)):
if i == 0:
dp[0] = 0
elif i == 1:
dp[1] = abs(A[1]-A[0])
else:
dp[i] = min(dp[i-1]+abs(A[i]-A[i-1]), dp[i-2]+abs(A[i]-A[i-2]))
print((dp[N-1])) | p03160 |
N = int(eval(input()))
A = list(map(int, input().split()))
INF = 10**9
dp = [INF]*N
for i in range(len(A)):
if i == 0:
dp[0] = 0
elif i == 1:
dp[1] = abs(A[1]-A[0])
else:
dp[i] = min(dp[i-1]+abs(A[i]-A[i-1]), dp[i-2]+abs(A[i]-A[i-2]))
print((dp[N-1])) | N = int(eval(input()))
A = list(map(int, input().split()))
INF = 10**9
dp = [0] + [INF]*N
for i in range(1,N):
if i == 1:
dp[1] = abs(A[1]-A[0])
else:
dp[i] = min(dp[i-1]+abs(A[i]-A[i-1]), dp[i-2]+abs(A[i]-A[i-2]))
print((dp[N-1])) | p03160 |
N=int(eval(input()))
h=list(map(int,input().split()))
DP=[0]*N
DP[0]=0
DP[1]=abs(h[1]-h[0])+DP[0]
i=2
while i<N:
DP[i]=min(abs(h[i]-h[i-1])+DP[i-1],abs(h[i]-h[i-2])+DP[i-2])
i+=1
print((DP[-1])) | def 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):
# from 2step before
pre_2=DP[i-2] + abs(h[i]-h[i-2])
pre_1=DP[i-1] + abs(h[i]-h[i-1])
DP[i]=min(pre_1,pre_2)
pass
print((DP[-1]))
if __name__ == '__main__':
main()
| p03160 |
import sys
input = sys.stdin.readline
def main():
#1:初期化
N = int(eval(input()))
#h = list(map(int, input().split()))
h = [int(x) for x in input().split()]
inf = float("inf")
dp = [inf]*(N)
#2:初期値
dp[0] = 0
#3:dp実行部(貰うDP)
for i in range(1,N):
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
if(i>1): #2つ目の足場には二個前の足場がないので．
dp[i] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]))
# #3:dp実行部(配るDP)
# for i in range(N):
# if(i+1<N):
# dp[i+1] = min(dp[i+1], dp[i] + abs(h[i] - h[i+1]))
# if(i+2<N):
# dp[i+2] = min(dp[i+2], dp[i] + abs(h[i] - h[i+2]))
#4:出力
print((dp[N-1]))
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
def main():
#1:初期化
N = int(eval(input()))
h = list(map(int, input().split()))
#h = [int(x) for x in input().split()]
inf = float("inf")
dp = [inf]*(N)
#2:初期値
dp[0] = 0
#3:dp実行部(貰うDP)
for i in range(1,N):
dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
if(i>1): #2つ目の足場には二個前の足場がないので．
dp[i] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]))
# #3:dp実行部(配るDP)
# for i in range(N):
# if(i+1<N):
# dp[i+1] = min(dp[i+1], dp[i] + abs(h[i] - h[i+1]))
# if(i+2<N):
# dp[i+2] = min(dp[i+2], dp[i] + abs(h[i] - h[i+2]))
#4:出力
print((dp[N-1]))
if __name__ == '__main__':
main() | p03160 |
from functools import lru_cache
import sys
sys.setrecursionlimit(10 ** 7)
N = int(eval(input()))
h = list(map(int, input().split()))
@lru_cache(maxsize=None)
def rec(n):
# print(n)
if n == 1:
return 0
elif n == 2:
return abs(h[1]-h[0])
else:
return min(rec(n-1)+abs(h[n-1]-h[n-2]), rec(n-2)+abs(h[n-1]-h[n-3]))
print((rec(N))) | from functools import lru_cache
import sys
sys.setrecursionlimit(10 ** 7)
N = int(eval(input()))
h = list(map(int, input().split()))
memo = [None] * N
memo[0] = 0
memo[1] = abs(h[1]-h[0])
def rec(n):
if memo[n] == None:
memo[n] = min(rec(n-1)+abs(h[n]-h[n-1]), rec(n-2)+abs(h[n]-h[n-2]))
return memo[n]
rec(N-1)
print((memo[N-1]))
"""
@lru_cache(maxsize=None)
def rec(n):
# print(n)
if n == 1:
return 0
elif n == 2:
return abs(h[1]-h[0])
else:
return min(rec(n-1)+abs(h[n-1]-h[n-2]), rec(n-2)+abs(h[n-1]-h[n-3]))
"""
# print(rec(N)) | p03160 |
'''
以下解説を参考に回答
https://qiita.com/drken/items/dc53c683d6de8aeacf5a
'''
N = int(eval(input()))
H = list(map(int, input().split()))
# DPテーブル
dp = [10 ** 9] * N
# 初期条件
dp[0] = 0
dp[1] = abs(H[1] - H[0])
# ループ
for i in range(1, 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])) | '''
以下解説を参考に回答
https://qiita.com/drken/items/dc53c683d6de8aeacf5a
'''
N = int(eval(input()))
H = list(map(int, input().split()))
# DPテーブル
dp = [10 ** 9] * 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 ** 9 + 1
dp = [INF] * N
dp[0] = 0
for i in range(len(dp) - 1):
dp[i + 1] = min(dp[i] + abs(h[i + 1] - h[i]), dp[i + 1])
if i + 2 < len(dp):
dp[i + 2] = min(dp[i] + abs(h[i + 2] - h[i]), dp[i + 2])
print((dp[N - 1]))
| N = int(eval(input()))
blank = 2
h = list(map(int,input().split())) + [0] * blank
INF = 10 ** 9 + 1
dp = [INF] * (N + blank)
dp[0] = 0
for i in range(N):
dp[i + 1] = min(dp[i] + abs(h[i + 1] - h[i]), dp[i + 1])
dp[i + 2] = min(dp[i] + abs(h[i + 2] - h[i]), dp[i + 2])
print((dp[N - 1]))
| p03160 |
n = int(eval(input()))
h = list(map(int,input().split()))
inf = 10000
dp = []
for i in range(100000):
dp.append(inf)
dp[0] = 0
for i in range(1,n):
if i>1:
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
else:
dp[i] = dp[i-1] + abs(h[i]-h[i-1])
print((dp[n-1]))
| N = int(eval(input()))
h = list(map(int,input().split()))
dp = [100010]*N
dp[0] = 0
for i in range(1,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()))
dp = [float('INF') for _ in range(n)]
for i in range(n):
if 0 == i:
dp[i] = 0
elif 1 == i:
dp[i] = abs(h[i-1] - h[i])
else:
dp[i] = min(dp[i-1] + abs(h[i-1] - h[i]),
dp[i-2] + abs(h[i-2] - h[i]))
print((dp[-1]))
| n = int(eval(input()))
h = list(map(int, input().split()))
cost = [0 for _ in range(n)]
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]))
| p03160 |
N = int(eval(input()))
*T, = list(map(int, input().split()))
INF = float("inf") # pythonでの無限大の作り方
DP = [INF for i in range(N)]
def chmin(a, b):
if a > b:
return b
return a
DP[0] = 0
for i in range(1, N):
DP[i] = chmin(DP[i], DP[i-1] + abs(T[i-1] - T[i]))
DP[i] = chmin(DP[i], DP[i-2] + abs(T[i-2] - T[i]))
print((int(DP[-1]))) | """
dp[i] := 足場iまでにかかるコストの最小値
"""
N = int(eval(input()))
*h, = list(map(int, input().split()))
dp = [0 for _ in range(N)]
dp[1] = abs(h[0] - h[1]) # initialize dp
for i in range(2, N):
case1 = dp[i-1] + abs(h[i-1] - h[i])
case2 = dp[i-2] + abs(h[i-2] - h[i])
dp[i] = min(case1, case2)
print((dp[-1])) | p03160 |
"""
dp[i] := 足場iまでにかかるコストの最小値
"""
N = int(eval(input()))
*h, = list(map(int, input().split()))
dp = [0 for _ in range(N)]
dp[1] = abs(h[0] - h[1]) # initialize dp
for i in range(2, N):
case1 = dp[i-1] + abs(h[i-1] - h[i])
case2 = dp[i-2] + abs(h[i-2] - h[i])
dp[i] = min(case1, case2)
print((dp[-1])) | N = int(eval(input()))
H = list(map(int, input().split()))
cost = [0]*N
cost[1] = abs(H[0] - H[1])
for k in range(2, N):
cost[k] = min(cost[k-1] + abs(H[k-1] - H[k]), cost[k-2] + abs(H[k-2] - H[k]))
print((cost[-1])) | p03160 |
import sys
def solve(stns, idx, mem):
if idx >= len(stns) -1:
return 0
if idx in mem:
return mem[idx]
if idx == len(stns) - 2:
# can take only one step
# print(idx)
# final_step = solve(stns, idx + 1, mem) + abs(stns[idx] - stns[idx+1])
final_step = abs(stns[idx] - stns[idx+1])
mem[idx] = final_step
return final_step
else:
# step: i + 11
step1 = solve(stns, idx + 1, mem) + abs(stns[idx] - stns[idx+1])
# step: i + 2
step2 = solve(stns, idx + 2, mem) + abs(stns[idx] - stns[idx+2])
min_cost = min(step1, step2)
mem[idx] = min_cost
return min_cost
def take_input():
# n = input()
# stns = [int(x) for x in input().split(' ')]
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
sys.setrecursionlimit(1000000)
# do magic here
n = int(eval(input()))
stns = [int(x) for x in input().split()]
mem = {}
res = solve(stns, 0, mem)
print(res)
take_input() | import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
sys.setrecursionlimit(1000000)
def solve(stns, idx, mem):
if idx >= len(stns) -1:
return 0
if idx in mem:
return mem[idx]
if idx == len(stns) - 2:
#cant take more than one step
final_step = abs(stns[idx] - stns[idx+1])
mem[idx] = final_step
return final_step
else:
# step: i + 11
step1 = solve(stns, idx + 1, mem) + abs(stns[idx] - stns[idx+1])
# step: i + 2
step2 = solve(stns, idx + 2, mem) + abs(stns[idx] - stns[idx+2])
min_cost = min(step1, step2)
mem[idx] = min_cost
return min_cost
def take_input():
n = eval(input())
stns = [int(x) for x in input().split()]
mem = {}
res = solve(stns, 0, mem)
print(res)
take_input() | p03160 |
import math
N = int(eval(input()))
vals = list(map(int, input().split()))
def chmin_orig(i1, i2):
if dp[i1] > (dp[i2] + abs(vals[i1]-vals[i2])):
dp[i1] = dp[i2] + abs(vals[i1]-vals[i2])
return True
return False
dp = [float('inf')] * 100010
dp[0] = 0
for i in range(N):
chmin_orig(i, i-1)
if i > 1:
chmin_orig(i, i-2)
print((dp[N-1]))
| N = int(eval(input()))
costs = list(map(int, input().split())) + [0]*10000
def chmin(i, j, dp, costs):
if dp[i+j] > dp[i] + abs(costs[i] - costs[i+j]):
dp[i+j] = dp[i] + abs(costs[i] - costs[i+j])
return True
return False
dp = [float('inf')] * 100010
dp[0] = 0
for i in range(N):
chmin(i, 1, dp, costs)
chmin(i, 2, dp, costs)
print((dp[N-1])) | p03160 |
n = int(eval(input()))
hs = list(map(int, input().split()))
# 足場 i にたどり着くまでのコストの総和の最小値
dp = [1e14] * n
dp[0] = 0
dp[1] = abs(hs[0] - hs[1])
for i in range(2, n):
dp[i] = min(abs(hs[i] - hs[i - 1]) + dp[i - 1], abs(hs[i] - hs[i - 2]) + dp[i - 2])
print((dp[n - 1]))
| n = int(eval(input()))
hs = list(map(int, input().strip().split()))
# 足場 i にたどり着くまでに支払うコストの総和の最小値
# 初期値として足場 0 にいるので dp[0] = 0
dp = [0] * n
# 足場 1 に行くための最小値は 0 → 1 と行く場合に当たるので
dp[1] = abs(hs[1] - hs[0])
# DP する
for i in range(2, n):
cost_sum_1 = dp[i - 1] + abs(hs[i] - hs[i - 1])
cost_sum_2 = dp[i - 2] + abs(hs[i] - hs[i - 2])
dp[i] = min(cost_sum_1, cost_sum_2)
print((dp[n - 1]))
| p03160 |
n = int(eval(input()))
ls_h = list(map(int,input().split()))
ls_cos = [0]*n
ls_cos[1] = abs(ls_h[1]-ls_h[0])
for i in range(2,n):
ls_cos[i] = min(ls_cos[i-2]+abs(ls_h[i]-ls_h[i-2]) , ls_cos[i-1]+abs(ls_h[i]-ls_h[i-1]))
print((ls_cos[-1]))
| n = int(eval(input()))
h = list(map(int,input().split()))
ans = [0,abs(h[1]-h[0])]+[0]*(n-2)
for i in range(2,n):
ans[i] = min(ans[i-1]+abs(h[i]-h[i-1]),ans[i-2]+abs(h[i]-h[i-2]))
print((ans[-1])) | p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
a = [0,abs(h[1]-h[0])] + [float('inf')]*(n-2)
for i in range(2,n):
a[i] = min(a[i-2]+abs(h[i]-h[i-2]), a[i-1]+abs(h[i]-h[i-1]))
print((a[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[-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 = [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])) | p03160 |
N = int(eval(input()))
h = list(map(int, input().split()))
ans = [100000000000] * N
ans[0] = 0
for i in range(N-1):
ans[i+1] = min(ans[i+1], ans[i] + abs(h[i] - h[i+1]))
if i + 2 > N - 1:
continue
ans[i+2] = min(ans[i+2], ans[i] + abs(h[i] - h[i+2]))
print((ans[-1])) | N = int(eval(input()))
h = list(map(int, input().split()))
ans = [float("inf")] * N
ans[0] = 0
for i in range(N-1):
ans[i+1] = min(ans[i+1], ans[i] + abs(h[i] - h[i+1]))
if i + 2 > N - 1:
continue
ans[i+2] = min(ans[i+2], ans[i] + abs(h[i] - h[i+2]))
print((ans[-1])) | p03160 |
import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
*h, = list(map(int, input().split()))
def rec(i: int, c: int) -> int:
if i == 0:
return c
elif i <= 1:
return rec(i-1, c+abs(h[i]-h[i-1]))
return min(rec(i-1, c+abs(h[i]-h[i-1])), rec(i-2, c+abs(h[i]-h[i-2])))
print((rec(n-1, 0)))
"""
3,0
2,20 1,10
1,30 0,50 0,30
0,50
"""
| 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] = dp[i-1] + abs(h[i-1] - h[i])
else:
dp[i] = min(dp[i-1] + abs(h[i-1] - h[i]), dp[i-2] + abs(h[i-2] - h[i]))
print((dp[n-1]))
| 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-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 = [int(i) for i in input().split()]
# 無限大の値
f_inf = float('inf')
# DP テーブルを初期化 (最小化問題なので INF に初期化)
dp = [f_inf] * n
# 初期条件
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] = 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 = [int(i) for i in input().split()]
# 無限大の値
f_inf = float('inf')
# DP テーブルを初期化 (最小化問題なので INF に初期化)
dp = [f_inf] * n
# 初期条件
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] = 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 = float('inf')
#DPテーブル
dp = [INF] * N
#最初のコストは0
dp[0] = 0
#最小化問題
#i番目のコストの最小値は、i-1 or i -2 番目までのコストからiまでのコストを足したものの小さい方
for i in range(1,N):
dp[i] = min(dp[i],dp[i-1] + abs(h[i]-h[i-1]))
#i=1のときは、i-2番目が存在しない
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**8)
n = int(eval(input()))
h = list(map(int,input().split()))
dp = [float("inf")] * n #dpテーブル
#dp[i]メモ化テーブル
#まずは使わない
def rec(i):#再帰による全探索
if i == 0:
return 0
elif i == 1:
return abs(h[0]-h[1])
else:
return min(rec(i-1)+abs(h[i]-h[i-1]),rec(i-2)+abs(h[i]-h[i-2]))
print((rec(n-1)))
| import sys
sys.setrecursionlimit(10**8)
n = int(eval(input()))
h = list(map(int,input().split()))
dp = [float("inf")] * n #dpテーブル
#dp[i]メモ化テーブル
def rec(i):#再帰による全探索
if dp[i] != float("inf"):
return dp[i]
if i == 0:
return 0
elif i == 1:
return abs(h[0]-h[1])
else:
dp[i] = min(rec(i-1)+abs(h[i]-h[i-1]),rec(i-2)+abs(h[i]-h[i-2]))
return dp[i]
print((rec(n-1)))
| p03160 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.