#include <cstdio>
#include <iostream>

class MyDequeNode {
private:
    const int val, ind;
    MyDequeNode* next;
public:
    MyDequeNode( int val, int ind );

    int getVal() const;

    int getInd() const;

    MyDequeNode* getNext() const;

    void setNext( MyDequeNode* );

    ~MyDequeNode();

};

MyDequeNode::~MyDequeNode() {
    next = nullptr;
}

void MyDequeNode::setNext( MyDequeNode* nxt ) {
    next = nxt;
}


MyDequeNode* MyDequeNode::getNext() const {
    return next;
}

int MyDequeNode::getVal() const {
    return val;
}

int MyDequeNode::getInd() const {
    return ind;
}

MyDequeNode::MyDequeNode( int val, int ind ) : val( val ), ind( ind ) {
    next = nullptr;
}

class MyDeque {
    MyDequeNode* fst;
    MyDequeNode* last;

public:

    MyDeque();

    void popFront();

    void pushBack( MyDequeNode* );

    void popBack( int );

    MyDequeNode* getFst() const;

    MyDequeNode* getLast() const;

    ~MyDeque();
};

void MyDeque::pushBack( MyDequeNode* myNode ) {
    if ( fst == nullptr ) {
        fst = last = myNode;
    } else {
        last->setNext( myNode );
        last = myNode;
    }
}

void MyDeque::popBack( int nr ) {
    if ( last != nullptr && last->getVal() > nr ) {
        MyDequeNode* node = fst;
        while ( node->getNext() != nullptr && node->getNext()->getVal() <= nr )
            node = node->getNext();

        MyDequeNode* aux = node;
        node = node->getNext();
        aux->setNext( nullptr );
        last = aux;

        while ( node != nullptr ) {
            aux = node;
            node = node->getNext();
            delete aux;
        }

        if ( fst->getVal() > nr ) {
            delete fst;
            fst = last = nullptr;
        }
    }
}

void MyDeque::popFront() {
    if ( fst != nullptr ) {
        if ( fst == last ) {
            delete fst;
            fst = last = nullptr;
        } else {
            MyDequeNode* aux = fst;
            fst = fst->getNext();
            delete aux;
        }
    }
}

MyDequeNode* MyDeque::getFst() const {
    return fst;
}

MyDequeNode* MyDeque::getLast() const {
    return last;
}


MyDeque::~MyDeque() {
    while ( fst != nullptr )
        popFront();
}

MyDeque::MyDeque() {
    fst = last = nullptr;
}


int main() {
    int n, k;
    long long s( 0LL );
    MyDeque myDeque;        //obs: va fi mereu sortat crescator
    FILE* fin, * fout;
    fin = fopen( "deque.in", "r" );
    fscanf( fin, "%d%d", &n, &k );

    for ( int i = 1; i <= n; i++ ) {
        int nr;
        fscanf( fin, "%d", &nr );

        myDeque.popBack( nr );

        MyDequeNode* myDequeNode = new MyDequeNode( nr, i );
        myDeque.pushBack( myDequeNode );

        //trb sa ne asiguram ca nu am depasit intervalul
        while ( myDeque.getFst() != nullptr && myDeque.getLast()->getInd() - myDeque.getFst()->getInd() >= k )
            myDeque.popFront();

        if ( i >= k && myDeque.getFst() != nullptr ) {
            s += myDeque.getFst()->getVal();
        }
    }

    fclose( fin );
    fout = fopen( "deque.out", "w" );
    fprintf( fout, "%lld\n", s );
    fclose( fout );

    return 0;
}