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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		int N = scn.nextInt();
		int K = scn.nextInt();
		int[] P = new int[N];

		int b = 1;
		int check = 0;
		for (int i = 0; i < N; i++) {
			P[i] = scn.nextInt();
			if(i > 0) {
				if(P[i] > P[i-1]) {
					b++;
					if(b>= K)check++;
				}else {
					b = 1;
				}
			}
		}
		PriorityQueue<Integer> max = new PriorityQueue<Integer>(new MyComp());
		PriorityQueue<Integer> min = new PriorityQueue<Integer>();

		boolean[] used = new boolean[N + 1];
		int[] A_max = new int[N - K + 1];
		int[] A_min = new int[N - K + 1];
		for (int i = 0; i <= N; i++) {
			if (i < K) {
				max.add(P[i]);
				min.add(P[i]);
			} else {
				int ma, mi;
				while (true) {
					ma = max.poll();
					if (!used[ma])
						break;
				}
				while (true) {
					mi = min.poll();
					if (!used[mi])
						break;
				}
				A_max[i - K] = ma;
				A_min[i - K] = mi;
				used[P[i - K]] = true;
				if (i != N) {
					max.add(P[i]);
					min.add(P[i]);
					max.add(ma);
					min.add(mi);
				}
			}
		}
		int ans = 1;
		for(int i = 0;i < N-K;i++) {
			if(A_max[i] < P[i+K] && A_min[i+1] > P[i] ) {

			}else {
				ans++;
			}
		}
		ans -= Math.max(check-1, 0);


		System.out.println(Math.max(ans,1));

	}

}

class MyComp implements Comparator<Integer> {

	@Override
	public int compare(Integer o1, Integer o2) {
		if (o1 > o2) {
			return -1;
		}
		if (o1 < o2) {
			return 1;
		}
		return 0;
	}

}