I. Степан і кубики

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define pb push_back
#define int long long
#define mp make_pair
#define left left_compile
#define right right_compile

const int INF = (int)1e15;
const int md = (int)1e9 + 7;
const int MAXN = (int)1e5 + 10;
const int N = (int)2e5 + 1111;
const int debug = 0;

typedef tree<
int,
null_type,
less_equal<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;

mt19937 rnd(time(nullptr));

vector<vector<int>> t(4*N);
vector<vector<int>> pr(4*N);
vector<int> sum(4*N);
int a[N];

vector<int> ans;

vector<int> Mg(vector<int> a,vector<int> b){
    ans.clear();
    int id[2];
    id[0] = id[1] = 0;
    int sz[2];
    sz[0] = a.size(), sz[1] = b.size();
    while(id[0] < sz[0] && id[1] < sz[1]){
        if(a[id[0]] < b[id[1]])
            ans.pb(a[id[0]++]);
        else
            ans.pb(b[id[1]++]);
    }
    while(id[0] < sz[0])
        ans.pb(a[id[0]++]);
    while(id[1] < sz[1])
        ans.pb(b[id[1]++]);
    return ans;
}

void build(int v,int l,int r){
    if(l > r)
        return;
    if(l == r){
        t[v].pb(a[l]);
        pr[v] = t[v];
        sum[v] = a[l];
        return;
    }
    int m = (r + l) / 2;
    build(v<<1,l,m);
    build(v<<1|1,m+1,r);
    t[v] = Mg(t[v<<1],t[v<<1|1]);
    sum[v] = sum[v<<1] + sum[v<<1|1];
    pr[v] = t[v];
    for(int i = 1; i < pr[v].size(); i++){
        pr[v][i] += pr[v][i-1];
    }
    return;
}

int ask(int v,int l,int r,int tl,int tr,int M){
    if(l > r || tl > tr)
        return 0;
    if(l == tl && r == tr){
        if(t[v].back() <= M){
            return (r-l+1) * M - sum[v];
        }
        if(t[v][0] > M){
            return sum[v] - (r - l + 1) * M;
        }
        int id = upper_bound(t[v].begin(),t[v].end(),M) - t[v].begin();
        id--;
        return M * (id + 1) - pr[v][id] + (sum[v] - pr[v][id]) - M * (r-l-id);
    }
    int m = (l + r) / 2;
    return ask(v<<1,l,m,tl,min(tr,m),M) + ask(v<<1|1,m+1,r,max(m+1,tl),tr,M);
}

vector<int> get(int v,int l,int r,int tl,int tr){
    if(l > r || tl > tr)
        return vector<int>();
    if(l == tl && r == tr)
        return t[v];
    int m = (l + r) / 2;
    return Mg(get(v<<1,l,m,tl,min(tr,m)),get(v<<1|1,m+1,r,max(m+1,tl),tr));
}

int n,m;

void myerase(ordered_set& st, int v){
    int r = st.order_of_key(v);
    auto it = st.find_by_order(r);
    st.erase(it);
    return;
}

void solve_case(){

    cin >> n >> m;

    for(int i = 0; i < n; i++){
        cin >> a[i];
    }

    build(1,0,n-1);

    vector<int> cur;
    ordered_set st;

    for(int i = 0; i < m; i++){
        st.insert(a[i]);
    }

    int ans = INF;

    int k = 0;
    while(2 * (k + 1) - m < 0)
        k++;

    ans = min(ans,ask(1,0,n-1,0,m-1,*st.find_by_order(k)));

    for(int i = m; i < n; i++){
        myerase(st,a[i-m]);
        st.insert(a[i]);
        auto it = st.find_by_order(k);
        int t = *it;
        ans = min(ans,ask(1,0,n-1,i-m+1,i,t));
    }

    cout << ans;

    return;
}

signed main(){
    ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
//    freopen("input.txt","r",stdin);
//    freopen("output.txt","w",stdout);

    init();

    int t = 1;
//    cin >> t;

    for(int _ = 1; _ <= t; _++){
//        n = _;
        solve_case();
    }

    return 0;
}

/*
..........
.#........
.#........
.#........
..........
..........
..........
..........
..........
.........#

*/