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: Accepted)

    #![allow(unused_imports)]
    #![allow(dead_code)]
    use std::io::prelude::*;
    use std::cmp::{max, min};
    use std::collections::{BinaryHeap, VecDeque};

    const MOD: i64 = 1e9 as i64 + 7; 

    fn main(){
        let n: usize = read();
        let k: usize = read();
        let p: Vec<usize> = (0..n).map(|_| read()).collect();
        let mut q1 = VecDeque::new();
        let mut q2 = VecDeque::new();
        let mut ans = 1;
        let mut cnt = 0;
        for i in 0..k{
            while !q1.is_empty() && *q1.back().unwrap() > p[i]{
                q1.pop_back();
            }
            while !q2.is_empty() && *q2.back().unwrap() < p[i]{
                q2.pop_back();
            }
            q1.push_back(p[i]);
            q2.push_back(p[i]);
        }
        if q1.len() == k{
            cnt += 1;        
        }
        
        for i in k..n{
            while !q1.is_empty() && *q1.back().unwrap() > p[i]{
                q1.pop_back();
            }
            while !q2.is_empty() && *q2.back().unwrap() < p[i]{
                q2.pop_back();
            }
            q1.push_back(p[i]);
            q2.push_back(p[i]);
            let &mi = q1.front().unwrap();
            let &ma = q2.front().unwrap();
            let mut f = false;
            if mi != p[i - k] || ma != p[i]{
                ans += 1;
                f = true;
            }
            if mi == p[i - k]{
                q1.pop_front();
            }else if ma == p[i - k]{
                q2.pop_front();
            }
            if f && q1.len() == k{
                cnt += 1;
            }
        }
        if cnt > 0{
            ans -= cnt - 1;
        }
        println!("{}", ans);
    }

    fn read<T>() -> T
    where
        T: std::str::FromStr,
    {
        let stdin = std::io::stdin();
        let token: String = stdin
            .lock()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect();
        token.parse().ok().unwrap()
    }