Problem:
Score : 700 points

Problem Statement

Snuke has a permutation (P_0,P_1,\cdots,P_{N-1}) of (0,1,\cdots,N-1).

Now, he will perform the following operation exactly once:

Choose K consecutive elements in P and sort them in ascending order.

Find the number of permutations that can be produced as P after the operation.

Constraints

2 \leq N \leq 200000

2 \leq K \leq N

0 \leq P_i \leq N-1

P_0,P_1,\cdots,P_{N-1} are all different.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K
P_0 P_1 \cdots P_{N-1}

Output

Print the number of permutations that can be produced as P after the operation.

Sample Input 1

5 3
0 2 1 4 3

Sample Output 1

2

Two permutations can be produced as P after the operation: (0,1,2,4,3) and (0,2,1,3,4).

Sample Input 2

4 4
0 1 2 3

Sample Output 2

1

Sample Input 3

10 4
2 0 1 3 7 5 4 6 8 9

Sample Output 3

6

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template<class T = int> using V = vector<T>;
template<class T = int> using VV = V< V<T> >;

struct SegmentTree {
  using T = struct { int min, max; };
  static T op(const T& a, const T& b) { return {min(a.min, b.min), max(a.max, b.max)}; }
  static constexpr T e() { return {(int)1e9, (int)-1e9}; }

  const int n;
  V<T> t;
  SegmentTree(int n) : n(n), t(2 * n, e()) {}
  T& operator[](int i) { return t[i + n]; }
  void build() { for (int i = n - 1; i; --i) t[i] = op(t[2 * i], t[2 * i + 1]); }
  T acc(int l, int r) const {
    T resl = e(), resr = e();
    for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
      if (l & 1) resl = op(resl, t[l++]);
      if (r & 1) resr = op(t[--r], resr);
    }
    return op(resl, resr);
  }
  void set(int i, const T& a) {
    t[i += n] = a;
    while (i >>= 1) t[i] = op(t[2 * i], t[2 * i + 1]);
  }
};

int main() {
  cin.tie(nullptr); ios::sync_with_stdio(false);
  int n, k; cin >> n >> k;
  V<> p(n);
  SegmentTree st(n);
  for (int i = 0; i < n; ++i) {
    cin >> p[i];
    st[i] = {p[i], p[i]};
  }
  st.build();
  V<> c(n);
  for (int i = 0; i < n - 1; ++i) {
    c[i] = p[i] < p[i + 1];
  }
  for (int i = n - 1; i; --i) {
    c[i - 1] += c[i];
  }

  int res = 0;
  bool ex = false;
  for (int i = 0; i + k <= n; ++i) {
    if (c[i] - c[i + k - 1] == k - 1) {
      ex = true;
      continue;
    }
    if (i + k < n) {
      auto e = st.acc(i + 1, i + k);
      if (p[i] < e.min and e.max < p[i + k]) continue;
    }
    ++res;
  }
  res += ex;
  cout << res << '\n';
}