#include <bits/stdc++.h>
#define dim 1000000

using namespace std;

/**
Deque class:
- Methods:
    *Pop_Back
    *Pop_Front
    *Push_Back
    *Push_Front
    *Back
    *Front
    *Empty
    *Size
    *Clear
    *Insert
    *Find
    *Erase + EraseValue
    *Swap
    *Reverse
    *Create
    *Afis
- Operators:
    *deque[]
    *deque = deque
    *out << deque[] << "\n";
- Constructors:
    *Init
    *Input from file
    *Copy another deque
- Destructor
- Apps:
    Vila2 (InfoArena)
    Deque (InfoArena)
    Knumere (InfoArena)
*/

template <class Type> class Deque
{
private:
    Type *v; ///deque-ul
    int n; ///dimensiunea deque-ului
    int _end, _begin; ///positia primei si ultimei valori
public:
///----------methods----------
    void Pop_Back()
    {
        if (!Empty())
        {
            _end--;
            n--;
        }
    }

    void Pop_Front()
    {
        if (!Empty())
        {
            _begin++;
            n--;
        }
    }

    void Push_Back(Type x)
    {
        if (Empty())
        {
            Create(x);
            return;
        }
        n++;
        v[_end++] = x;
    }

    void Push_Front(Type x)
    {
        if (Empty())
        {
            Create(x);
            return;
        }
        n++;
        v[--_begin] = x;
    }

    Type Back()
    {
        if (!Empty()) return v[_end - 1];
        return -1;
    }

    Type Front()
    {
        if (!Empty()) return v[_begin];
        return -1;
    }

    bool Empty()
    {
        return (n == 0);
    }

    int Size()
    {
        return n;
    }

    void Clear()
    {
        n = 0;
        _end = _begin = -1;
    }

    void Insert(Type x, int pos)
    {
        if (Empty())
        {
            Create(x);
            return;
        }
        if (pos >= n)
        {
            Push_Back(x);
            return;
        }
        if (pos <= 0)
        {
            Push_Front(x);
            return;
        }
        for (int i = n; i > pos; i--)
            v[_begin + i] = v[_begin + i - 1];
        v[_begin + pos] = x;
        n++;
        _end++;
    }

    int Find(Type x)
    {
        for (int i = 0, j = n - 1; i < n; i++, j--)
        {
            if (v[i + _begin] == x) return i;
            if (v[j + _begin] == x) return j;
        }
        return -1;
    }

    void EraseValue(Type x)
    {
        Erase(Find(x));
    }

    void Erase(int pos)
    {
        if (pos == n - 1)
        {
            Pop_Back();
            return;
        }
        if (pos == 0)
        {
            Pop_Front();
            return;
        }
        if (!(pos >= 0 && pos < n)) return;
        for (int i = pos; i < n - 1; i++) v[_begin + i] = v[_begin + i + 1];
        n--;
        _end--;
    }

    void Swap(Deque &x)
    {
        Deque <Type> aux(x);
        x.n = n;
        x._end = _end;
        x._begin = _begin;
        x.v = new Type[dim];
        for (int i = _begin; i < _end; i++)
            x.v[i] = v[i];
        n = aux.Size();
        _begin = aux._begin;
        _end = aux._end;
        v = new Type[dim];
        for (int i = _begin; i < _end; i++)
            v[i] = aux.v[i];
    }

    void Reverse()
    {
        Deque <Type> aux;
        aux.n = n;
        aux._end = _end;
        aux._begin = _begin;
        aux.v = new Type[dim];
        for (int i = _begin; i < _end; i++)
            aux.v[i] = v[i];
        for (int i = _begin, j = _end - 1; i < _end; i++, j--)
            v[i] = aux.v[j];
    }

    void Create(Type x)
    {
        if (Empty())
        {
            v = new Type[dim];
            n++;
            _begin = dim / 2;
            _end = _begin + 1;
            v[_begin] = x;
        }
    }

    void Afis()
    {
        for (int i = _begin; i < _end; i++)
            cout << v[i] << " ";
        cout << "\n";
    }
///----------operators----------
Type operator[](int i)
{
    return v[_begin + i];
}

void operator =(Deque &y)
{
    n = y.n;
    _begin = y._begin;
    _end = y._end;
    delete []v;
    v = new Type[dim];
    for (int i = 0; i < n; i++)
        v[_begin + i] = y.v[_begin + i];
}

friend ostream &operator <<(ostream &out, Deque D)
{
    for (int i = 0; i < D.n; i++)
        out << D[i] << " ";
    out << "\n";
    return out;
}
///----------constructors----------
    Deque()
    {
        Clear();
    }

    Deque(const char fisIn[])
    {
        int x;
        n = 0;
        _begin = _end = -1;
        v = new Type[dim];
        ifstream fin(fisIn);
        while (fin >> x) Push_Back(x);
        fin.close();
    }

    Deque(Deque &w)
    {
        n = w.Size();
        _begin = w._begin;
        _end = w._end;
        v = new Type[dim];
        for (int i = _begin; i < _end; i++)
            v[i] = w.v[i];
    }
///----------destructor----------
    ~Deque()
    {
        n = 0;
        _begin = _end = -1;
        delete []v;
    }
};

