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 Kotlin (1.0.0) (judge verdict: Accepted)

import java.util.*

fun slideMin(a: List<Int>, k: Int): ArrayList<Int> {
  val res = arrayListOf<Int>()
  val deq: Deque<Int> = LinkedList()
  for (r in 0 until a.size) {
    val l = r - k + 1
    while (!deq.isEmpty() && a[deq.getLast()] >= a[r]) deq.removeLast()
    deq.add(r)
    if (l < 0) continue
    res.add(deq.getFirst())
    if (deq.getFirst() == l) deq.removeFirst()
  }
  return res
}

fun slideMax(a: List<Int>, k: Int): ArrayList<Int> {
  val res = arrayListOf<Int>()
  val deq: Deque<Int> = LinkedList()
  for (r in 0 until a.size) {
    val l = r - k + 1
    while (!deq.isEmpty() && a[deq.getLast()] <= a[r]) deq.removeLast()
    deq.add(r)
    if (l < 0) continue
    res.add(deq.getFirst())
    if (deq.getFirst() == l) deq.removeFirst()
  }
  return res
}

fun main(args: Array<String>) {
  val (n, k) = readLine()!!.split(" ").map { it.toInt() }
  val p = readLine()!!.split(" ").map { it.toInt() }
  val isUp = IntArray(n) { 
    if (it == 0) {
      0
    } else {
      if (p[it - 1] < p[it]) 1 else 0
    }
  }
  val cs = mutableListOf<Int>(0)
  isUp.reduce { buf, value ->
    cs.add(buf + value)
    buf + value
  }

  var sorted = 0
  var ans = 0
  val mn = slideMin(p, k + 1)
  val mx = slideMax(p, k + 1)
  for (i in 0..n - k) {
    val d = cs[i + k - 1] - cs[i]
    if (d == k - 1) {
      sorted = 1 
      continue
    }
    if (i > 0 && mn[i - 1] == i - 1 && mx[i - 1] == i + k - 1) continue
    ans++
  }
  println(ans + sorted)
}