#include <fstream>
#include <stdexcept>
#include <vector>

template <typename T> struct Node {
    Node *next = nullptr;
    Node *prev = nullptr;
    T value;
};

template <typename T> class ReadOnlyFrontDeque {
    std::vector<T> container;
    std::size_t frontIndex = 0;
    std::size_t endIndex = 0;
    std::size_t _size = 0;

public:
    bool empty() const {
        return frontIndex == endIndex;
        return size() == 0;
    }

    std::size_t size() const {
        return endIndex - frontIndex;
        return _size;
    }

    T front() const {
        if (empty()) {
            throw std::out_of_range("Deque is empty");
        }
        return container[frontIndex];
    }

    T back() const {
        if (empty()) {
            throw std::out_of_range("Deque is empty");
        }
        return container[endIndex - 1];
    }

    void push_front(T value) {
        throw std::logic_error("Not implemented");
    }

    void push_back(T value) {
        if (container.size() <= endIndex) {
            container.push_back(value);
        } else {
            container[endIndex] = value;
        }

        endIndex++;
    }

    T pop_front() {
        if (empty()) {
            throw std::out_of_range("No element to pop");
        }

        auto oldValue = front();
        frontIndex++;
        _size--;
        return oldValue;
    }

    T pop_back() {
        if (empty()) {
            throw std::out_of_range("No element to pop");
        }

        auto oldValue = back();
        endIndex--;
        _size--;
        return oldValue;
    }
};

struct Elem {
    size_t index;
    int value;
};

int main() {
    std::ifstream ifs("deque.in");
    std::ofstream ofs("deque.out");

    ReadOnlyFrontDeque<Elem> deq;

    std::size_t N, K;
    ifs >> N >> K;

    long long sum_of_minimums = 0;
    for (std::size_t i = 0; i < N; i++) {
        int x;
        ifs >> x;

        while (!deq.empty() && x <= deq.back().value) {
            deq.pop_back();
        }
        deq.push_back({i, x});

        if (deq.front().index + K <= i) {
            deq.pop_front();
        }
        if (i + 1 >= K && !deq.empty()) {
            // Once we have read at least K numbers, start summing the minimums
            sum_of_minimums += deq.front().value;
        }
    }

    ofs << sum_of_minimums << '\n';
    return 0;
}