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 Rust (1.15.1) (judge verdict: Wrong Answer)

// Practice AtCoder
// author: Leonardone @ NEETSDKASU

fn main() {
    let mut stdin = String::new();
    std::io::Read::read_to_string(&mut std::io::stdin(), &mut stdin).unwrap();
    let mut stdin = stdin.split_whitespace();
    let mut get = || stdin.next().unwrap();
    macro_rules! get {
        ($t:ty) => (get().parse::<$t>().unwrap());
        () => (get!(i64));
    }
    
    let n = get!(usize);
    let k = get!(usize);
    let mut vs = vec![];
    for i in 0 .. n {
        let v = get!();
        vs.push(v);
    }
    let mut ord = vec![1; n];
    for i in 1 .. n {
        if vs[i-1] < vs[i] {
            ord[i] = ord[i-1] + 1;
        }
    }
    let mut pqmin = std::collections::BinaryHeap::new();
    let mut pqmax = std::collections::BinaryHeap::new();
    for i in 0 .. k {
        pqmin.push((-vs[i], i));
        pqmax.push((vs[i], i));
    }
    let mut ans = 1;
    for i in 0 .. n - k {
        let d = ord[i+k] - ord[i+1] + 1;
        let min = {
            let mut r = (0, n);
            while let Some((v, j)) = pqmin.pop() {
                if j < i {
                    continue;
                }
                r.0 = v;
                r.1 = j;
                break;
            }
            r
        };
        let max = {
            let mut r = (0, n);
            while let Some((v, j)) = pqmax.pop() {
                if j < i {
                    continue;
                }
                r.0 = v;
                r.1 = j;
                break;
            }
            r
        };
        if !(min.1 == i && max.0 < vs[i+k]) && d < k {
            ans += 1;
        }
        if min.1 != i {
            pqmin.push(min);
        }
        if max.1 != i {
            pqmax.push(max);
        }
        pqmin.push((-vs[i+k], i+k));
        pqmax.push((vs[i+k], i+k));
    }
    println!("{}", ans);
}