#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:
    ReadOnlyFrontDeque(std::size_t size) {
        container.resize(size);
    }

    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 {
    int index;
    int value;
};

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

    unsigned N, K;
    ifs >> N >> K;

    std::vector<int> nums(N);
    for (std::size_t i = 0; i < N; i++) {
        int x;
        ifs >> x;
        nums[i] = x;
    }

    ReadOnlyFrontDeque<int> index_deque(5'000'000);
    long long sum_of_minimums = 0;
    for (unsigned i = 0; i < N; i++) {
        while (!index_deque.empty() && nums[i] <= nums[index_deque.back()]) {
            index_deque.pop_back();
        }
        index_deque.push_back(i);

        if (index_deque.front() + K <= i) {
            index_deque.pop_front();
        }

        if (i + 1 >= K && !index_deque.empty()) {
            // Once we have read at least K numbers, start summing the minimums
            sum_of_minimums += nums[index_deque.front()];
        }
    }

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