{-# OPTIONS_GHC -O2 #-}
{-# LANGUAGE BangPatterns #-}
import qualified Control.Arrow         as Arrow
import qualified Control.Monad         as Monad
import qualified Data.Bits             as Bits
import qualified Data.ByteString.Char8 as BSC8
import qualified Data.Char             as Char
import qualified Data.List             as List
import qualified Data.Vector.Unboxed   as VU

inf :: Int
inf = 2 ^ 20

main :: IO ()
main = do
    (!n, !k) <- getAB
    !xv <- getAN n -- VU.Vector Int
    print $ solver xv k (n - 1)

data FlogTreeF a
    = Flog !Int !(Maybe a)
instance Functor FlogTreeF where
    fmap f (Flog x Nothing)  = Flog x Nothing
    fmap f (Flog x (Just y)) = Flog x (Just (f y))

solver :: VU.Vector Int -> Int -> Int -> Int
solver !xv k = dyna phi psi
    where
        psi 0 = Flog (xv VU.! 0) Nothing
        psi i = Flog (xv VU.! i) (Just (i - 1))

        {-
        dp[i] := 足場iに到着したときの最小のコスト
        i-1 から来る場合 + そこからのコスト
        i-2 から来る場合 + そこからのコスト
        ...
        i-k から来る場合 + そこからのコスト
        のうち小さいものを選ぶ
        
        跡を辿る関数 trace を工夫して実装する
        -}
        phi (Flog h Nothing)  = 0 -- 最初は0なので dp[0] = 0
        phi prev@(Flog h (Just t)) = trace inf h prev k

        -- 現在の最小値をmとして保存しておき (初期値は1024*1024)
        -- 一つ戻るごとに更新していく
        trace m o (Flog _ (Just t)) 1 = case sub t of
            Flog h' _ -> min m (extract t + abs (o - h')) -- kを走査し終えたら次のノードに入っている値がdp[h]となる
        trace m o (Flog _ Nothing) i = m -- すべて走査し終えたら保存していたmが答え
        trace m o (Flog _ (Just t)) i = case sub t of -- dp[h-1]を調べる
            prev@(Flog h' ts) -> trace (min m (extract t + abs (o - h'))) o prev (i - 1)


-- * 入出力
getI :: BSC8.ByteString -> Maybe (Int, BSC8.ByteString)
getI = fmap (Arrow.second BSC8.tail) . BSC8.readInt
getAB :: IO (Int, Int)
getAB = (\vec -> (vec VU.! 0, vec VU.! 1)) . VU.unfoldrN 2 getI <$> BSC8.getLine
getAN :: Int -> IO (VU.Vector Int)
getAN n = VU.unfoldrN n getI <$> BSC8.getLine

-- ! 射
newtype Fix f
    = InF { outF :: f (Fix f) }

pair :: (a -> b, a -> c) -> a -> (b, c)
pair (f, g) x = (f x, g x)

-- ! 下方射
cata :: Functor f => (f a -> a) -> (Fix f -> a)
cata phi = phi . fmap (cata phi) . outF
-- ! 上方射
ana  :: Functor f => (b -> f b) -> (b -> Fix f)
ana psi = InF . fmap (ana psi) . psi
-- ! 双方射
hylo :: Functor f => (f b -> b) -> (a -> f a) -> (a -> b)
hylo phi psi = cata phi . ana psi

-- * 未来用データ(直和)
data Fx f a x
    = Fx { unFx :: Either a (f x) }
-- * 過去用データ（直積）
data Hx f a x
    = Hx { unHx :: (a, f x) }

-- * Fx f a は関手
instance Functor f => Functor (Fx f a) where
    fmap f (Fx (Left x))  = Fx (Left x)
    fmap f (Fx (Right x)) = Fx (Right (fmap f x))
-- * Hx f a は関手
instance Functor f => Functor (Hx f a) where
    fmap f (Hx (x, y)) = Hx (x, fmap f y)

-- * Fx f a の不動点
newtype Free f a
    = Free { unFree :: Fix (Fx f a) }
-- * Hx f a の不動点
newtype CoFree f a
    = CoFree { unCoFree :: Fix (Hx f a) }

-- * Free f は関手
instance Functor f => Functor (Free f) where
    fmap f = Free . cata (InF . phi) . unFree
        where
            phi (Fx (Left a))  = Fx (Left (f a))
            phi (Fx (Right b)) = Fx (Right b)
-- * CoFree f は関手
instance Functor f => Functor (CoFree f) where
    fmap f = CoFree . ana (psi . outF) . unCoFree
        where
            psi (Hx (a, x)) = Hx (f a, x)

-- * Free と CoFree の情報を出し入れする関数
extract :: Functor f => CoFree f t -> t
extract cf = case outF (unCoFree cf) of
    Hx (a, _) -> a

sub :: Functor f => CoFree f a -> f (CoFree f a)
sub cf = case outF (unCoFree cf) of
    Hx (_, b) -> fmap CoFree b

inject :: Functor f => a -> Free f a
inject = Free
        . InF
        . Fx
        . Left

-- ! 時空射
chrono :: Functor f => (f (CoFree f b) -> b) -> (a -> f (Free f a)) -> (a -> b)
chrono phi psi = extract . hylo phi' psi' . inject
    where
        phi' = CoFree
            . InF
            . fmap unCoFree
            . Hx
            . pair (phi, id)
        psi' = uncurry either (psi, id)
            . unFx
            . fmap Free
            . outF
            . unFree

-- ! dp射
dyna :: Functor f => (f (CoFree f b) -> b) -> (a -> f a) -> (a -> b)
dyna phi psi = chrono phi (fmap inject . psi)