#include <iostream>
#include <vector>
#include <fstream>
#include <cstdint>
#include <chrono>

class MaxSor_Korkoros {
public:
    MaxSor_Korkoros(size_t kapacitas)
        : kapacitas_{ kapacitas }
        , e_{ 0 }
        , v_{ 0 }
        , meret_{ 0 }
        , sor_(kapacitas_)
        , me_{ 1 }
        , mv_{ 0 }
        , mmeret_{ 0 }
        , msor_(kapacitas_) { }

    bool ures() const {
        return meret_ == 0;
    }

    uint64_t eleje() const {
        return sor_[e_];
    }

    uint64_t max() const {
        return msor_[mv_];
    }

    size_t meret() const {
        return meret_;
    }

    void sorba(uint64_t uj_elem) {
        while (mmeret_ > 0 && msor_[me_] < uj_elem) {
            me_ = me_ + 1 < kapacitas_ ? me_ + 1 : 0;
            --mmeret_;
        }
        me_ = me_ > 0 ? me_ - 1 : kapacitas_ - 1;
        msor_[me_] = uj_elem;
        ++mmeret_;

        sor_[v_] = uj_elem;
        v_ = v_ + 1 < kapacitas_ ? v_ + 1 : 0;
        ++meret_;
    }

    void sorbol() {
        const auto elem_ki = eleje();
        e_ = e_ + 1 < kapacitas_ ? e_ + 1 : 0;
        --meret_;

        if (msor_[mv_] == elem_ki) {
            mv_ = mv_ > 0 ? mv_ - 1 : kapacitas_ - 1;
            --mmeret_;
        }
    }

private:
    size_t kapacitas_;

    size_t e_, v_, meret_;
    std::vector<uint64_t> sor_;

    size_t me_, mv_, mmeret_;
    std::vector<uint64_t> msor_;
};

char be_buffer[2'200'100];
char *be_kov = be_buffer;

inline uint64_t kov_int() {
    int i = 0;
    for (; *be_kov < '0'; be_kov++) { }
    for (; *be_kov >= '0'; be_kov++) {
        i = i * 10 + *be_kov - '0';
    }

    return i;
}

namespace chr = std::chrono;

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

    std::cin.read(be_buffer, sizeof(be_buffer));

    const auto n = kov_int();
    const auto k = kov_int();

    MaxSor_Korkoros ms(k + 1);

    uint64_t koltseg = 0, min_koltseg = 0;
    ms.sorba(kov_int());
    for (int i = 1; i < n; i++) {
        const auto uj_elem = kov_int() + i;
        auto akt_max = ms.max();

        koltseg += uj_elem <= akt_max ? akt_max - uj_elem
                                      : (uj_elem - akt_max) * ms.meret();
        ms.sorba(uj_elem);

        if (ms.meret() > k) {
            akt_max = ms.max();
            const auto regi_elem = ms.eleje();

            koltseg -= regi_elem < akt_max ? akt_max - regi_elem : 0;
            ms.sorbol();
            koltseg -= (akt_max - ms.max()) * ms.meret();

            min_koltseg = std::min(min_koltseg, koltseg);

        } else {
            min_koltseg = koltseg;
        }
    }

    std::cout << min_koltseg << '\n';

    return 0;
}