#include <fstream>
#include <deque>

using namespace std;

template <class type> class node;
template <class type> class Deque;

template <class type> class node
{
    type info;
    node <type> *_left_address, *_right_address;
    friend class Deque <type>;
};

template <class type> class Deque
{
    private:

    int count;
    node <type> *L, *R, *now;
    type error;

    void init_void_deque (const type value)
    {
        now = new node <type>;
        now -> info = value;
        now -> _left_address = NULL;
        now -> _right_address = NULL;
        L = R = now;
    }

    void make_void_deque ()
    {
        delete L;
        delete R; // not necessarily
        L = R = now = NULL;
    }

    public:

    Deque (type error)
    {
        this -> error = error;
        this -> count = 0;
        L = R = now = NULL;
    }

    void destroy()
    {
        while (!this -> empty())
            this -> pop_back();
    }

    bool empty()
    {
        return this -> count == 0;
    }

    int size()
    {
        return this -> count;
    }

    type back()
    {
        return L -> info;
    }

    type front()
    {
        return R -> info;
    }

    void push_back(const type value)
    {
        ++ this -> count;
        if (this -> count == 1)
        {
            init_void_deque(value);
            return ;
        }
        now = new node <type>;
        now -> info = value;
        now -> _left_address = NULL;
        now -> _right_address = L;
        L -> _left_address = now;
        L = now;
    }

    void push_front(const type value)
    {
        ++ this -> count;
        if (this -> count == 1)
        {
            init_void_deque(value);
            return ;
        }
        now = new node <type>;
        now -> info = value;
        now -> _left_address = R;
        now -> _right_address = NULL;
        R -> _right_address = now;
        R = now;
    }

    void pop_back()
    {
        -- this -> count;
        if (this -> count == 0)
        {
            make_void_deque();
            return ;
        }
        now = L -> _right_address;
        delete L;
        L = now;
        L -> _left_address = NULL;
    }

    void pop_front()
    {
        -- this -> count;
        if (this -> count == 0)
        {
            make_void_deque();
            return ;
        }
        now = R -> _left_address;
        delete R;
        R = now;
        R -> _right_address = NULL;
    }
};

const int NMax = 5000010;

long long ans = 0LL;
Deque <int> D = Deque<int> (-2000000000);
//deque <int> D;
int N, K;
int a[NMax];

int main()
{
    ifstream f ("deque.in");
    f >> N >> K;
    for(int i = 1; i <= N; ++ i)
        f >> a[i];
    f.close();
    for(int i = 1; i <= N; ++ i)
    {
        //if (i % 250000 == 0)
        //   cout << i << "\n";
        while (!D.empty() && a[i] <= a[D.front()])
            D.pop_front();
        D.push_front(i);

        if (D.back() == i - K)
            D.pop_back();

        if (i >= K)
            ans += a[D.back()];
    }
    ofstream g ("deque.out");
    g << ans << "\n";
    g.close();
    //D.destroy();
    return 0;
}