Buggy python submission (verdict: Runtime Error):
import numpy as np

N, K = map(int, input().split())
H = np.array([int(i) for i in input().split()])

dp = np.full(N, np.inf, int)
dp[0] = 0
for i in range(1, N):
    dp[i] = min(dp[max(i-K, 0):i]+np.abs(H[max(i-K, 0):i]-H[i]))
    
print(dp[N-1])

Fixed submission:
import numpy as np

# 入力
N, K = map(int, input().split())
H = np.array([int(i) for i in input().split()])

# ndarray型のDPテーブルを生成
dp = np.zeros(N, dtype=int)
# 初期値をセット
dp[0] = 0

# 各足場へたどり着く最小コストを調べる
for i in range(1, N):
    s = max(0, i-K)
    dp[i] = min(dp[s:i] + np.abs(H[i] - H[s:i])) # iより前の足場のコストに足す

print(dp[N-1])

Buggy python submission (verdict: Time Limit Exceeded):
import sys
input = sys.stdin.readline

# 入力
N, K = map(int, input().split())
H = [int(i) for i in input().split()]

# DPテーブルを用意
dp = [float("inf")] * N
# 初期値をセット
dp[0] = 0

# 足場0から順次最小コストを決定する
for i in range(1, N):
    # for j in range(1, K+1):
        # if i + j < N:
            # dp[i+j] = min(dp[i+j], (dp[i] + abs(H[i] - H[i+j])))
    dp[i] = min([dp[i-j] + abs(H[i] - H[i-j]) for j in range(1, min(K+1, i+1)) if i-j >= 0])

# 足場NのインデックスはN-1
print(dp[N-1])

Fixed submission:
import numpy as np

# 入力
N, K = map(int, input().split())
H = np.array([int(i) for i in input().split()])

# ndarray型のDPテーブルを生成
dp = np.zeros(N, dtype=int)
# 初期値をセット
dp[0] = 0

# 各足場へたどり着く最小コストを調べる
for i in range(1, N):
    s = max(0, i-K)
    dp[i] = min(dp[s:i] + np.abs(H[i] - H[s:i])) # iより前の足場のコストに足す

print(dp[N-1])

Buggy python submission (verdict: Time Limit Exceeded):
import sys
input = sys.stdin.readline

# 入力
N, K = map(int, input().split())
H = [int(i) for i in input().split()]

# DPテーブルを用意
dp = [float("inf")] * N
# 初期値をセット
dp[0] = 0

# 足場0から順次最小コストを決定する
for i in range(1, N):
    # for j in range(1, K+1):
        # if i + j < N:
            # dp[i+j] = min(dp[i+j], (dp[i] + abs(H[i] - H[i+j])))
    dp[i] = min([dp[i-j] + abs(H[i] - H[i-j]) for j in range(1, K+1) if i-j >= 0])

# 足場NのインデックスはN-1
print(dp[N-1])

Fixed submission:
import numpy as np

# 入力
N, K = map(int, input().split())
H = np.array([int(i) for i in input().split()])

# ndarray型のDPテーブルを生成
dp = np.zeros(N, dtype=int)
# 初期値をセット
dp[0] = 0

# 各足場へたどり着く最小コストを調べる
for i in range(1, N):
    s = max(0, i-K)
    dp[i] = min(dp[s:i] + np.abs(H[i] - H[s:i])) # iより前の足場のコストに足す

print(dp[N-1])

Buggy python submission (verdict: Time Limit Exceeded):
# 入力
N, K = map(int, input().split())
H = [int(i) for i in input().split()]

# DPテーブルを用意
dp = [float("inf")] * N
# 初期値をセット
dp[0] = 0

# 足場0から順次最小コストを決定する
for i in range(1, N):
    # for j in range(1, K+1):
        # if i + j < N:
            # dp[i+j] = min(dp[i+j], (dp[i] + abs(H[i] - H[i+j])))
    dp[i] = min([dp[i-j] + abs(H[i] - H[i-j]) for j in range(1, K+1) if i-j >= 0])

# 足場NのインデックスはN-1
print(dp[N-1])

Fixed submission:
import numpy as np

# 入力
N, K = map(int, input().split())
H = np.array([int(i) for i in input().split()])

# ndarray型のDPテーブルを生成
dp = np.zeros(N, dtype=int)
# 初期値をセット
dp[0] = 0

# 各足場へたどり着く最小コストを調べる
for i in range(1, N):
    s = max(0, i-K)
    dp[i] = min(dp[s:i] + np.abs(H[i] - H[s:i])) # iより前の足場のコストに足す

print(dp[N-1])

Buggy python submission (verdict: Time Limit Exceeded):
# 入力
N, K = map(int, input().split())
H = [int(i) for i in input().split()]

# DPテーブルを用意
dp = [float("inf") for i in range(N)]
# 初期値をセット
dp[0] = 0

# 足場0から順次最小コストを決定する
for i in range(1, N):
    # for j in range(1, K+1):
        # if i + j < N:
            # dp[i+j] = min(dp[i+j], (dp[i] + abs(H[i] - H[i+j])))
    dp[i] = min([dp[i-j] + abs(H[i] - H[i-j]) for j in range(1, K+1) if i-j >= 0])

# 足場NのインデックスはN-1
print(dp[N-1])

Fixed submission:
import numpy as np

# 入力
N, K = map(int, input().split())
H = np.array([int(i) for i in input().split()])

# ndarray型のDPテーブルを生成
dp = np.zeros(N, dtype=int)
# 初期値をセット
dp[0] = 0

