#include <fstream>
#include <cassert>
#include <vector>

using namespace std;

ifstream cin ("deque.in");
ofstream cout ("deque.out");

class Deq {

public:
  Deq() {
    _sz = 0;
    _front = NULL;
    _back = NULL;
  }

  int front() {
    assert(_sz >= 0);
    return _front -> val; 
  }

  int back() {
    assert(_sz >= 0);
    return _back -> val;
  }

  bool empty() {
    return _sz == 0;
  }

  int size() {
    return _sz;
  }

  void push_back(int val) {
    _push_back(val);
  }

  void pop_back() {
    _pop_back();
  }

  void push_front(int val) {
    _push_front(val);
  }

  void pop_front() {
    _pop_front();
  }

  int operator [](int at) {
    assert (at > 0 or _sz > 0);

    int cur = 0;
    Node *n = this -> _back;
    while (cur != at) {
      cur ++;
      assert(cur <= _sz);
      n = n -> next_node;
    }
    return n -> val;
  }
private:
  
  struct Node {
    Node(int val = -1) {
      this -> val = val;
      this -> next_node = NULL;
      this -> prev_node = NULL;
    }
    int val;
    Node *next_node;
    Node *prev_node;
  };

  int _sz;
  Node *_front;
  Node *_back;

  void _push_back(int val) {
    Node *node = new Node();
    node -> val = val;
    if (_sz == 0) {
      _front = node;
      _back = node;
      _sz += 1;
    }
    else {
      _back -> prev_node = node;
      node ->  next_node = _back;
      _back = node;
      _sz += 1;
    }
  }

  void _push_front(int val) {
    Node *node = new Node();
    node -> val = val;
    if (_sz == 0) {
      _front = node;
      _back = node;
      _sz += 1;
    }
    else {
      _front -> next_node = node;
      node ->  prev_node = _front;
      _front = node;
      _sz += 1;
    }
  }

  void _pop_back() {
    assert(_sz > 0);
    if (_sz == 1) {
      delete _back;
      _back = NULL;
      _front = NULL;
      _sz -= 1;
    }
    else {
      _back = _back -> next_node;
      delete _back -> prev_node;
      _back -> prev_node = NULL;
      _sz -= 1;
    }
  }

  void _pop_front() {
    assert(_sz > 0);
    if (_sz == 1) {
      delete _back;
      _back = NULL;
      _front = NULL;
      _sz -= 1;
    }
    else {
      _front = _front -> prev_node;
      delete _front -> next_node;
      _front -> next_node = NULL;
      _sz -= 1;
    }
  }
};

long long solve(Deq* &deq, vector < int > &v, int n, int k) {
  
  long long sum = 0;

  for (int i = 1; i <= k; i ++) {
    if (deq -> size() == 0) {
      deq -> push_front(i);
    }
    else {
      if (v[i] > v[deq -> front()] and i > n - k + 1)
        continue;
      while (deq -> size() > 0 and v[i] <= v[deq -> front()]) {
        deq -> pop_front();
      }
      deq -> push_front(i);
    }
  }
  sum += v[deq -> back()];

  for (int i = k + 1; i <= n; i ++) {
    while (deq -> size() > 0 and v[i] <= v[deq -> front()]) {
      deq -> pop_front();
    }
    deq -> push_front(i);
    if (deq -> back() <= i - k) {
      deq -> pop_back();
    }
    sum += v[deq -> back()];
  }

  return sum;
}

int main () {

  int n, k;
  cin >> n >> k;
  Deq *deq = new Deq();
  vector < int > v(n + 1);
  for (int i = 1; i <= n; i ++) {
    cin >> v[i];
  }

  cout << solve (deq, v, n, k) << '\n';
}