#include <cstdio>
#include <cassert>
#include <cctype>

class inputParser {
    static const unsigned int buffSize = 1 << 17;
    unsigned int pozBuff;
    FILE* fin;
    unsigned char* buffer;

    void getChar( unsigned char& ch ) {
        if ( pozBuff == buffSize ) {
            pozBuff = 0;
            assert( fread( buffer, sizeof( char ), buffSize, fin ) );
        }
        ch = buffer[ pozBuff++ ];
    }

public:
    explicit inputParser( const char* fileName ) {
        fin = fopen( fileName, "r" );
        assert( fin != nullptr );
        buffer = new unsigned char[buffSize];
        pozBuff = buffSize;
    }

    inputParser( const inputParser& dummy ) = delete;

    inputParser& operator=( const inputParser& dummy ) = delete;

    template < class intType >
    inputParser& operator>>( intType& nr ) {
        int sgn( 1 );
        unsigned char ch;
        nr = 0;
        getChar( ch );
        while ( isdigit( ch ) == 0 && ch != '-' )
            getChar( ch );
        if ( ch == '-' ) {
            sgn = -1;
            getChar( ch );
        }
        while ( isdigit( ch ) != 0 ) {
            nr = nr * 10 + ch - '0';
            getChar( ch );
        }
        nr *= sgn;
        return *this;
    }

    inputParser& operator>>( char& ch ) {
        unsigned char ch2;
        do {
            getChar( ch2 );
        } while ( isgraph( ch2 ) == 0 );
        ch = static_cast<char>(ch2);
        return *this;
    }

    inputParser& operator>>( unsigned char& ch ) {
        getChar( ch );
        do {
            getChar( ch );
        } while ( isgraph( ch ) == 0 );
        return *this;
    }

    ~inputParser() {
        fclose( fin );
        delete[] buffer;
    }
};

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 = nullptr;
        MyDequeNode* aux;
        while ( node->getNext() != nullptr && node->getNext()->getVal() < nr ) {
            while ( node->getVal() == node->getNext()->getVal() ) {
                aux = node->getNext();
                node->setNext( aux->getNext() );
                delete aux;
            }
            if ( node->getNext() != nullptr && node->getNext()->getVal() < nr )
                node = node->getNext();
        }

        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
    inputParser fin( "deque.in" );
    fin >> n >> k;
    for ( int i = 1; i <= n; i++ ) {
        int nr;
        fin >> 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();
        }
    }

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

    return 0;
}