#include <bits/stdc++.h>
#define MAX 5000100
using namespace std;

class Deque
{
public:
    Deque()
    {
        frontNode = nullptr;
        backNode = nullptr;
        sizeOfDeque = 0;
    }

    int size()
    {
        return sizeOfDeque;
    }

    int front()
    {
        assert (frontNode != nullptr);
        return frontNode -> value;
    }

    int back()
    {
        assert (backNode != nullptr);
        return backNode -> value;
    }

    void push_front(int value)
    {
        sizeOfDeque += 1;
        if (frontNode == nullptr)
        {
            frontNode = backNode = renew(value, nullptr, nullptr);
            return;
        }
        frontNode -> leftNode = renew(value, nullptr, frontNode);
        frontNode = frontNode -> leftNode;
    }

    void push_back(int value)
    {
        sizeOfDeque += 1;
        if (backNode == nullptr)
        {
            frontNode = backNode = renew(value, nullptr, nullptr);
            return;
        }
        backNode -> rightNode = renew(value, backNode, nullptr);
        backNode = backNode -> rightNode;
    }

    void pop_front()
    {
        assert(sizeOfDeque >= 1);
        sizeOfDeque -= 1;

        recycle.push_back(frontNode);
        frontNode = frontNode -> rightNode;

        if (frontNode != nullptr)
            frontNode -> leftNode = nullptr;
        else
            backNode = nullptr;
    }

    void pop_back()
    {
        assert(sizeOfDeque >= 1);
        sizeOfDeque -= 1;

        recycle.push_back(backNode);
        backNode = backNode -> leftNode;

        if (backNode != nullptr)
            backNode -> rightNode = nullptr;
        else
            frontNode = nullptr;
    }

    void clear()
    {
        while (frontNode != nullptr)
        {
            recycle.push_back(frontNode);
            frontNode = frontNode -> rightNode;
        }
        sizeOfDeque = 0;
        frontNode = nullptr;
        backNode = nullptr;
    }
private:
    struct node
    {
        node *leftNode;
        node *rightNode;
        int value;

        node()
        {
            this -> leftNode = nullptr;
            this -> rightNode = nullptr;
            this -> value = 0;
        }

        node(int _value, node *_left, node *_right)
        {
            this -> leftNode = _left;
            this -> rightNode = _right;
            this -> value = _value;
        }
    };
    node *frontNode;
    node *backNode;
    int sizeOfDeque;

    vector <node *> recycle;

    node* renew (int value, node* _left, node* _right)
    {
        if (!recycle.empty())
        {
            auto oldNode = recycle.back();
            recycle.pop_back();
            oldNode->value = value;
            oldNode->rightNode = _right;
            oldNode->leftNode = _left;
            return oldNode;
        }
        return new node(value, _left, _right);
    }
};


Deque* dubla = new Deque();
int n,k;
long long sol;
int v[MAX];
int main()
{
    freopen("deque.in","r",stdin);
    freopen("deque.out","w",stdout);
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;scanf("%d",v+i),++i);
    for(int i=1;i<=n;++i){
        while(dubla->size() and v[i]<=v[dubla->back()])dubla->pop_back();
        if(dubla->size() and i-k==dubla->front())dubla->pop_front();
        dubla->push_back(i);
        if(i>=k)sol=sol+v[dubla->front()];
    }
    printf("%lld\n",sol);
    return 0;
}