#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

struct FenwickTree {
    int size;
    vector<long long> tree;

    FenwickTree(int n) : size(n), tree(n + 1, 0) {}

    void update(int idx, long long delta) {
        idx++;
        while (idx <= size) {
            tree[idx] += delta;
            idx += idx & -idx;
        }
    }

    long long query(int idx) {
        if (idx < 0) return 0;
        idx++;
        long long res = 0;
        while (idx > 0) {
            res += tree[idx];
            idx -= idx & -idx;
        }
        return res;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, K;
    cin >> N >> K;
    vector<int> A(N);
    for (int i = 0; i < N; i++) {
        cin >> A[i];
    }

    vector<int> sorted_A = A;
    sort(sorted_A.begin(), sorted_A.end());
    sorted_A.erase(unique(sorted_A.begin(), sorted_A.end()), sorted_A.end());
    int m = sorted_A.size();

    vector<int> rank_A(N);
    for (int i = 0; i < N; i++) {
        rank_A[i] = lower_bound(sorted_A.begin(), sorted_A.end(), A[i]) - sorted_A.begin();
    }

    FenwickTree cnt_bit(m), sum_bit(m);
    for (int i = 0; i < K; i++) {
        cnt_bit.update(rank_A[i], 1);
        sum_bit.update(rank_A[i], A[i]);
    }

    long long min_cost = LLONG_MAX;
    int required = (K + 1) / 2;

    auto compute_cost = [&]() {
        int low = 0, high = m - 1;
        int med_r = m - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            long long cnt = cnt_bit.query(mid);
            if (cnt >= required) {
                med_r = mid;
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        long long median = sorted_A[med_r];
        long long cnt_less = cnt_bit.query(med_r - 1);
        long long sum_less = sum_bit.query(med_r - 1);
        long long cnt_total_med = cnt_bit.query(med_r);
        long long sum_total = sum_bit.query(m - 1);
        long long sum_more = sum_total - sum_bit.query(med_r);
        long long cnt_more = K - cnt_total_med;
        return (median * cnt_less - sum_less) + (sum_more - median * cnt_more);
    };

    min_cost = compute_cost();

    for (int i = K; i < N; i++) {
        int left_r = rank_A[i - K];
        cnt_bit.update(left_r, -1);
        sum_bit.update(left_r, -A[i - K]);

        int right_r = rank_A[i];
        cnt_bit.update(right_r, 1);
        sum_bit.update(right_r, A[i]);

        long long current = compute_cost();
        if (current < min_cost) {
            min_cost = current;
        }
    }

    cout << min_cost << '\n';

    return 0;
}