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

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

int n, siz;
//struct nod
//{
//    int indice, val;
//};


std::vector<int> minHeapu;
std::unordered_map<int, int> minHashu;
std::vector<int> moFoPos;
std::unordered_map<int, std::deque<int> > aparitii;

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

void insertuMinu(int val, int indice)
{
    aparitii[val].push_back(indice);
    if(aparitii[val].size() == 1)
    {
        minHeapu.push_back(val);
        int i = minHeapu.size() / 2;
        int j = minHeapu.size() - 1;

        minHashu[val] = j;

        while(i >= 1 && minHeapu[i] > val)
        {
            minHashu[minHeapu[i]] = j;
            minHashu[minHeapu[j]] = i;

            swa(minHeapu[i], minHeapu[j]);
//            swa(minHeapu[i].indice, minHeapu[j].indice);

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

void deluMinu(int position)
{
    aparitii[moFoPos[position]].pop_front();
    if(aparitii[moFoPos[position]].size() == 0)
    {
        int valInit = minHeapu.back();
    //    position--;

//        std::cout<<"elem pos: "<<position<<"; valoarea: "<<moFoPos[position]<<"; in hash: "<<minHashu[moFoPos[position]]<<"; in heap: "<<minHeapu[minHashu[moFoPos[position]]]<<'\n';

        minHeapu[minHashu[moFoPos[position]]] = minHeapu.back();
//        minHeapu[minHashu[moFoPos[position]]].indice = minHeapu.back().indice;
        minHashu[minHeapu.back()] = minHashu[moFoPos[position]];

        minHeapu.pop_back();

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

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

            if(valInit > minHeapu[i*2+p])
            {
                int a1 = minHashu[minHeapu[i]], a2 = minHashu[minHeapu[i*2+p]];

                minHashu[minHeapu[i]] = a2;
                minHashu[minHeapu[i*2 + p]] = a1;

                swa(minHeapu[i], minHeapu[i*2 + p]);
//                swa(minHeapu[i].indice, minHeapu[i*2 + p].indice);
            }
            else
            {
                break;
            }
            i = i * 2 + p;
        }
    }
}

void citire()
{
//    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;

        insertuMinu(p, i);

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

            deluMinu(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()
{
//    nod v;
//    v.indice = -1;
//    v = -1;
    minHeapu.push_back(-1);
//    maxHeapu.push_back(v);
//    moFoPos.push_back(-1);
    citire();
    return 0;
}