#include <fstream>
#include <iostream>

class MyNode {
private:
    const int val, ind;
    MyNode* next;

public:
    MyNode( int val, int ind );

    int getVal() const;

    int getInd() const;

    MyNode* getNext() const;

    void setNext( MyNode* );

    ~MyNode();

};

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

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

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

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

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

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

class MyDeque {
    MyNode* fst;
    MyNode* beforeLast;

public:

    MyDeque();

    void popFront();

    void pushBack( MyNode* );

    void popBack( int );

    MyNode* getFst() const;

    MyNode* getLast() const;

    ~MyDeque();
};

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

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

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

MyNode* MyDeque::getLast() const {
    if ( beforeLast != nullptr && beforeLast->getNext() != nullptr )
        return beforeLast->getNext();
    else
        return beforeLast;
}

void MyDeque::popBack( int nr ) {
    MyNode* last = getLast();

    if ( last != nullptr && ( last->getVal() > nr ) ) {
        MyNode* node = beforeLast = fst;
        MyNode* aux;

        if ( node->getVal() < nr ) {
            while ( node->getNext() != nullptr && node->getNext()->getVal() < nr ) {
                beforeLast = node;
                node = node->getNext();
            }

            aux = node;
            node = node->getNext();
            aux->setNext( nullptr );

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

void MyDeque::pushBack( MyNode* myNode ) {
    if ( fst == nullptr ) {
        fst = beforeLast = myNode;
    } else {
        if ( beforeLast->getNext() != nullptr ) {
            if ( beforeLast->getNext()->getVal() == myNode->getVal() ) {
                delete beforeLast->getNext();
            } else
                beforeLast = beforeLast->getNext();
        }
        beforeLast->setNext( myNode );
    }
}

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


int main() {
    int n, k;
    long long s( 0LL );
    MyDeque myDeque;        //obs: va fi mereu sortat crescator
    std::ifstream fin( "deque.in" );
    fin >> n >> k;
    for ( int i = 1; i <= n; i++ ) {
        int nr;
        fin >> nr;
        myDeque.popBack( nr );

        MyNode* myDequeNode = new MyNode( 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();
        }
    }
    fin.close();

    std::ofstream fout( "deque.out" );
    fout << s << '\n';
    fout.close();

    return 0;
}