#include <fstream>

class MyDequeNode {
private:
    int val, ind;
    MyDequeNode *next;
    MyDequeNode *prev;
public:
    MyDequeNode(int val, int ind) {
        this->val = val; // (*this).val
        this->ind = ind;
        next = nullptr;
        prev = nullptr;
    }

    int getVal() const {
        return val;
    }

    void setVal(int v) {
        val = v;
    }

    int getInd() const {
        return ind;
    }

    void setInd(int ind) {
        MyDequeNode::ind = ind;
    }

    MyDequeNode *getPrev() const {
        return prev;
    }

    void setPrev(MyDequeNode *prev) {
        MyDequeNode::prev = prev;
    }

    MyDequeNode *getNext() const {
        return next;
    }

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

    virtual ~MyDequeNode() {
        val = ind = 0;
        next = nullptr;
        prev = nullptr;
    }

};

class MyDeque {
    MyDequeNode *fst;
    MyDequeNode *last;
    int co;

public:

    MyDeque() {
        fst = last = nullptr;
        co = 0;
    }

    void popFront();

    void pushBack(MyDequeNode *);

    void popBack();

    MyDequeNode *getFst() const;

    void setFst(MyDequeNode *fst);

    MyDequeNode *getLast() const;

    void setLast(MyDequeNode *last);

    int getCo() const;

    void setCo(int co);

    virtual ~MyDeque();
};

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

void MyDeque::popBack() {
    if (last != nullptr) {
        if (last->getPrev() == nullptr) {//avem un singur elem in deque
            delete last;
            fst = last = nullptr;
            co = 0;
        } else {
            last->getPrev()->setNext(nullptr);

            MyDequeNode *aux = last;
            last = last->getPrev();
            delete aux;

            co--;
        }
    }
}

void MyDeque::popFront() {
    if (fst != nullptr) {
        if (fst->getNext() == nullptr) {
            delete fst;
            fst = last = nullptr;
            co = 0;
        } else {
            fst->getNext()->setPrev(nullptr);

            MyDequeNode *aux = fst;
            fst = fst->getNext();
            delete aux;

            co--;
        }
    }
}

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

void MyDeque::setFst(MyDequeNode *fst) {
    MyDeque::fst = fst;
}

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

void MyDeque::setLast(MyDequeNode *last) {
    MyDeque::last = last;
}

int MyDeque::getCo() const {
    return co;
}

void MyDeque::setCo(int co) {
    MyDeque::co = co;
}

MyDeque::~MyDeque() {
    while (co > 0)
        popFront();
}


int main() {
    int n, k;
    long long s(0);
    MyDeque myDeque;        //obs: va fi mereu sortat crescator
    std::ifstream fin("deque.in");
    std::ofstream fout("deque.out");
    fin >> n >> k;

    for (int i = 1; i <= n; i++) {
        int nr;
        fin >> nr;

        //cat timp mai am elem in deque si elem meu e mai mic decat ultimul
        while (myDeque.getCo() > 0 && myDeque.getLast()->getVal() > nr) {
            myDeque.popBack();
        }

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

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

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

    fout << s << '\n';
    fin.close();
    fout.close();

    return 0;
}