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

template <class T> using Vec = vector<T>;

template <class T, class F> struct QueueAggregation {
    const F f;
    const T e;
    Vec<T> as, bs, ae, be;
    T vs, ve;
    QueueAggregation(F f_, T e_) : f(f_), e(e_), vs(e), ve(e) {}

    void push_s(const T& x) { as.push_back(x), bs.push_back(vs = f(x, vs)); }
    void push_e(const T& x) { ae.push_back(x), be.push_back(ve = f(ve, x)); }
    void reduce() {
        while (!ae.empty()) {
            push_s(ae.back()), ae.pop_back();
        }
        while (!be.empty()) be.pop_back();
        ve = e;
    }

    bool empty() const { return as.empty() && ae.empty(); }
    int size() const { return int(as.size() + ae.size()); }

    void push(const T& x) {
        if (as.empty()) {
            push_s(x), reduce();
        } else {
            push_e(x);
        }
    }
    void pop() {
        assert(!empty());
        if (as.empty()) reduce();
        as.pop_back(), bs.pop_back();
        vs = (bs.empty() ? e : bs.back());
    }
    T prod() const { return f(vs, ve); }
};

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(20);

    int N, M;
    cin >> N >> M;
    auto P = Vec<int>(N);
    for (int& a : P) {
        cin >> a;
        a--;
    }
    auto invP = Vec<int>(N);
    using views::iota, views::reverse;
    for (int i : iota(0, N)) {
        invP[P[i]] = i;
    }

    constexpr int MAXN = 50010;
    using Bitset = bitset<MAXN>;
    auto larger = Bitset{};
    auto mat = Vec<Bitset>(N);  // mat[i][d] := [P[i] < P[i + d]]
    for (int p : iota(0, N) | reverse) {
        int i = invP[p];
        mat[i] = larger >> i;
        larger.set(i);
    }

    auto all_set = Bitset{};
    all_set.set();
    auto qa = QueueAggregation(
        [](const Bitset& l, const Bitset& r) { return l & r; }, all_set);
    int64_t ans = 0;
    for (int st = 0, en = 0; st + M <= N; st++) {
        while (en - st < M) {
            qa.push(mat[en]);
            en++;
        }
        ans += int(qa.prod().count());
        qa.pop();
    }
    cout << ans << '\n';

    return 0;
}