Problem:
Score : 600 points

Problem Statement

You are given an integer sequence A of length N and an integer K.
You will perform the following operation on this sequence Q times:

Choose a contiguous subsequence of length K, then remove the smallest element among the K elements contained in the chosen subsequence (if there are multiple such elements, choose one of them as you like).

Let X and Y be the values of the largest and smallest element removed in the Q operations. You would like X-Y to be as small as possible.
Find the smallest possible value of X-Y when the Q operations are performed optimally.

Constraints

1 \leq N \leq 2000

1 \leq K \leq N

1 \leq Q \leq N-K+1

1 \leq A_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K Q
A_1 A_2 ... A_N

Output

Print the smallest possible value of X-Y.

Sample Input 1

5 3 2
4 3 1 5 2

Sample Output 1

1

In the first operation, whichever contiguous subsequence of length 3 we choose, the minimum element in it is 1.
Thus, the first operation removes A_3=1 and now we have A=(4,3,5,2).
In the second operation, it is optimal to choose (A_2,A_3,A_4)=(3,5,2) as the contiguous subsequence of length 3 and remove A_4=2.
In this case, the largest element removed is 2, and the smallest is 1, so their difference is 2-1=1.

Sample Input 2

10 1 6
1 1 2 3 5 8 13 21 34 55

Sample Output 2

7

Sample Input 3

11 7 5
24979445 861648772 623690081 433933447 476190629 262703497 211047202 971407775 628894325 731963982 822804784

Sample Output 3

451211184

Solution in Scala (2.11.7) (judge verdict: Accepted)

import java.util
import java.util.Scanner

import scala.util.Sorting

/**
  * lewin のコードが速かったのでscalaだとどれぐらいの速度が出るのかみてみる
  */
object Main {
  def main(args: Array[String]): Unit = {
    val in = new Scanner(System.in)
    val n = in.nextInt()
    val k = in.nextInt()
    val q = in.nextInt()
    val arr = Array.fill(n)(in.nextInt())
    val solver = new TaskE
    println(solver.solve(n, k, q, arr))
  }

  class TaskE {
    def get(arr: Array[Int], k: Int, sm: Int, big: Int): Int = {
      var good = 0
      var tot = 0
      var ans = 0
      for {
        j <- arr.indices
      }{
        if (arr(j) < sm) {
          ans += Math.max(0, Math.min(tot - k + 1, good))
          good = 0
          tot = 0
        }
        else {
          tot += 1
          if (arr(j) <= big) good += 1
        }
      }
      ans += Math.max(0, Math.min(tot - k + 1, good))
      ans
    }

    def solve(n: Int, k: Int, q: Int, arr: Array[Int]): Int = {
      val brr = util.Arrays.copyOf(arr, arr.length)
      Sorting.quickSort(brr)
      var ret = brr(q - 1) - brr(0)
      for {
        small <- brr.indices
      } {
        var lo = small
        var hi = brr.length
        while (lo < hi) {
          val mid = (lo + hi) / 2
          if (get(arr, k, brr(small), brr(mid)) >= q) hi = mid
          else lo = mid + 1
        }
        if (lo < brr.length) ret = Math.min(ret, brr(lo) - brr(small))
      }
      ret
    }
  }

}