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# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AtCorder
{
	public class Program
	{
		static void Main(string[] args)
		{
			Scanner cin = new Scanner();
			int n = cin.Int();
			int k = cin.Int();
			int[] p = cin.ArrayInt(n);


			var count = new int[n];
			var ss = new SortedSet<int>();
			for (int i = 0; i < k; i++) {
				ss.Add(p[i]);
				count[p[i]]++;
			}

			int noSort = 0;
			int ren = 0;
			int pp = -1;
			var ni = new bool[n];
			for (int i = 0; i < n; i++) {
				if (p[i] >= pp) {
					ren++;
					if (ren >= k) {
						noSort++;
						ni[i] = true;
					}
				} else {
					ren = 1;
				}

				pp = p[i];
			}

			int ans = 1;
			bool isNoSort = ni[k - 1];
			for (int i = k; i < n; i++) {
				int prev = ss.Min;
				count[p[i - k]]--;
				if (count[p[i - k]] == 0) {
					ss.Remove(p[i - k]);
				}

				ss.Add(p[i]);
				count[p[i]]++;

				if (p[i - k] != prev) {
					if (ni[i]) {
						if (isNoSort == false) {
							++ans;
						}

						isNoSort = true;
					} else {
						++ans;
					}
					
					continue;
				}

				int next = ss.Max;
				if (p[i] != next) {
					if (ni[i]) {
						if (isNoSort == false) {
							++ans;
						}

						isNoSort = true;
					} else {
						++ans;
					}

					continue;
				}
			}

			Console.WriteLine(ans);
		}
	}

	public class Scanner
	{
		private readonly char[] delimiter_ = new char[] { ' ' };
		private string[] buf_;
		private int index_;

		public Scanner()
		{
			buf_ = new string[0];
			index_ = 0;
		}

		public string Next()
		{
			if (index_ < buf_.Length) {
				return buf_[index_++];
			}

			string st = Console.ReadLine();
			while (st == "") {
				st = Console.ReadLine();
			}

			buf_ = st.Split(delimiter_, StringSplitOptions.RemoveEmptyEntries);
			if (buf_.Length == 0) {
				return Next();
			}

			index_ = 0;
			return buf_[index_++];
		}

		public int Int()
		{
			return int.Parse(Next());
		}
		public int[] ArrayInt(int N, int add = 0)
		{
			int[] Array = new int[N];
			for (int i = 0; i < N; i++) {
				Array[i] = Int() + add;
			}
			return Array;
		}

		public long Long()
		{
			return long.Parse(Next());
		}

		public long[] ArrayLong(int N, long add = 0)
		{
			long[] Array = new long[N];
			for (int i = 0; i < N; i++) {
				Array[i] = Long() + add;
			}
			return Array;
		}

		public double Double()
		{
			return double.Parse(Next());
		}

		public double[] ArrayDouble(int N, double add = 0)
		{
			double[] Array = new double[N];
			for (int i = 0; i < N; i++) {
				Array[i] = Double() + add;
			}
			return Array;
		}
	}
}