//https://www.infoarena.ro/problema/deque

#pragma GCC optimize("O3")   
#pragma GCC optimize("Ofast") 
#pragma GCC optimize("fast-math") 
#pragma GCC optimize("unroll-loops") 
#pragma GCC optimize("inline")  
//#define _USE_MATH_DEFINES
//#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <fstream>
//#include <vector>
//#include <cstring>
//#include <cmath>
//#include <bitset>
//#include <queue>
//#include <stack>
//#include <utility>
//#include <algorithm>
//#include <string>
//#include <map>
//#include <unordered_map>
//#include <set>
//#include <unordered_set>
//#include <cstdint>
//#include <climits>
//#include <iomanip>
//#include <cstdio>
//#include <tuple>

using namespace std;

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

const int NRMAX = 5000000;

template <typename T>
class Deque
{
public:

	Deque(int capacityVal) : capacity(capacityVal), sizeNr(0), frontPtr(0), backPtr(0) { dq = new T[capacity]; }

	~Deque() { delete[] dq; }

	T& back() const
	{
		return dq[(backPtr - 1 + capacity) % capacity];
	}

	T& fronrt() const
	{
		return dq[frontPtr];
	}

	bool pop_back()
	{
		if (sizeNr == 0)
			return false;

		backPtr = (backPtr - 1 + capacity) % capacity;
		--sizeNr;
		return true;
	}

	bool pop_front()
	{
		if (sizeNr == 0)
			return false;

		frontPtr = (frontPtr + 1) % capacity;
		--sizeNr;
		return true;
	}

	bool push_back(const T& x)
	{
		if (sizeNr >= capacity)
			return false;

		dq[backPtr] = x;
		backPtr = (backPtr + 1) % capacity;
		++sizeNr;
		return true;
	}

	bool push_front(const T& x)
	{
		if (sizeNr >= capacity)
			return false;

		frontPtr = (frontPtr - 1 + capacity) % capacity;
		dq[frontPtr] = x;
		++sizeNr;
		return true;
	}

	bool empty() const
	{
		return (sizeNr == 0);
	}

	int size() const
	{
		return sizeNr;
	}

	void clear()
	{
		frontPtr = backPtr = sizeNr = 0;
	}

private:

	T* dq;
	int capacity, sizeNr;
	int frontPtr, backPtr;
};

int x[NRMAX + 1];

int main()
{
	//ios_base::sync_with_stdio(false);
	//cin.tie(nullptr);
	//cout.tie(nullptr);

	Deque <int> dq(NRMAX + 1);
	int n, k, i;
	int64_t sum = 0;

	fin >> n >> k;
	for (i = 1; i <= n; ++i)
	{
		fin >> x[i];

		while (!dq.empty() && x[dq.fronrt()] >= x[i])
			dq.pop_front();

		dq.push_front(i);

		if (i < k)
			continue;

		while (!dq.empty() && dq.back() <= (i - k))
			dq.pop_back();

		//cout << x[dq.back()] << " ";
		if(!dq.empty())
			sum += (int64_t)x[dq.back()];

	}

	fout << sum;

	return 0;
}