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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <tuple>
#include <iomanip>
#include <cstring>

using namespace std;

typedef long long ll;
//typedef pair<int,int> Pint;
//typedef pair<ll, ll> P;
typedef pair<ll, pair<ll, ll> > P;
//typedef tuple<int,int,int> T;
typedef vector<ll> vec;
typedef vector<vec> mat;
#define rep(i, n) for(ll i = 0; i < (n); i++)
#define revrep(i, n) for(ll i = (n-1); i >= 0; i--)
#define pb push_back
#define f first
#define s second
const ll INFL = 1LL << 60;//10^18 = 2^60
const int INF = 1 << 30;//10^9
const ll MOD = 1e9 + 7;
//const ll MOD  = 998244353;
//vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};
//vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};

ll max(ll a, ll b){return (a > b) ? a : b;}
ll min(ll a, ll b){return (a < b) ? a : b;}
ll pow_long(ll x, ll k){
  ll res = 1;
  while(k > 0){
    if(k % 2) res *= x;
    x *= x;
    k /= 2;
  }
  return res;
}

const ll N_ = (1 << 18);
ll seg[2*N_-1];
//Range Minimum Query
void update(ll k, ll x){
  k += N_-1;
  seg[k] = x;
  while(k > 0){
    k = (k-1)/2;
    seg[k] = min(seg[2*k+1], seg[2*k+2]);
  }
}

ll query(ll x, ll y, ll k, ll left, ll right){
  if(right <= x || y <= left) return INFL;
  if(x <= left && right <= y) return seg[k];
  ll mid = (left + right) / 2;
  ll l = query(x, y, 2*k+1, left, mid);
  ll r = query(x, y, 2*k+2, mid, right);
  return min(l, r);
}

ll N, K, Q;
vector<ll> A;

int main(void){
  cin >> N >> K >> Q;
  A.resize(N);
  rep(i, N) cin >> A[i];
  rep(i, N) update(i, A[i]);
  ll ans = INFL;
  rep(i, N){
    vector<pair<ll, ll>> can;
    rep(j, N){
      ll k = j + K;
      if(query(j, k, 0, 0, N_) >= A[i]){
        while(query(j, k+1, 0, 0, N_) >= A[i]) k++;
        can.pb({j, k});
        j = k-1;
      }
    }

    ll cnt = 0;
    rep(j, can.size()) cnt += (can[j].s - can[j].f) - K + 1;

    if(cnt < Q) continue;
    vector<ll> xs;
    rep(j, can.size()) for(ll k = can[j].f; k < can[j].s; k++) xs.pb(A[k]);
    sort(xs.begin(), xs.end());
    if(xs[0] < A[i]) continue;
    ans = min(ans, xs[Q-1] - A[i]);
  }
  cout << ans << endl;
}