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 <iostream>
#include <sstream>
#include <algorithm>
#include <string>
#include <vector>
#include <stack>
#include <set>
#include <queue>
#include <map>
#include <numeric>
#include <functional>
#include <math.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;

#define INF ((int)1e9)
#define INFLL ((ll)1e18)
#define MOD (1000000007LL)


int main(int argc, const char * argv[]) {
    ios_base::sync_with_stdio(false);
    int N, K;
    cin >> N >> K;
    vector<int> P(N);
    for (int n = 0; n < N; ++n) cin >> P[n];
    
    if (N == K) {
        cout << 1 << endl;
        return 0;
    }
    
    vector<int> vnMin(N-K), vnMax(N-K);
    deque<int> deqMin, deqMax;
    for (int n = 0; n < N; ++n) {
        while (!deqMin.empty()) {
            if (P[deqMin.back()] > P[n]) {
                deqMin.pop_back();
            } else {
                break;
            }
        }
        deqMin.push_back(n);
        if (n >= K) {
            vnMin[n-K] = P[deqMin[0]];
            if (deqMin.front() == n-K) {
                deqMin.pop_front();
            }
        }
        
        while (!deqMax.empty()) {
            if (P[deqMax.back()] < P[n]) {
                deqMax.pop_back();
            } else {
                break;
            }
        }
        deqMax.push_back(n);
        if (n >= K) {
            vnMax[n-K] = P[deqMax[0]];
            if (deqMax.front() == n-K) {
                deqMax.pop_front();
            }
        }
    }
    
    int nCount = 0;
    int nOrigInc = 0;
    vector<int> vnOrigInc(N-K+1, 0);
    for (int n = 0; n < N-1; ++n) {
        if (P[n] < P[n+1]) {
            ++nCount;
        }
        if (n >= K-1 && P[n-K+1] < P[n-K+2]) {
            --nCount;
        }
        if (nCount == K-1) {
            ++nOrigInc;
            vnOrigInc[n-K+2] = 1;
        }
    }
    
    int nRes = N-K+1;
    for (int n = 0; n+K < N; ++n) {
        if (!vnOrigInc[n] && P[n] == vnMin[n] && P[n+K] == vnMax[n]) {
            --nRes;
        }
    }
    
    if (nOrigInc > 1) {
        nRes -= (nOrigInc - 1);
    }
    cout << nRes << endl;

    return 0;
}