#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const long double eps = 1e-10;
const int step[8][2] = {{-1, 0}, {0, 1}, {1, 0},  {0, -1},
                        {-1, 1}, {1, 1}, {1, -1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
  return a < 0 ? -a : a;
}
template <typename t, typename t1>
t min1(t a, t1 b) {
  return a < b ? a : b;
}
template <typename t, typename... arg>
t min1(t a, arg... arr) {
  return min1(a, min1(arr...));
}
template <typename t, typename t1>
t max1(t a, t1 b) {
  return a > b ? a : b;
}
template <typename t, typename... arg>
t max1(t a, arg... arr) {
  return max1(a, max1(arr...));
}
inline int jud(double a, double b) {
  if (abs(a) < eps && abs(b) < eps)
    return 0;
  else if (abs1(a - b) / max(abs1(a), abs1(b)) < eps)
    return 0;
  if (a < b) return -1;
  return 1;
}
template <typename t>
inline int jud(t a, t b) {
  if (a < b) return -1;
  if (a == b) return 0;
  return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
  if (na == 0) return 0;
  int be = 0, en = na - 1;
  if (*a <= *(a + na - 1)) {
    if (f_lb == 0)
      while (be < en) {
        int mid = (be + en + 1) / 2;
        if (jud(*(a + mid), val) != 1)
          be = mid;
        else
          en = mid - 1;
      }
    else
      while (be < en) {
        int mid = (be + en) / 2;
        if (jud(*(a + mid), val) != -1)
          en = mid;
        else
          be = mid + 1;
      }
    if (f_small && jud(*(a + be), val) == 1) be--;
    if (!f_small && jud(*(a + be), val) == -1) be++;
  } else {
    if (f_lb)
      while (be < en) {
        int mid = (be + en + 1) / 2;
        if (jud(*(a + mid), val) != -1)
          be = mid;
        else
          en = mid - 1;
      }
    else
      while (be < en) {
        int mid = (be + en) / 2;
        if (jud(*(a + mid), val) != 1)
          en = mid;
        else
          be = mid + 1;
      }
    if (!f_small && jud(*(a + be), val) == -1) be--;
    if (f_small && jud(*(a + be), val) == 1) be++;
  }
  return be;
}
template <class T>
inline T lowb(T num) {
  return num & (-num);
}
inline int bitnum(unsigned int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(unsigned long long nValue) {
  return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitnum(long long nValue) {
  return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitmaxl(unsigned int a) {
  if (a == 0) return 0;
  return 32 - __builtin_clz(a);
}
inline int bitmaxl(int a) {
  if (a == 0) return 0;
  return 32 - __builtin_clz(a);
}
inline int bitmaxl(unsigned long long a) {
  int temp = a >> 32;
  if (temp) return 32 - __builtin_clz(temp) + 32;
  return bitmaxl(int(a));
}
inline int bitmaxl(long long a) {
  int temp = a >> 32;
  if (temp) return 32 - __builtin_clz(temp) + 32;
  return bitmaxl(int(a));
}
long long pow(long long n, long long m, long long mod = 0) {
  if (m < 0) return 0;
  long long ans = 1;
  long long k = n;
  while (m) {
    if (m & 1) {
      ans *= k;
      if (mod) ans %= mod;
    }
    k *= k;
    if (mod) k %= mod;
    m >>= 1;
  }
  return ans;
}
template <class t1, class t2>
inline void add(t1& a, t2 b, int mod = -1) {
  if (mod == -1) mod = 1000000007;
  a += b;
  while (a >= mod) a -= mod;
  while (a < 0) a += mod;
}
template <class t>
void output1(t arr) {
  for (int i = 0; i < (int)arr.size(); i++) cerr << arr[i] << ' ';
  cerr << endl;
}
template <class t>
void output2(t arr) {
  for (int i = 0; i < (int)arr.size(); i++) output1(arr[i]);
}
const int maxn = 200100;
int n, l;
int orig[maxn];
struct Range {
  int from, to;
  vector<int> align_to[2];
  bool operator<(const Range& other) const {
    if (from == other.from) {
      return to < other.to;
    }
    return from < other.from;
  }
} buf[maxn * 3];
int lbuf;
map<int, vector<int>> all_range;
int temp[2][maxn], ltemp;
int main() {
  ios_base::sync_with_stdio(0);
  scanf("%d%d", &n, &l);
  for (int i = 0; i < n; i++) {
    scanf("%d", orig + i);
    buf[lbuf].from = i;
    buf[lbuf].to = i + 1;
    buf[lbuf].align_to[0].push_back(1);
    buf[lbuf].align_to[1].push_back(1);
    all_range[orig[i]].push_back(lbuf++);
  }
  long long ans = 0;
  for (auto& it : all_range) {
    vector<int>& all_r = it.second;
    sort(all_r.begin(), all_r.end(),
         [&](const int& a, const int& b) { return buf[a] < buf[b]; });
    for (int i = 0, nxt_i = 0; i < (int)all_r.size(); i = nxt_i) {
      while (nxt_i < (int)all_r.size() - 1 &&
             buf[all_r[nxt_i + 1]].from == buf[all_r[nxt_i]].to) {
        nxt_i++;
      }
      nxt_i++;
      ltemp = 0;
      for (int j = i; j < nxt_i; j++) {
        int no = all_r[j];
        auto rbuf = buf[no];
        for (int k = 0, rsum = 0; k < (int)rbuf.align_to[0].size(); k++) {
          temp[0][ltemp] = rbuf.align_to[0][k];
          temp[1][ltemp++] = rbuf.align_to[1][rbuf.align_to[0].size() - k - 1];
          if (k >= l - 1)
            rsum += rbuf.align_to[1][rbuf.align_to[0].size() - k - 1 + l - 1];
          ans -= 1ll * rbuf.align_to[0][k] * rsum;
        }
      }
      for (int j = 0, sum = 0; j < ltemp; j++) {
        if (j >= l - 1) sum += temp[1][j - l + 1];
        ans += 1ll * temp[0][j] * sum;
      }
      if (ltemp >= l) {
        buf[lbuf].from = buf[all_r[i]].from;
        buf[lbuf].to = buf[all_r[nxt_i - 1]].to;
        for (int j = l - 1; j < ltemp; j++) {
          if (j % l == l - 1) {
            buf[lbuf].align_to[0].push_back(0);
            buf[lbuf].align_to[1].push_back(0);
          }
          buf[lbuf].align_to[0].back() += temp[0][j];
          buf[lbuf].align_to[1].back() += temp[0][ltemp - 1 - j];
        }
        all_range[it.first + 1].push_back(lbuf++);
      }
    }
  }
  cout << ans + n << endl;
  return 0;
}
