#include <iostream>
#include <vector>
#include <stack>

class MaxVerem {
public:
    MaxVerem() = default;

    bool empty() const {
        return s_.empty();
    }

    size_t size() const {
        return s_.size();
    }

    int top() const {
        return s_.top().first;
    }

    int max() const {
        return s_.top().second;
    }

    void pop() {
        s_.pop();
    }

    void push(int e) {
        if (empty()) {
            s_.emplace(e, e);

        } else {
            s_.emplace(e, std::max(e, max()));
        }
    }

private:
    std::stack<std::pair<int, int>> s_;
};

class MaxSor {
public:
    MaxSor() = default;

    bool empty() const {
        return in_.empty() && out_.empty();
    }

    size_t size() const {
        return in_.size() + out_.size();
    }

    int top() {
        fill_out();
        return out_.top();
    }

    int max() const {
        const auto in_empty = in_.empty();
        const auto out_empty = out_.empty();

        if (in_empty && out_empty) {
            return 0;

        } else if (!in_empty && !out_empty) {
            return std::max(in_.max(), out_.max());

        } else if (in_empty) {
            return out_.max();

        } else {
            return in_.max();
        }
    }

    void pop() {
        fill_out();
        out_.pop();
    }

    void push(int e) {
        in_.push(e);
    }

private:
    void fill_out() {
        if (out_.empty()) {
            while (!in_.empty()) {
                out_.push(in_.top());
                in_.pop();
            }
        }
    }

    MaxVerem in_, out_;
};

void beolvas(std::istream &in, std::vector<int> &h, int &k) {
    size_t n;
    in >> n >> k;

    h.resize(n);
    for (auto i = 0u; i < n; i++) {
        in >> h[i];
    }
}

void feldolgoz(const std::vector<int> &h, int k) {
    MaxSor s;

    uint64_t koltseg = 0;
    s.push(h[0]);
    for (auto i = 1; i < k; i++) {
        const auto max_mag = s.max();
        const auto uj_mag = h[i] + i;

        if (uj_mag <= max_mag) {
            koltseg += max_mag - uj_mag;

        } else {
            koltseg += static_cast<uint64_t>(uj_mag - max_mag) * static_cast<uint64_t>(s.size());
        }

        s.push(uj_mag);
    }

    auto min_koltseg = koltseg;
    const auto n = static_cast<int>(h.size());
    for (auto i = k; i < n; i++) {
        const auto regi_max_mag = s.max();
        koltseg -= regi_max_mag - s.top();
        s.pop();

        const auto max_mag = s.max();
        koltseg -= static_cast<uint64_t>(regi_max_mag - max_mag) * static_cast<uint64_t>(s.size());

        const auto uj_mag = h[i] + i;
        if (uj_mag <= max_mag) {
            koltseg += max_mag - uj_mag;

        } else {
            koltseg += static_cast<uint64_t>(uj_mag - max_mag) * static_cast<uint64_t>(s.size());
        }
        min_koltseg = std::min(min_koltseg, koltseg);

        s.push(uj_mag);
    }

    std::cout << min_koltseg << std::endl;
}

int main() {
    std::vector<int> h;
    int k;
    beolvas(std::cin, h, k);
    feldolgoz(h, k);

    return 0;
}