#include <iostream>
#include <fstream>
#include <vector>
//#include <map>
#include <unordered_map>

std::ifstream fin("deque.in");
std::ofstream fout("deque.out");

int n;
std::vector<int> heapu;
//std::map<int, int> hashu;
std::unordered_map<int, int> hashu;
std::vector<int> moFoPos;

void insertu(int val)
{
    heapu.push_back(val);
    int i = heapu.size() / 2;
    int j = heapu.size() - 1;

    hashu[val] = j;

    while(i >= 1 && heapu[i] > val)
    {
        hashu[heapu[i]] = j;
        hashu[heapu[j]] = i;

        int aux = heapu[i];
        heapu[i] = heapu[j];
        heapu[j] = aux;

        j = i;
        i = i / 2;
    }
}

void delu(int position)
{
    int valInit = heapu.back();
    position--;

    heapu[hashu[moFoPos[position]]] = heapu.back();
    hashu[heapu.back()] = hashu[moFoPos[position]];

    heapu.pop_back();

    int i = hashu[moFoPos[position]];
    while(i * 2 < heapu.size())
    {
        int val = heapu[i*2];
        int p = 0;

        if(i*2 + 1 < heapu.size() && heapu[i*2+1] < heapu[i*2])
        {
            val = heapu[i*2+1];
            p = 1;
        }

        if(valInit > heapu[i*2+p])
        {
            int a1 = hashu[heapu[i]], a2 = hashu[heapu[i*2+p]];
            int aux = heapu[i];

            hashu[heapu[i]] = a2;
            hashu[heapu[i*2 + p]] = a1;

            heapu[i] = heapu[i*2 + p];
            heapu[i*2 + p] = aux;
        }
        else
        {
            break;
        }
        i = i * 2 + p;
    }
}

void citirea()
{
    int siz;
//    std::deque<nod> moFoList;
    fin>>n>>siz;

    long long suma = 0;
    int p;
    for(int i = 0; i < n; i++)
    {
        fin>>p;

        moFoPos.push_back(p);
//        nod elem;
//        elem.indice = i;
//        elem = p;

        insertu(p);

        if(i >= siz - 1)
        {
            suma += heapu[1];
//            std::cout<<i<<' '<<siz - 1<<": "<<minHeapu[1].indice<<' '<<minHeapu[1]<<'\n';
//            std::cout<<moFoPos[minHeapu[1]]<<'\n';
//            for(int i = 1; i < minHeapu.size(); i++)
//            {
//                std::cout<<moFoPos[minHeapu[i]]<<' ';
////                std::cout<<minHeapu[i]<<' ';
//            }
//            std::cout<<'\n';

            delu(i-siz + 2);

//            for(int i = 1; i < minHeapu.size(); i++)
//            {
//                std::cout<<minHeapu[i]<<' ';
//            }
//            std::cout<<'\n';
//            std::cout<<'\n';
        }
    }
    fout<<suma<<'\n';
//    std::cout<<suma<<'\n';
}

int main()
{
    heapu.push_back(-1);
    citirea();
    return 0;
}