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: Wrong Answer)

#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
typedef pair<int, int> P;
typedef long long ll;
const int INF = 1001001001;
const ll LINF = 1001002003004005006ll;
const ll MOD = 1e9+7;

int main() {
	int n, k;
	cin >> n >> k;
    vector<int> v(n+1);
    rep(i, n) {
        cin >> v[i];
    }
    v[n] = n;

    int ans = 1;
    int maxp = -1;
    int minp = n;
    rep(j, k) {
        maxp = max(maxp, v[j]);
        minp = min(minp, v[j]);
    }

    rep(i, n-k) {
        if (v[i] != minp || v[i+k] < maxp) {
            ++ans;
        } else if (v[i+k] > maxp) {
            maxp = v[i+k];
        } else {
            int maxp = -1;
            int minp = n;
            rep(j, k) {
                maxp = max(maxp, v[i+j]);
                minp = min(minp, v[i+j]);
            }            
        }
    }
    cout << ans << endl;

	return 0;
}