#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define elif else if
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>

#define repname(a, b, c, d, e, ...) e
#define rep(...) repname(__VA_ARGS__, rep3, rep2, rep1, rep0)(__VA_ARGS__)
#define rep0(x) for (int rep_counter = 0; rep_counter < (x); ++rep_counter)
#define rep1(i, x) for (int i = 0; i < (x); ++i)
#define rep2(i, l, r) for (int i = (l); i < (r); ++i)
#define rep3(i, l, r, c) for (int i = (l); i < (r); i += (c))

#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")

struct ScalarInput
{
  template <class T>
  operator T()
  {
    T ret;
    cin >> ret;
    return ret;
  }
};
struct VectorInput
{
  size_t n;
  VectorInput(size_t n) : n(n) {}
  template <class T>
  operator vector<T>()
  {
    vector<T> ret(n);
    for (T &x : ret)
      cin >> x;
    return ret;
  }
};
ScalarInput input() { return ScalarInput(); }
VectorInput input(size_t n) { return VectorInput(n); }

template <typename T>
void print(vector<T> a)
{
  for (int i = 0; i < a.size(); i++)
  {
    cout << a[i] << " \n"[i + 1 == a.size()];
  }
}

template <class T>
void print(T x)
{
  cout << x << '\n';
}

template <class Head, class... Tail>
void print(Head &&head, Tail &&...tail)
{
  cout << head << ' ';
  print(forward<Tail>(tail)...);
}

template <typename T, typename F>
struct SlideWindowAggregation
{
//   vector<T> a0, a1, r0, r1;
  deque<T> a0, a1, r0, r1;
  F f;
  T I, f0, f1;

  SlideWindowAggregation(F _f, T _i) : f(_f), I(_i), f0(_i), f1(_i) {}

private:
  void push_s0(const T &x)
  {
    // a0.push_back(x);
    // r0.push_back(f0 = f(x, f0));
    a0.emplace_back(x);
    r0.emplace_back(f0 = f(x, f0));
  }
  void push_s1(const T &x)
  {
    // a1.push_back(x);
    // r1.push_back(f1 = f(f1, x));
    a1.emplace_back(x);
    r1.emplace_back(f1 = f(f1, x));
  }
  void transfer()
  {
    while (!a1.empty())
    {
      push_s0(a1.back());
      a1.pop_back();
    }
    // while (!r1.empty())
    //   r1.pop_back();
    r1.clear();
    f1 = I;
  }

public:
  void push(const T &x)
  {
    if (a0.empty())
    {
      push_s0(x);
      transfer();
    }
    else
    {
      push_s1(x);
    }
  }
  void pop()
  {
    if (a0.empty())
      transfer();
    a0.pop_back();
    r0.pop_back();
    f0 = r0.empty() ? I : r0.back();
  }
  T query() { return f(f0, f1); }
};

using BS = bitset<50000>;
int main()
{
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int n, m;
  cin >> n >> m;
  vector<int> p(n), inv(n);
  rep(i, n)
  {
    cin >> p[i];
    p[i]--;
    inv[p[i]] = i;
  }

//   ll s = n - m + 1;
//   if (s * s * (ll)n <= 5e6)
//   {
//     ll ans = 0;
//     for (int i = 0; i < s; i++)
//     {
//       for (int j = i + 1; j < s; j++)
//       {
//         bool flag = true;
//         for (int k = 0; k < m; k++)
//         {
//           if (p[i + k] > p[j + k])
//           {
//             flag = false;
//             break;
//           }
//         }
//         if (flag)
//         {
//           ans++;
//         }
//       }
//     }
//     cout << ans << endl;
//     exit(0);
//   }

  vector<BS> dp(n);

  BS B(0);
  for (int i = n - 1; i >= 0; i--)
  {
    dp[inv[i]] = B >> inv[i];
    B.set(inv[i], 1);
  }

  auto f = [](const BS &a, const BS &b)
  {
    return a & b;
  };
  BS e(0);
  e.flip();
  SlideWindowAggregation<BS, decltype(f)> swag(f, e);
  {
    swag.a1.resize(m);
    swag.r1.resize(m);
    
    swag.a1.clear();
    swag.r1.clear();
  }
  for (int i = 0; i < m - 1; i++)
    swag.push(dp[i]);
  ll ans = 0;
  for (int i = m - 1; i < n; i++)
  {
    swag.push(dp[i]);
    ans += swag.query().count();
    swag.pop();
  }
  cout << ans << endl;
}