problem_id stringclasses 100
values | submission_id stringlengths 10 10 | status stringclasses 2
values | code stringlengths 6 806 |
|---|---|---|---|
p03160 | s393089799 | Accepted | N = int(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]) |
p03160 | s965617699 | Accepted | n = int(input())
H = list(map(int, input().split()))
DP = [0 for i in range(n)]
DP[0] = 0
DP[1] = abs(H[1] - H[0])
for i in range(2, n):
a = DP[i - 2] + abs(H[i] - H[i - 2])
b = DP[i - 1] + abs(H[i] - H[i - 1])
if a <= b:
DP[i] = a
else:
DP[i] = b
print(DP[n - 1]) |
p03160 | s287382210 | Accepted | n = int(input())
h = list(map(int, input().split()))
memo = [0] * n
memo[0] = 0
memo[1] = abs(h[0]-h[1])
for i in range(2,n):
memo[i] += min(abs(h[i]-h[i-1])+memo[i-1],\
abs(h[i]-h[i-2])+memo[i-2])
print(memo[-1])
|
p03160 | s931925383 | Accepted | n = int(input())
h = list(map(int,input().split()))
INF = 10 ** 20
dp = [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 | s555626435 | Accepted | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
import bisect
import numpy as np
N = int(input())
H = list(map(int, input().split()))
dp = np.zeros(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(int(dp[N-1])) |
p03160 | s149076708 | Accepted | n = int(input())
h = tuple(int(i) for i in input().split())
x, y = 0, abs(h[0]-h[1])
for i in range(2, n):
v = min(x+abs(h[i-2]-h[i]), y+abs(h[i-1]-h[i]))
x, y = y, v
print(y) |
p03160 | s441212352 | Accepted | n = int(input())
l = list(map(int,input().split()))
dp = [0]*n
dp[1] = abs(l[1]-l[0])
for i in range(2,n):
dp[i] = min(dp[i-2]+abs(l[i-2]-l[i]),dp[i-1]+abs(l[i-1]-l[i]))
print(dp[n-1]) |
p03160 | s213654866 | Accepted | N = int(input())
step = list(map(int, input().split()))
dp = [float('inf')] * N
dp[0] = 0
dp[1] = abs(step[0] - step[1])
for i, s in enumerate(step):
if i < 2:
continue
dp[i] = min(dp[i - 2] + abs(step[i - 2] - step[i]), dp[i - 1] + abs(step[i - 1] - step[i]))
print(dp[N - 1]) |
p03160 | s857944685 | Accepted | import numpy as np
N = int(input())
h = list(map(int, input().split()))
dp = np.full(N, np.inf)
dp[0] = 0
for i in range(1,N):
dp[i] = min(dp[i],dp[i-1]+np.abs(h[i] - h[i-1]))
if i > 1: dp[i] = min(dp[i],dp[i-2]+np.abs(h[i] - h[i-2]))
print(int(dp[-1])) |
p03160 | s891297350 | Accepted | n = int(input())
h = list(map(int, input().split()))
dp = [0] * len(h)
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 | s744290001 | Accepted | N = int(input())
h = [int(x) for x in input().split()]
dp = [1000000 for _ in range(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]))
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 | s223995347 | Accepted | n = int(input())
cost = list(map(int, input().split(" ")))
dp = [None for i in range(n)]
dp[0] = 0
dp[1] = abs(cost[1] - cost[0])
for i in range(2, n):
one_step_cost = abs(cost[i] - cost[i-1]) + dp[i-1]
two_step_cost = abs(cost[i] - cost[i-2]) + dp[i-2]
best_cost = min([one_step_cost, two_step_cost])
dp[i] = best_cost
print(dp[n-1]) |
p03160 | s188587168 | Accepted | N = int(input())
h = list(map(int,input().split()))
dp = [0]*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])
|
p03160 | s575421494 | Accepted | N = int(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 | s196862920 | Accepted | N = int(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 | s361305480 | Accepted | n = int(input())
h = list(map(int, input().split()))
dp = [0, abs(h[1]-h[0])]
for i in range(2, n):
dp.append(min(abs(h[i]-h[i-1])+dp[-1], abs(h[i]-h[i-2])+dp[-2]))
print(dp[-1]) |
p03160 | s234357502 | Accepted | 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])
|
p03160 | s137998330 | Accepted | def cost(a, b):
tmp = a - b
if tmp < 0:
tmp = -1*tmp
return tmp
N = int(input())
h = list(map(int, input().split()))
min_cost = [0]*N
min_cost[0] = 0
min_cost[1] = cost(h[0], h[1])
for i in range(2, N):
min_cost[i] = min(min_cost[i - 2]+cost(h[i-2], h[i]), min_cost[i-1]+cost(h[i-1], h[i]))
print(min_cost[-1]) |
p03160 | s807465011 | Accepted | #DP-A
n=int(input())
h=list(map(int,input().split()))
dp=[float('inf')]*n
dp[0]=0
for i in range(1,n):
#2パターンの遷移を考え小さいほうを保存する
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]) |
p03160 | s026478886 | Accepted | n=int(input())
z=list(map(int,input().split()))
ans=[0,abs(z[1]-z[0])]
for i in range(2,len(z)):
ans.append(min(abs(z[i]-z[i-1])+ans[-1],abs(z[i]-z[i-2])+ans[-2]))
print(ans[-1])
|
p03160 | s478813434 | Accepted | def main():
n = int(input())
hs = list(map(int, input().split()))
INF = 10 ** 12
dp = [INF] * n
dp[0] = 0
dp[1] = abs(hs[1] - hs[0])
for i in range(2, n):
dp[i] = min(dp[i], dp[i - 1] + abs(hs[i] - hs[i - 1]))
dp[i] = min(dp[i], dp[i - 2] + abs(hs[i] - hs[i - 2]))
print(dp[-1])
if __name__ == "__main__":
main()
|
p03160 | s251374233 | Accepted | n=int(input())
h=list(map(int, input().split()))
dp=[0]*n
dp[1]=abs(h[1]-h[0])
for i in range(2, n):
a=abs(h[i]-h[i-1])
b=abs(h[i]-h[i-2])
dp[i]=min((dp[i-1]+a), (dp[i-2]+b))
print(dp[n-1]) |
p03160 | s773854475 | Accepted | n = int(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 | s038807488 | Accepted | n = int(input())
h = [int(i) for i in input().split()]
dp = [0, abs(h[1] - h[0])] + [-1 for i in range(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[-1])
|
p03160 | s598882459 | Accepted | # -*- coding: utf-8 -*-
N = int(input().strip())
h_list = list(map(int, input().rstrip().split()))
#-----
cost = [0]*N
cost[1] = abs(h_list[1] - h_list[0])
for i in range(2,N):
cost1 = cost[i-1] + abs(h_list[i] - h_list[i-1])
cost2 = cost[i-2] + abs(h_list[i] - h_list[i-2])
cost[i] = min( cost1, cost2 )
print(cost[-1])
|
p03160 | s969377065 | Accepted | N = int(input())
h_list = list(map(int, input().split()))
dp = [0] * (N)
for i in range(1, N):
h1 = abs(h_list[i] - h_list[i-1])
h2 = abs(h_list[i] - h_list[i-2]) if i >= 2 else 10**9
dp[i] = min(dp[i-1] + h1, dp[i-2] + h2)
print(dp[-1]) |
p03160 | s072932026 | Accepted | n = int(input())
h = list(map(int,input().split()))
cost = [1000000 for i in range(n)]
cost[0] = 0
for i in range(1,n):
if i-1>=0 and i-2>=0:
cost[i] = min(cost[i-1]+abs(h[i]-h[i-1]),cost[i-2]+abs(h[i]-h[i-2]))
elif i-2<=0 and i-1>=0:
cost[i] = cost[i-1]+abs(h[i]-h[i-1])
else:
print("Error")
print(cost[n-1])
|
p03160 | s167538096 | Accepted | import sys
def mincost(n,h):
dp=[-1 for i in range(n)]
dp[n-1]=0
dp[n-2]=abs(h[n-2]-h[n-1])
for i in range(n-3,-1,-1):
dp[i]=min(dp[i+1]+abs(h[i+1]-h[i]),dp[i+2]+abs(h[i+2]-h[i]))
return dp[0]
n=int(input())
h=[int(x) for x in input().split()]
print(mincost(n,h)) |
p03160 | s805606381 | Accepted | def I(): return int(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 | s939600810 | Accepted | N=int(input())
h_array=input().split()
dp=[0]*N
dp[0]=0
dp[1]=abs(int(h_array[0])-int(h_array[1]))
for n in range(2,N):
dp[n] =min(abs(int(h_array[n])-int(h_array[n-1]))+dp[n-1],abs(int(h_array[n])-int(h_array[n-2]))+dp[n-2])
print(dp[-1]) |
p03160 | s102124640 | Accepted | n=int(input())
h=list(map(int,input().split()))
#dp[i]はiに来たときのコストの総和の最小値
dp=[float('inf')]*n
dp[0]=0
dp[1]=abs(h[0]-h[1])+dp[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 | s946903834 | Accepted | n = int(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]) |
p03160 | s717972830 | Accepted | n=int(input())
h=list(map(int,input().split()))
dp=[0]*n
def dis(a,b):
return abs(h[a]-h[b])
dp[1]=dis(1,0)
for i in range(2,n):
dp[i]=min(dp[i-1]+dis(i,i-1),dp[i-2]+dis(i,i-2))
print(dp[-1]) |
p03160 | s544121393 | Accepted | N = int(input())
h = list(map(int, input().split()))
INF = 10 ** 9
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], 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 | s517492195 | Accepted | n=int(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]) |
p03160 | s597679175 | Accepted | N = int(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 | s661454848 | Accepted | def min_cost():
# Translation of Errichto's solution
len_costs = input()
costs = input().split(' ')
costs = list(map(int, costs))
dp = [float('inf') for i in range(len(costs))]
dp[0] = 0
for i in range(len(costs)):
for j in [i + 1, i + 2]:
if j < len(costs):
dp[j] = min(dp[j], dp[i] + abs(costs[i] - costs[j]))
print(dp[-1])
min_cost()
# min_cost([10, 30, 40, 20])
# min_cost([10, 10])
# min_cost([30, 10, 60, 10, 60, 50])
|
p03160 | s878204795 | Accepted | n=int(input())
arr=list(map(int, input().split()))
cost=[0 for _ in range(n+1)]
cost[2]=abs(arr[1]-arr[0])
for stone in range(3, n+1):
cost[stone]=min(cost[stone-1]+abs(arr[stone-1]-arr[stone-2]), cost[stone-2]+abs(arr[stone-1]-arr[stone-3]))
print(cost[n]) |
p03160 | s019591797 | Accepted | a=int(input())
b=list(map(int,input().split()))
c=[0,abs(b[0]-b[1])]
for i in range(2,a):
d=min(c[i-2]+abs(b[i-2]-b[i]),c[i-1]+abs(b[i-1]-b[i]))
c.append(d)
print(c[a-1]) |
p03160 | s097587812 | Accepted |
"""
dp[i] : 足場iに到達するにあたって、たどり着く最小回数
"""
INF = 10**10
dp = [INF]*110000
N = int(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 | s816459270 | Accepted | N = int(input())
H = list(map(int,input().split()))
DP = [0]
for i in range(1,N):
a = DP[i-1] + abs(H[i]-H[i-1])
b = DP[i-2] + abs(H[i]-H[i-2]) if i>1 else float("inf")
DP.append(min(a,b))
print(DP[N-1]) |
p03160 | s322375625 | Accepted | n=int(input())
h=list(map(int,input().split()))
dp=[0]*n
rage=range #lol
for i in rage(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 | s760325090 | Accepted | def main():
n = int(input())
hs = tuple(map(int, input().split()))
a, b = 0, abs(hs[1] - hs[0])
for i in range(2, n):
d1 = a + abs(hs[i] - hs[i-2])
d2 = b + abs(hs[i] - hs[i-1])
a, b = b, d1 if d1 <= d2 else d2
print(b)
if __name__ == "__main__":
main() |
p03160 | s288198000 | Accepted | N = int(input())
h = [0] * (2*N)
h[:N] = list(map(int, input().split()))
INF = 10**9
dp = [INF] * (2*N)
dp[0] = 0
for i in range(N):
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 | s257176830 | Accepted | n = int(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 | s413202255 | Accepted | N = int(input())
h = list(map(int, input().split()))
dp = [float('inf') for _ in range(N)]
dp[0] = 0
for i in range(N):
if i - 1 >= 0:
if dp[i - 1] + abs(h[i] - h[i - 1]) < dp[i]:
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1])
if i - 2 >= 0:
if dp[i - 2] + abs(h[i] - h[i - 2]) < dp[i]:
dp[i] = dp[i - 2] + abs(h[i] - h[i - 2])
print(dp[N-1]) |
p03160 | s429530421 | Accepted | N = int(input())
H = list(map(int, input().split()))
points = [0]*N
points[1] = abs(H[1]-H[0])
for i in range(2,N):
points[i] = min(points[i-2]+abs(H[i-2]-H[i]), points[i-1]+abs(H[i-1]-H[i]))
print(points[-1]) |
p03160 | s720006678 | Accepted | # A - Frog 1
def main():
N, *H = 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 | s301640472 | Accepted | def ch_min(a, b):
if (a > b):
a = b
return a
if __name__ == "__main__":
N = int(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])
|
p03160 | s725148993 | Accepted | n = int(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 - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]))
print(dp[n - 1]) |
p03160 | s915207902 | Accepted | def aminch(dp, pot, dp_1, pot_1): # Absolute MINimum CHanging
return min(dp, abs(pot-pot_1)+dp_1)
N = int(input())
h = tuple(map(int, input().split()))
dp = [float("INF")]*N
dp[0], dp[1] = 0, abs(h[0]-h[1])
for i in range(2, N):
dp[i] = aminch(dp[i], h[i], dp[i-1], h[i-1])
dp[i] = aminch(dp[i], h[i], dp[i-2], h[i-2])
print(dp[-1]) |
p03160 | s519831095 | Accepted | n = int(input())
h = list(map(int, input().split()))
INF = 10 ** 18
dp = [INF] * n
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i, (e1, e2, e3) in enumerate(zip(h, h[1:], h[2:]), 2):
dp[i] = min(dp[i], dp[i-1] + abs(e3 - e2), dp[i-2] + abs(e3 - e1))
ans = dp[-1]
print(ans)
|
p03160 | s089314112 | Accepted | n = int(input())
lst1 = list(map(int,input().split()))
dp = [0]*n
dp[1] = abs(lst1[1]-lst1[0])
for i in range(2,n):
dp[i] = min(dp[i-1]+abs(lst1[i]-lst1[i-1]),dp[i-2]+abs(lst1[i]-lst1[i-2]))
print(dp[-1]) |
p03160 | s989905480 | Accepted | N = int(input())
h = list(map(int, input().split()))
dp = [0] * 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]) |
p03160 | s907260510 | Accepted | N = int(input())
HS = [int(i) for i in input().split()]
dp = [float('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 | s901374134 | Accepted | def solve(N,h):
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]))
return dp[N-1]
N=int(input())
h=list(map(int,input().split()))
print(solve(N,h)) |
p03160 | s045902499 | Accepted | n = int(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 | s627577874 | Accepted | N=int(input())
h=list(map(int, input().split()))
h=[0]+h
dp=[10*10]*(N+1)
dp[1]=0
for n in range(2,N+1):
if n>2:
dp[n]=min(dp[n-1]+abs(h[n-1]-h[n]),dp[n-2]+abs(h[n-2]-h[n]))
else:
dp[n]=dp[n-1]+abs(h[n]-h[n-1])
print(dp[N])
|
p03160 | s701045294 | Accepted | N = int(input())
h = list(map(int, input().split()))
dp_h = [0] * N
dp_h[1] = abs(h[0] - h[1])
for i in range(2,N):
p_1 = abs(h[i] - h[i-1]) + dp_h[i-1]
p_2 = abs(h[i] - h[i-2]) + dp_h[i-2]
dp_h[i] = min(p_1, p_2)
print(dp_h[N-1]) |
p03160 | s213169653 | Accepted | N=int(input())
h = list(map(int,input().split()))
dp= [0]*N
for i in range(N):
if i == 0:
continue
if i == 1:
dp[1] = abs(h[0] - h[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 | s390587359 | Accepted | size = int(input())
arr = list(map(int, input().split()))
dp = [0]*(size)
dp[0] = 0
dp[1] = abs(arr[1] - arr[0])
for i in range(2,size):
dp[i] = min(dp[i-1] + abs(arr[i-1]-arr[i]), dp[i-2] + abs(arr[i-2]- arr[i]))
print(dp[size-1])
|
p03160 | s834352879 | Accepted | N = int(input())
H = list(map(int, input().split()))
H = [0] + H
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-2] + abs(H[i-2] - H[i]), dp[i-1] + abs(H[i-1] - H[i]))
print(dp[N]) |
p03160 | s458892445 | Accepted | n=int(input())
l=list(map(int,input().split()))
k=[0]*n
k[0]=0
k[1]=abs(l[1]-l[0])
for i in range(2,n):
k[i]=min(k[i-1]+abs(l[i]-l[i-1]),k[i-2]+abs(l[i]-l[i-2]))
print(k[n-1]) |
p03160 | s818406345 | Accepted | N = int(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 | s558987458 | Accepted | n = int(input())
h = list(map(int,input().strip().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-2]-h[i]), dp[i-1] + abs(h[i-1]-h[i]))
print(dp[n-1]) |
p03160 | s092494083 | Accepted | n = int(input())
pedras = list(map(int,input().split()))
dp = [0] * n
dp[0] = 0
dp[1] = abs(pedras[0] - pedras[1])
for i in range(2,n):
custo1 = dp[i-1] + abs(pedras[i-1] - pedras[i])
custo2 = dp[i-2] + abs(pedras[i-2] - pedras[i])
dp[i] = min(custo1,custo2)
print(dp[n-1])
|
p03160 | s414666716 | Accepted | n = int(input())
lis = list(map(int, input().split()))
dp = [0 for _ in range(n)]
for i,d in enumerate(dp):
if i == 0:
continue
if i == 1:
dp[1] = abs(lis[1]-lis[0])
continue
dp[i] = min((dp[i-2]+abs(lis[i-2]-lis[i])),(dp[i-1]+abs(lis[i-1]-lis[i])))
#print(dp)
print(dp[-1]) |
p03160 | s184441938 | Accepted | n=int(input())
arr=list(map(int,input().split()))
dp=[0]*len(arr)
dp[0]=0
dp[1]=abs(arr[1]-arr[0])
for i in range(2,len(arr)):
dp[i]=min((dp[i-1]+abs(arr[i-1]-arr[i])),(dp[i-2]+abs(arr[i-2]-arr[i])))
print(dp[len(arr)-1]) |
p03160 | s962507580 | Accepted | N = int(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]) |
p03160 | s057076242 | Accepted | N = int(input())
H = list(map(int, input().split()))
L = [0]*N
L[1]=abs(H[1]-H[0])
for i in range(2, N):
L[i] = min(L[i-1]+abs(H[i]-H[i-1]), L[i-2]+abs(H[i]-H[i-2]))
print(L[-1]) |
p03160 | s339812720 | Accepted | n = int(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):
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]) |
p03160 | s730411366 | Accepted | n = int(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] = abs(h[i - 1]- h[i])
else:
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 | s872788620 | Accepted | n = int(input())
H = [0]+list(map(int,input().split()))
if n >= 3:
dp = [0]*(n+1)
dp[2] = abs(H[2]-H[1])
dp[3] = min(abs(H[3]-H[2])+dp[2], abs(H[3]-H[1]))
for i in range(4,n+1):
dp[i] = min(abs(H[i]-H[i-1])+dp[i-1], abs(H[i]-H[i-2])+dp[i-2])
print(dp[n])
else:
print(abs(H[2]-H[1])) |
p03160 | s508603264 | Accepted | n = int(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])
|
p03160 | s493757067 | Accepted | N = int(input())
H = list(map(int, input().split()))
B = [0]*N
B[1]=abs(H[1]-H[0])
for i in range(2, N):
B[i] = min(B[i-2]+abs(H[i]-H[i-2]), B[i-1]+abs(H[i]-H[i-1]))
print(B[N-1]) |
p03160 | s694025638 | Accepted | n = int(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 | s704395640 | Accepted | def main():
n, height = getInputs()
cost = [0] * n
cost[1] = abs(height[0] - height[1])
for i in range(2, n):
cost[i] = min(
cost[i - 1] + abs(height[i] - height[i - 1]),
cost[i - 2] + abs(height[i] - height[i - 2])
)
print(cost[-1])
def getInputs():
return int(input()), tuple(map(lambda x: int(x), input().split()))
main()
|
p03160 | s173031334 | Accepted | n = int(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 | s681982086 | Accepted | N = int(input())
h = list(map(int, input().split()))
dp = [-1] * N
for x in range(N):
if x == 0:
dp[0] = 0
elif x == 1:
dp[1] = abs(h[1] - h[0])
else:
dp[x] = min(abs(h[x] - h[x - 1]) + dp[x - 1],
abs(h[x] - h[x - 2]) + dp[x - 2])
print(dp[N - 1])
|
p03160 | s443547076 | Accepted | N = int(input())
H = list(map(int, input().split()))
INF = 10000000000
dp = [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 - 3:
dp[i + 2] = min(dp[i + 2], dp[i] + abs(H[i] - H[i + 2]))
print(dp[N - 1]) |
p03160 | s731455269 | Accepted | n = int(input())
heights = list(map(int, input().split()))
dp = [float('inf') for i in range(n)]
dp[0] = 0
for i in range(1, n):
dp[i] = min(dp[i], dp[i - 1] + abs(heights[i] - heights[i - 1]))
if i > 1:
dp[i] = min(dp[i], dp[i - 2] + abs(heights[i] - heights[i - 2]))
print(dp[n - 1])
|
p03160 | s824882514 | Accepted | N=int(input())
dp=[float('inf') for i in range(N+1)]
l=[int(x) for x in input().rstrip().split()]
dp[0]=0
dp
for i in range(1,N):
if i==1:
dp[i]=dp[i-1]+abs(l[i]-l[i-1])
else:
dp[i]=min(dp[i-1]+abs(l[i]-l[i-1]),dp[i-2]+abs(l[i]-l[i-2]))
print(dp[N-1])
|
p03160 | s602073680 | Accepted | N = int(input())
H = list(map(int, input().split()))
minlist = [0]*N
minlist[0] = 0
minlist[1] = abs(H[1] - H[0])
for i in range(2,N):
minlist[i] = min(minlist[i-2] + abs(H[i-2] - H[i]), minlist[i-1] + abs(H[i-1] - H[i]))
print(minlist[N-1]) |
p03160 | s259966151 | Accepted | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N = int(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])
ans = dp[-1]
print(ans) |
p03160 | s088736935 | Accepted | N = int(input())
list = [int(i) for i in input().split(" ")]
def cost(N):
dp = [0] * N
dp[0] = 0
dp[1] = abs(list[1]-list[0])
for i in range(2,N):
dp[i] = min([dp[i-1]+abs(list[i-1]-list[i]),dp[i-2]+abs(list[i-2]-list[i])])
return dp[N-1]
print(cost(N)) |
p03160 | s490445232 | Accepted | def chmin(DP,b,i):
if (DP[i]> b):
DP[i] = b
return True
return False
N = int(input())
H = [i for i in map(int,input().split())]
dp = [10**10 for i in range(N)]
dp[0] = 0
for i in range(1,N):
chmin(dp,dp[i-1]+abs(H[i]-H[i-1]),i)
if i > 1:
chmin(dp,dp[i-2]+abs(H[i]-H[i-2]),i)
print(dp[-1])
|
p03160 | s888284186 | Accepted | import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
sys.setrecursionlimit(1000000)
# do magic here
n = int(input())
heights = [int(x) for x in input().split()]
MAX = 10000000
dp = {}
def solve(x):
if x==0:
return 0
if x < 0:
return MAX
if x in dp:
return dp[x]
a = abs(heights[x-1] - heights[x]) + solve(x-1)
b = abs(heights[x-2] - heights[x]) + solve(x-2)
dp[x] = min(a,b)
return dp[x]
print(solve(n-1))
|
p03160 | s752025141 | Accepted | # -*- coding: utf-8 -*-
"""
Created on Tue Jan 21 16:49:00 2020
@author: matsui
"""
def cost(i,j):
return abs(int(h[i])-int(h[j]))
N=int(input())
h=input().split()
dp=[0]*N
dp[1]=cost(0,1)
for i in range(2,N):
dp[i]=min(cost(i,i-1)+dp[i-1],cost(i,i-2)+dp[i-2])
print(dp[N-1]) |
p03160 | s004982389 | Accepted | n = int(input())
ar = list(map(int,input().split(" ")))
br = [0]
for i in range(n):
if i == 1:
br.append(abs(ar[i-1] - ar[i]))
elif i != 0:
a = br[-2] + abs(ar[i-2] - ar[i])
b = br[-1] + abs(ar[i-1] - ar[i])
br.append(min(a,b))
print(br[-1])
|
p03160 | s141122893 | Accepted | n = int(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 | s533406234 | Accepted | n = int(input())
h = list(map(int, input().split()))
INF = 1000000000
h += [INF] * 2
#最小値(コスト)を求める問題のため、DP配列を無限大に初期化
dp = [INF] * (n + 2)
#0番目の地点はコスト0
dp[0] = 0
for i in range(n):
#もらうDPとやらで実装
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 | s874712459 | Accepted | N = int(input())
h_list = list(map(int, input().split()))
dp = [float('INF') for i in range(N)]
dp[0] = 0
def calc_cost(now, next):
global h_list
global dp
global N
if next > N - 1: return
if dp[next] > dp[now] + abs(h_list[next] - h_list[now]):
dp[next] = dp[now] + abs(h_list[next] - h_list[now])
return
for i in range(N):
calc_cost(i, i + 1)
calc_cost(i, i + 2)
print(dp[N - 1]) |
p03160 | s394694287 | Accepted | N = int(input())
h = list(map(int, input().split()))
inf = 10**9
dp = [0] + [inf]*N
for i in range(1,N):
if i == 1:
dp[1] = 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 | s727620551 | Accepted | n = int(input())
arr = input().split()
arr = list(map(int, arr))
arr = [arr[0]] + arr
dp = [0]*len(arr)
dp[0] = 0
dp[1] = 0
for i in range(2, n+1):
dp[i] = min(dp[i-2]+ abs(arr[i] - arr[i-2]), dp[i-1] + abs(arr[i] - arr[i-1]))
print(dp[n])
|
p03160 | s769369649 | Accepted | n = int(input())
h = list(map(int,input().split()))
INF = float('inf')
dp = [INF] * n
dp[0] = 0
dp[1] = abs(h[1] - h[0])
def chmin(a, b):
if a <= b:
return a
else:
return b
for i in range(2, n):
dp[i] = chmin(dp[i], dp[i - 2] + abs(h[i - 2] - h[i]))
dp[i] = chmin(dp[i], dp[i - 1] + abs(h[i - 1] - h[i]))
print(dp[n - 1])
|
p03160 | s120715877 | Accepted | def main():
n = int(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() |
p03160 | s691542476 | Accepted | n = int(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-2]+abs(l[i]-l[i-2]), dp[i-1]+abs(l[i]-l[i-1]))
print(dp[n-1]) |
p03160 | s458214107 | Accepted | n=int(input())
l=list(map(int,input().split()))
a=0
b=abs(l[0]-l[1])
for i in range(2,n):
h1=a+abs(l[i]-l[i-2])
h2=b+abs(l[i]-l[i-1])
a=b
b=min(h1,h2)
print(b) |
p03160 | s874183224 | Accepted | import sys
N = int(sys.stdin.readline())
h = [int(hi) for hi in sys.stdin.readline().split(' ')]
dp = [1000000 * N] * 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])
|
p03160 | s593131843 | Accepted | n = int(input())
ln = list(map(int, input().split()))
min_ln = []
for i in range(n):
if i == 0:
min_ln.append(0)
elif i == 1:
min_ln.append(abs(ln[1] - ln[0]))
else:
min_ln.append(min(abs(ln[i] - ln[i-1]) + min_ln[i-1], abs(ln[i] - ln[i-2]) + min_ln[i-2]))
print(min_ln[-1]) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.