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 <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cassert>
#include <cstdint>
#include <iostream>
#include <iomanip>
#include <string>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <numeric>
#include <bitset>

using namespace std;

using ll =  long long;
using Pll = pair<ll, ll>;
using Pii = pair<int, int>;

constexpr ll MOD = 1000000007;
constexpr long double EPS = 1e-10;
constexpr int dyx[4][2] = {
    { 0, 1}, {-1, 0}, {0,-1}, {1, 0}
};

int main() {
    std::ios::sync_with_stdio(false); cin.tie(nullptr);
    int n, k;
    cin >> n >> k;
    vector<int> a(n), lt;
    for(int i=0;i<n;++i){
        cin >> a[i];
        if(i && a[i-1] > a[i]) lt.push_back(i-1);
    }

    if(lt.empty()) {
        cout << 1 << endl;
        return 0;
    }

    int max_a = 0;
    int lt_idx = (lt[0] < k)?0:-1;
    for(int i=0;i<k;++i) {
        max_a = max(max_a, a[i]);
    }
    
    bool sonomama = (lt[0]>=k)?true:false;
    int ans = sonomama?0:1;
    for(int i=k;i<n;++i) {
        while(lt_idx+1 < lt.size() && lt[lt_idx+1] < i) ++lt_idx;
        if(max_a < a[i]) {
            max_a = a[i];
            if(i-lt[lt_idx] < k) {
                if(a[i-k] < a[i-k+1] && a[i-1] < a[i]) continue;
            } else {
                sonomama = true;
                continue;
            }
        }
        ++ans;
    }

    if(sonomama) ++ans;
    cerr << endl;

    cout << ans << endl;
}