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 Ruby (2.3.3) (judge verdict: Wrong Answer)

N,K=gets.split.map &:to_i
ps=gets.split.map &:to_i
cs=Array.new(N,1)
min_deq=Array.new(0)
max_deq=Array.new(0)
K.times do |i|
    if min_deq.empty?
        min_deq << i
    else
        until min_deq.empty?
            if ps[i] < ps[min_deq[-1]]
                min_deq.pop
            else
                break
            end
        end
        min_deq << i
    end
end

K.times do |i|
    if max_deq.empty?
        max_deq << i
    else
        until max_deq.empty?
            if ps[i] > ps[max_deq[-1]]
                max_deq.pop
            else
                break
            end
        end
        max_deq << i
    end
end

(N-K).times do |i|
    until min_deq.empty?
        if ps[i+K] <= ps[min_deq[-1]]
            min_deq.pop
        else
            break
        end
    end
    min_deq << i+K
    until max_deq.empty?
        if ps[i+K] >= ps[max_deq[-1]]
            max_deq.pop
        else
            break
        end
    end
    max_deq << i+K
    # p min_deq + ["#"] + max_deq
    cs[i+K]=cs[i+K-1]+1
    cs[i+K]-=1 if ps[i]==ps[min_deq[0]] && ps[i+K]==ps[max_deq[0]]
    min_deq.shift if min_deq[0]==i
    max_deq.shift if max_deq[0]==i
end
cnt=cs[-1]
cnt_up=1
cnt_k=-1
for i in 1..N-1
    if ps[i-1] < ps[i]
        cnt_up+=1
    else
        cnt_up=1
    end
    # p cnt_up
    if K==cnt_up
        cnt_k+=1
        cnt_up=0
    end
end
p [cnt-(cnt_k<0 ? 0 : cnt_k),1].max