#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <map>
#include <cmath>
#include <algorithm>
#include <stack>
#include <climits>
#include <queue>
using namespace std;
//
//int n, m;
//bool vaild(int i, int j)
//{
//    return i >= 0 && i <= n - 1 && j >= 0 && j <= m - 1;
//}
//
//int xcor[] = { 1,-1 , 0 , 0 };
//int ycor[] = { 0,0 , 1 , -1 };
//
//
//long long maxSubArraySum(vector<long long >& a, long long start, long long  end)
//{
//    long long max_so_far = a[start];
//    long long curr_max = a[start];
//    for (int i = 0; i < end; i++)
//    {
//        curr_max += a[i];
//        if (curr_max < a[i])
//        {
//            curr_max = a[i];
//        }
//        max_so_far = max(max_so_far, curr_max);
//    }
//    return max_so_far;
//}
//
//
//long long gcd(long long a, long long b)
//{
//    if (b == 0)
//        return a;
//    return gcd(b, a % b);
//
//}
//
//
//long long lcm(long long a, long long b)
//{
//    return a * b / gcd(a, b);
//}
//
//
//
//int fastpow(int b, int p) {
//    if (p == 1)	return b;
//    int sq = pow(b, p / 2);
//    sq = sq * sq;
//
//    if (p % 2 == 1)
//        sq = sq * b;
//
//    return sq;
//}


//
//int grid[500][500];
//int n = 50;
//int targetx = 5;
//int targety = 5;
//
//int maxSum(int i, int j)
//{
//    if (i < 0 || i >= n || j < 0 || j >= n )
//    {
//        return 0;
//    }
//    if (i == targetx && j == targety)
//    {
//        return grid[i][j];
//    }
//    int sum1;
//    int sum2;
//    if (dp[i][j+1] != -1)
//    {
//        return dp[i][j + 1];
//    }
//    if (dp[i+1][j] != -1)
//    {
//        return dp[i+1][j ];
//    }
//    sum1 = maxSum(i, j + 1);
//    sum2 = maxSum(i, j + 1);
//    return dp[i][j] = grid[i][j] + max(sum1, sum2);
//}



//int dp[500][500];
//int RecuSum(int index, int curSum)
//{
//    if (dp[index][curSum] = -1)
//    {
//        return dp[index][curSum];
//    }
//    if (index == sum.size() )
//    {
//        return curSum % 7  == 0;
//    }
//    if (dp[index][curSum] = RecuSum(index + 1, curSum + sum[index]) || RecuSum(index + 1, curSum - sum[index]))
//    {
//        return dp[index][curSum];
//    }
//    return dp[index][curSum];
//}

// 0 0 -> 1 1
// 1 1 -> 2 6


//const int MAX = 21;
//const int N = 3;
//int minimumCost = INT_MAX;
//int r[MAX];
//int g[MAX];
//int b[MAX];
//int dp[MAX][MAX];

//
//int minCost (int lastColor , int i)
//{
//    
//    if (i == N)
//    {
//        return 0;
//    }
//    int& minimumCost = dp{i][lastColor];
//    if (minimumCost != -1)
//    {
//        return minimumCost;
//    }
//
//    minimumCost = INT_MAX;
//
//    if(minimumCost)
//    if (lastColor != 0)
//    {
//        minimumCost = min(r[i]+minCost(0, i + 1) , minimumCost);
//    }
//    if (lastColor != 1  )
//    {
//        minimumCost = min(g[i]+minCost(1, i + 1), minimumCost);
//
//    }
//    if (lastColor != 2)
//    {
//        minimumCost = min(b[i]+minCost(2, i + 1), minimumCost);
//
//    }
//    return minimumCost;
//
//}











//int dp[5][101];
//int minimumReset(int index, int parenttype)
//{
//    if (index == n)
//    {
//        return 0;
//    }
//
//    int &r = dp[parenttype][index];
//    if (r != -1)
//    {
//        return r;
//    }
//    r = 0;
//    
//
//    if (parenttype != 3 || elements[index] == 0)
//    {
//        r = max(minimumReset(index + 1, 3), r);
//
//    }
//
//
//    if ((elements[index] == 1 || elements[index] == 3) && parenttype != 1)
//        r = max(minimumReset(index + 1, 1)+1, r);
//
//    if ((elements[index] == 2 || elements[index] == 3 )&& parenttype != 2)
//        r = max(minimumReset(index + 1, 2)+1, r);
//
//    return r;
//
//}
//

int k;
int n;
int elements[100001];

long long dp[100001];

long long minCost(int index)
{
    if (index == n - 1)
    {
        return 0;
    }

    long long &r = dp[index];

    if (r != -1)
    {
        return r;
    }
    r = LLONG_MAX;

    for (int i = 1; i <= k ; i++)
    {
        int next = index + i;
        if (next < n)
        {
            r = min(minCost(next) + abs(elements[index] - elements[next]), r);
        }
    }


    return r;


}







int main()
{
    cin >> n >> k;
    for (int i = 0; i < n; i++)
    {
        int a;
        cin >> a;
        elements[i] = a;
    }
    for (int i = 0; i < 100001; i++)
    {
          dp[i] = -1;
    }

    cout << minCost(0);
}




Measured memory_bytes: 11000