/**
Vila2 (InfoArena):
Se da N si un vector de N elemente numere intregi.
Gasiti diferenta maxima dintre doua elem a unei subsecvente cu lungimimea <= K
#define dim 200000
Exemplu:
6 2
5 9 4 7 4 1 => 6 (7, 4, 1)
*/
/**
Deque <int> qmax, qmin;
int a[100005];

void Vila2()
{
    ifstream fin("vila2.in");
    ofstream fout("vila2.out");
    int i, n, k, x, dif = 0;
    fin >> n >> k;
    for (i = 0; i < n; i++) fin >> a[i];
    for (i = 0; i < n; i++)
    {
        x = a[i];
        if (qmax.Front() < i - k) qmax.Pop_Front();
        while (!qmax.Empty() && a[qmax.Back()] <= x) qmax.Pop_Back();
        qmax.Push_Back(i);
        if (qmin.Front() < i - k) qmin.Pop_Front();
        while (!qmin.Empty() && a[qmin.Back()] >= x) qmin.Pop_Back();
        qmin.Push_Back(i);
        dif = max(dif, abs(a[qmax.Front()] - a[qmin.Front()]));
    }
    fout << dif << "\n";
    fin.close();
    fout.close();
}
*/
/**
Deque (InfoArena):
Se da un sir A cu N numere intregi.
Pentru fiecare subsecventa de lungime K sa se determine minimul, iar apoi sa se calculeze suma acestor minime.
#define dim 10000000
Exemplu:
9 3
-7 9 2 4 -1 5 6 7 1 => -2
*/

Deque <int> q;
int a[5000000];

void pbDeque()
{
    ifstream fin("tdeque.in");
    ofstream fout("tdeque.out");
    int n, k, i, smin, x;
    fin >> n >> k;
    for (i = 0; i < n; i++) fin >> a[i];
    for (i = 0; i < k; i++)
    {
        x = a[i];
        while (!q.Empty() && a[q.Back()] >= x) q.Pop_Back();
        q.Push_Back(i);
    }
    smin = a[q.Front()];
    for (i = k; i < n; i++)
    {
        x = a[i];
        while (!q.Empty() && q.Front() <= i - k) q.Pop_Front();
        while (!q.Empty() && a[q.Back()] >= x) q.Pop_Back();
        q.Push_Back(i);
        smin += a[q.Front()];
    }
    fout << smin << "\n";
    fin.close();
    fout.close();
}

/**
Knumere (InfoArena):
Se dau N numere intregi in ordine crescatoare.
Sa se elimine K numere dintre acestea, astfel incat
diferenta maxima dintre oricare doua numere consecutive ramase sa fie minima.
#define dim 200000
Exemplu:
6 2
-1 3 5 11 19 35 => 6
*/
/**
int a[1000005];
Deque <int> q;

void Knumere()
{
    ifstream fin("knumere.in");
    ofstream fout("knumere.out");
    int n, k, x, i, y, minn;
    fin >> n >> k >> x;
    for (i = 1; i < n; i++)
    {
        fin >> a[i - 1];
        y = a[i - 1];
        a[i - 1] -= x;
        x = y;
    }
    k = n - 1 - k;
    for (i = 0; i < k; i++)
    {
        x = a[i];
        while (!q.Empty() && a[q.Back()] <= x) q.Pop_Back();
        q.Push_Back(i);
    }
    minn = a[q.Front()];
    for (i = k; i < n - 1; i++)
    {
        x = a[i];
        while (!q.Empty() && q.Front() <= i - k) q.Pop_Front();
        while (!q.Empty() && a[q.Back()] <= x) q.Pop_Back();
        q.Push_Back(i);
        minn = min(minn, a[q.Front()]);
    }
    fout << minn << "\n";
    fin.close();
    fout.close();
}*/

int main()
{

    pbDeque();

    return 0;
}