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 <algorithm>
#include <climits>
#include <cmath>
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>

using ll = long long;
using namespace std;

int main() {
    int n = 0, k = 0;
    cin >> n >> k;
    vector<int> p(n);
    for (int i=0; i<n; i++) {
        cin >> p.at(i);
    }
    vector<int> maxi(n), mini(n);
    int max_first = 0, min_first = 0, max_last = 0, min_last = 0;
    for (int i=0; i<k; i++) {
        while (max_last > 0 && p.at(i) > p.at(maxi.at(max_last-1))) {
            max_last--;
        }
        maxi.at(max_last) = i;
        max_last++;
    }
    for (int i=0; i<k; i++) {
        while (min_last > 0 && p.at(i) < p.at(mini.at(min_last-1))) {
            min_last--;
        }
        mini.at(min_last) = i;
        min_last++;
    }
    bool sorted = false;
    int cnt = 0;
    if (min_last-min_first == k) {
        sorted = true;
    }
    else {
        cnt++;
    }
    for (int i=0; i<n-k; i++) {
        while (max_last > 0 && p.at(i+k) > p.at(maxi.at(max_last-1))) {
            max_last--;
        }
        maxi.at(max_last) = i+k;
        max_last++;
        while (min_last > 0 && p.at(i+k) < p.at(mini.at(min_last-1))) {
            min_last--;
        }
        mini.at(min_last) = i+k;
        min_last++;
        int M = maxi.at(max_first), m = mini.at(min_first);
        if (maxi.at(max_first) == i) {
            max_first++;
        }
        if (mini.at(min_first) == i) {
            min_first++;
        }
        if (min_last-min_first == k) {
            sorted = true;
        }
        else if (M != i+k || m != i) {
            cnt++;
        }
    }
    if (sorted) {
        cnt++;
    }
    cout << cnt << endl;
    return 0;
}