# 各足場へたどり着く最小コストを調べる
for i in range(1, N):
    s = max(0, i-K)
    dp[i] = min(dp[s:i] + np.abs(H[i] - H[s:i])) # iより前の足場のコストに足す

print(dp[N-1])

Buggy python submission (verdict: Time Limit Exceeded):
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline

# 入力
N, K = map(int, input().split())
H = [int(i) for i in input().split()]

# メモ用のDPテーブル生成
dp = [float("inf") for i in range(N)]

# 初期値をセット
dp[0] = 0

# 足場iへたどり着く最小コストを返す
def rec(i):
    # ベースケース
    if i == 0:
        return 0
    
    # メモをチェック
    if dp[i] < float("inf"):
        return dp[i]
    
    # 足場iの最小コストの更新
    # for j in range(1, K+1):
        # if i - j >= 0:
            # 最小コストをメモ
            # dp[i] = min(dp[i], rec(i-j) + abs(H[i] - H[i-j]))
            
    dp[i] = min([rec(i-j) + abs(H[i] - H[i-j]) for j in range(1, K+1) if i - j >= 0])
    
    return dp[i]

print(rec(N-1))

Fixed submission:
import numpy as np

# 入力
N, K = map(int, input().split())
H = np.array([int(i) for i in input().split()])

# ndarray型のDPテーブルを生成
dp = np.zeros(N, dtype=int)
# 初期値をセット
dp[0] = 0

# 各足場へたどり着く最小コストを調べる
for i in range(1, N):
    s = max(0, i-K)
    dp[i] = min(dp[s:i] + np.abs(H[i] - H[s:i])) # iより前の足場のコストに足す

print(dp[N-1])

Buggy python submission (verdict: Time Limit Exceeded):
import sys
sys.setrecursionlimit(10**6)

# 入力
N, K = map(int, input().split())
H = [int(i) for i in input().split()]

# メモ用のDPテーブル生成
dp = [float("inf") for i in range(N)]

# 初期値をセット
dp[0] = 0

# 足場iへたどり着く最小コストを返す
def rec(i):
    # ベースケース
    if i == 0:
        return 0
    
    # メモをチェック
    if dp[i] < float("inf"):
        return dp[i]
    
    # 足場iの最小コストの更新
    # for j in range(1, K+1):
        # if i - j >= 0:
            # 最小コストをメモ
            # dp[i] = min(dp[i], rec(i-j) + abs(H[i] - H[i-j]))
            
    dp[i] = min([rec(i-j) + abs(H[i] - H[i-j]) for j in range(1, K+1) if i - j >= 0])
    
    return dp[i]

print(rec(N-1))

Fixed submission:
import numpy as np

# 入力
N, K = map(int, input().split())
H = np.array([int(i) for i in input().split()])

# ndarray型のDPテーブルを生成
dp = np.zeros(N, dtype=int)
# 初期値をセット
dp[0] = 0

# 各足場へたどり着く最小コストを調べる
for i in range(1, N):
    s = max(0, i-K)
    dp[i] = min(dp[s:i] + np.abs(H[i] - H[s:i])) # iより前の足場のコストに足す

print(dp[N-1])

Buggy python submission (verdict: Time Limit Exceeded):
import sys
sys.setrecursionlimit(10**6)

# 入力
N, K = map(int, input().split())
H = [int(i) for i in input().split()]

# メモ用のDPテーブル生成
dp = [float("inf") for i in range(N)]

# 初期値をセット
dp[0] = 0

# 足場iへたどり着く最小コストを返す
def rec(i):
    # ベースケース
    if i == 0:
        return 0
    
    # メモをチェック
    if dp[i] < float("inf"):
        return dp[i]
    
    # 足場iの最小コスト
    for j in range(1, K+1):
        if i - j >= 0:
            # 最小コストをメモ
            dp[i] = min(dp[i], rec(i-j) + abs(H[i] - H[i-j]))
    
    return dp[i]

print(rec(N-1))

Fixed submission:
import numpy as np

# 入力
N, K = map(int, input().split())
H = np.array([int(i) for i in input().split()])

# ndarray型のDPテーブルを生成
dp = np.zeros(N, dtype=int)
# 初期値をセット
dp[0] = 0

# 各足場へたどり着く最小コストを調べる
for i in range(1, N):
    s = max(0, i-K)
    dp[i] = min(dp[s:i] + np.abs(H[i] - H[s:i])) # iより前の足場のコストに足す

print(dp[N-1])

Buggy python submission (verdict: Time Limit Exceeded):
# 入力
N, K = map(int, input().split())
H = [int(i) for i in input().split()]

# DPテーブルを用意
dp = [float("inf") for i in range(N)]
# 初期値をセット
dp[0] = 0

# 足場0から順次最小コストを決定する
for i in range(N):
    for j in range(1, K+1):
        if i + j < N:
            dp[i+j] = min(dp[i+j], (dp[i] + abs(H[i] - H[i+j])))

# 足場NのインデックスはN-1
print(dp[N-1])

Fixed submission:
import numpy as np

# 入力
N, K = map(int, input().split())
H = np.array([int(i) for i in input().split()])

# ndarray型のDPテーブルを生成
dp = np.zeros(N, dtype=int)
# 初期値をセット
dp[0] = 0

# 各足場へたどり着く最小コストを調べる
for i in range(1, N):
    s = max(0, i-K)
    dp[i] = min(dp[s:i] + np.abs(H[i] - H[s:i])) # iより前の足場のコストに足す

print(dp[N-1])