#include <fstream>
#include <iostream>

using namespace std;

ifstream f("deque.in");
ofstream g("deque.out");


int n, k, x;
int Sum;

class nod {

    nod* next;
    nod* prev;
    int val;
    int poz;

public:

    nod* get_next() {
        return next;
    }

    nod* get_prev() {
        return prev;
    }

    int get_val() {
        return val;
    }

    int get_poz() {
        return poz;
    }

    void set_next(nod* n) {
        next = n;
    }

    void set_prev(nod* n) {
        prev = n;
    }

    void set_val(int x) {
        val = x;
    }

    void set_poz(int x) {
        poz = x;
    }


    nod() {
        next = NULL;
        prev = NULL;
        val = 0;
        poz = -1;
    }
};


class deque {

    nod* prim = NULL;
    nod* ultim = NULL;

public:

    void add_right(int x, int y) {
        if (ultim != NULL) {
            nod* aux;
            aux = new nod();
            ultim->set_next(aux);
            aux->set_prev(ultim);
            aux->set_val(x);
            aux->set_poz(y);
            ultim = aux;
        }
        else {
            nod* aux;
            aux = new nod();
            aux->set_val(x);
            aux->set_poz(y);
            prim = aux;
            ultim = aux;
        }

    }
    void add_left(int x, int y) {
        if (prim != NULL) {
            nod* aux;
            aux = new nod();
            prim->set_prev(aux);
            aux->set_next(prim);
            aux->set_val(x);
            aux->set_poz(y);
            prim = aux;
        }
        else {
            nod* aux;
            aux = new nod();
            aux->set_val(x);
            aux->set_poz(y);
            prim = aux;
            ultim = aux;
        }
    }

    void remove_left() {
        if (prim != ultim) {
            nod* aux;
            aux = prim->get_next();
            prim = aux;
        }
        else {
            prim = NULL;
            ultim = NULL;
        }
    }
    void remove_right() {
        if (prim != ultim) {
            nod* aux;
            aux = ultim->get_prev();
            ultim = aux;
        }
        else {
            prim = NULL;
            ultim = NULL;
        }
    }

    nod* get_prim() {
        return prim;
    }
    nod* get_ultim() {
        return ultim;
    }
};

int main()
{
    nod* aux;
    f >> n >> k;
    deque A;
    for (int i = 0; i < k - 1; i++) {
        f >> x;
        aux = A.get_ultim();
        while (aux != NULL && aux->get_val() >= x) {
            aux = aux->get_prev();
            A.remove_right();
        }
        A.add_right(x, i);

    }
    for (int i = k - 1; i < n; i++) {
        f >> x;

        aux = A.get_ultim();
        while (aux != NULL && aux->get_val() >= x) {
            aux = aux->get_prev();
            A.remove_right();
        }

        A.add_right(x, i);
        aux = A.get_prim();
        while (aux->get_poz() <= i - k) {
            aux = aux->get_next();
            A.remove_left();
        }
        Sum += aux->get_val();
    }
    g << Sum;
}