output_description: Print the smallest possible value of X-Y.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N K Q
      A_1 A_2 ... A_N
attempt: n, k, q = map(int, input().split())
  # N: 処理する区間の長さ
  N0 = 2 ** (n - 1).bit_length()
  INF = 2**31 - 1
  data = [INF] * (2 * N0)
  a = list(map(int, input().split()))
  for i in range(N0):
      data[i + N0] = a[i]
  
  
  # a_k の値を x に更新
  def update(k, x):
      k += N0 - 1
      data[k] = x
      while k >= 0:
          k = (k - 1) // 2
          data[k] = min(data[2 * k + 1], data[2 * k + 2])
  
  
  # 区間[l, r)の最小値
  def query(l, r):
      L = l + N0
      R = r + N0
      s = INF
      while L < R:
          if R & 1:
              R -= 1
              s = min(s, data[R - 1])
  
          if L & 1:
              s = min(s, data[L - 1])
              L += 1
          L >>= 1
          R >>= 1
      return s
  
  
  ans = []
  for i in range(q):
      res = INF
      for i in range(n - k + 1):
          v = query(i, i + k)
          if res > v:
              res = v
              ind = i
  
      ans.append(res)
      update(i, INF)
  
  
  print(max(ans) - min(ans))
  
problem_description: 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.
samples: [{"input": "5 3 2\n    4 3 1 5 2", "output": "1\n    \n\nIn the first operation, whichever contiguous subsequence of length 3 we\nchoose, the minimum element in it is 1. Thus, the first operation removes\nA_3=1 and now we have A=(4,3,5,2). In the second operation, it is optimal to\nchoose (A_2,A_3,A_4)=(3,5,2) as the contiguous subsequence of length 3 and\nremove A_4=2. In this case, the largest element removed is 2, and the smallest\nis 1, so their difference is 2-1=1.\n\n* * *"}, {"input": "10 1 6\n    1 1 2 3 5 8 13 21 34 55", "output": "7\n    \n\n* * *"}, {"input": "11 7 5\n    24979445 861648772 623690081 433933447 476190629 262703497 211047202 971407775 628894325 731963982 822804784", "output": "451211184"}]