using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace sipalyak
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] st = Console.ReadLine().Split().Select(int.Parse).ToArray();
            int N = st[0];
            int K = st[1];
            int[] kszum = new int[K + 1];//tömb, amely jelzi, hogy mennyit kell levonni a területbpl, hogy csokkenő legyen
            //Az alapelképzelés megkeressük az adott K-s rész legmagasabb elemét, és azt, aminek a tőle való taávolsága nagyobb köztük lévő magáasságkülönbségtől
            //Ezt hívhatjuk, a szakasz relatív legmagasabb pontjának, mert innen kell növelni, és csökkeneteni a magasságot
            //5 6 3 5 3 2 K=6 1esetén legmagasabb csúcson emelni kell, ezért megkeresi az utolso olyan esetet, ahol az előző feltétel nem igaz
            // ez lesz agy négyzet alapja (5*6(K)), ehhez hozzá kell adni egy háromszöget ami hahol emelkedik, 1+2+3, és le kell vonni, 
            //amennyivel utána csökken (1+2), és kivonni a jelenlegi magasságok összegét (5+6+3+5+3+2) 23=>30+6-3-23=10
            //a kszum adja meg, hogy egy távolságra mennyit kell levonni, vagy hozzáadni, ezt nem kell csak egyszer kiszámolni
            for (int i = 1; i < K + 1; i++)
            {
                kszum[i] =kszum[i-1]+i;//minden lépésben a háromszög hosszával nő az értéke
            }
           
            //beolvasás adatok eltárolása a két megvalósítás között nincs érdembeli sebességkülönbség
             //  int[] P = Console.ReadLine().Split().Select(int.Parse).ToArray();

            int[] P = new int[N];
            string[] t = Console.ReadLine().Split();
            for (int i = 0; i < N; i++)
            {
                P[i] = int.Parse(t[i]);
            }
            //int[] P = { 980855446, 998323020, 997418759, 994832636, 972080651, 973844772, 982446881, 999529807, 994574431, 998939886, 993768883, 999361467, 985621890, 994479633, 992913410, 994225250, 988670181, 992335377, 991835063, 997798360, 993513355, 988058282, 975548123, 999501819, 996917832, 994805932, 984880431, 999542936, 992620889, 996123248 };
            long max = 0, //az intervallumon belül a legnagyobb pont értéke
                 maxi = 0,//az intervallumon belül a legnagyobb pont helye
                 szum = 0, //az intervallumban lévő pontok összege intnél túlcsordulhat
                 minepit, //a minimális építési peták összege
                 max2 = 0, // a maximum utáni legnagyob helyéhez képest túl magas csúcs értéke
                 maxi2 = 0;//az előző helye
            //Az első k pontra megkerünk egy minimum építési külstéget
            for (int i = 0; i < K; i++)
            {
                if (max <= P[i])//ha az aktuális pont nagyobb mint az edidgi legnagyobb
                {
                    maxi = i;//ez lesz a legnygobb, és utána nem ahelyén lévő is
                    max = P[i];
                    max2 = max;
                    maxi2 = i;
                }
                else// ha nem nagyobb
                {
                    max2--;//ez mutatja azt a magasságot, aemlyel a pálya felépíthető a legnmagysabb pont növelése nélkül
                    maxi2++;//ez az indexe
                    if (max2 < P[i])//ha az edott pont ennél magasabb, akkor ez lesz a minimális érték
                    {
                        max2 = P[i];
                        maxi2 = i;
                    }
                }
                szum += P[i];//möveljük az összeget
            }
            if (maxi2 - maxi > max - max2)//ha a legmagasabb pont után egy pont magasabb, legmagasabbhoz képest, mint kellene
                minepit = K * max2 - //ennyibe kerülne felépíteni a pályát egyformán a maxi2 magasságra
                    szum +//ennyi a szakasz jelenlegi tömege, ezt nem kell megépíteni
                    kszum[maxi2  ] - //hozzáadjuk azt, amivel a elativ legmagasabb pont előtti részt meg kellene emelni
                    kszum[K - maxi2 - 1];//levonjuk, relatív legmagasabb pont mőgőtt lévő területet, amelyet nem kell megépíteni
            else
                //ugyanez, ha a relatív legmagasabb pont a  maximális érték, tehát nincs magasabb pont, mint ideális lenne
               minepit = K * max - szum + kszum[maxi ] - kszum[K - maxi - 1];

            long aktepit = 0;//ez mutatja, mennyi lenne az aktuális szakaszra az építési költség
            for (int i = K; i < N; i++)//bejárjuk a tömb maradék részét
            {
                szum -= P[i - K];//Levonjuk az az elemet,amely kiesik az intervallumből
                szum += P[i];//hozzáadjuk az aktuális elemet
                if (P[i] >= max)//ha az aktuálsi elem a legnagyobb ez az optimális
                {
                    maxi = i;//erre állítjuk a maximumot
                    max = P[i];
                    max2 = max;
                    maxi2 = i;
                }
                else//ha nem az ez baj, mert meg kell keresnünk az adott szaksz legnagyobb pontját, és a relatív legnygaobb pontot is
                    //ez lassítja be az algoritmus, mivel a K lehett 200 000 is.
                { 
                    max = P[i - K + 1];//induló értékek megadása
                    max2 = P[i-K+1];
                    maxi2 = i - K + 1;
                    maxi = maxi2;
                    for (int j = i-K+1; j < i+1; j++)//bejárjuk a szakaszt
                    {
                        if (max <= P[j])//ha az adott pont a legynagyobb ez lesz a legnagyobb
                        {
                            maxi = j;
                            max = P[j];
                            max2 = max;
                            maxi2 = j;
                        }
                        else//ha nem megkeressük megnézzük, hogy ez a pont relatív magasbb-e a legmagasabb pontnál
                        {
                            max2--;
                            maxi2++;
                            if (max2 < P[j])
                            {
                                max2 = P[j];
                                maxi2 = j;
                            }
                        }
                    }
                }
                if (maxi2 - maxi > max - max2)//a a relatív legmagasabb pont nem a legmagasabb pont
                    aktepit = K * max2 - szum + //a megépítéshez szükséges terület- a már létező magasság
                        kszum[maxi2 - (i-K+1)] - //előtte menyibe erül növelni a magasságot (i-k+1) az intevallum kezdete
                        kszum[i - maxi2];//utána mennyivel kell csökkenteni a magasságot
                else//ugyanez, ha a relatív legmygasabb pont a legmagasabb pont a szakszban
                    aktepit = K * max - szum + kszum[maxi - (i-K+1) ] - kszum[i - maxi];
                if (minepit > aktepit)//ha ez kisebb mint az eddigi minimum
                {
                    minepit = aktepit;
                }
            }
            Console.WriteLine(minepit);//kiírás
            //Probléma, hogy ez még mindig lassú a C#-nak, az futási idő 486 MS, a 400 helyett. CPP-re átírni
            Console.ReadKey();
        }
    }
}