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

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

struct myhash
{
    int val, poz;
};

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

inline void swap(int &a, int &b)
{
    int aux = a;
    a = b;
    b = aux;
}

void insertu(int val, int poz)
{
    if(hashu[val].val == 0)
    {
        heapu.push_back(val);
        int i = heapu.size() / 2;
        int j = heapu.size() - 1;

        hashu[val].val = j;
        hashu[val].poz = poz;

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

            j = i;
            i = i / 2;
        }
    }
    else
    {
        hashu[val].poz = poz;
    }
}

void delu(int position)
{
    if(hashu[moFoPos[position]].poz <= position)
    {
        int valInit = heapu.back();
    //    position--;

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

        heapu.pop_back();

        int i = hashu[moFoPos[position]].val;
        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])
            {
                swap(hashu[heapu[i]].val, hashu[heapu[i*2+p]].val);
                swap(hashu[heapu[i]].poz, hashu[heapu[i*2+p]].poz);
                swap(heapu[i], heapu[i*2+p]);
            }
            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, i);

        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 + 1);

//            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;
}