考慮這樣一個問題：
給出一段長度為n序列{ai}，對於一些詢問{L,R,K}請輸出序列上[L,R]內第K大的數。

關於暴力做法，其實是很簡單的，但是會超時，在此略過。

有一種辦法，是利用字首和的思想。先將{ai}離散到區間[1,n]，然後，對於任意節點i，都建立一棵權值線段樹，代表離散後{a1,…ai}在權值區間[1,n]出現的次數。

這樣，對於序列上的某一段[L,R]，我們就可以通過權值線段樹R和L-1某個節點儲存的權值出現次數相減，得到序列上這一段在這個節點代表的權值區間上的數字個數。（Tips:請注意區分序列上區間和權值線段樹節點代表的區間）

如果不考慮記憶體，那麼問題已經解決了，但是對於序列上的任意一點，我們都建立了一棵線段樹，此時空間複雜度已經達到平方級別，顯然不行。

但是考慮到一個巧妙的現象，對於第i棵線段樹，其實比起前一棵來說就多了一個數字，但是我們卻新建了一整棵線段樹！是不是有一點不划算啊2333

首先明確一個顯而易見的事實：無論如何，這n棵權值線段樹的結構形態都是一樣的。
對於權值線段樹上的任意一個節點，新加入一個屬於它的值進來，顯然這個節點的值要+1，然後再向下更新。但是，它就只有兩個兒子節點，這個更新的方向不是往左就是往右。

那麼這時對於第i棵線段樹，它的每一層，其實都只有一個節點和第i−1棵的相應節點不一樣。按道理說，這個線段樹真正需要記錄的就只是新建一條從上到下的鏈（需要記錄子節點是左還是右）來記錄，而不是新建一整棵線段樹。
如何確定不用更改的那些呢？很簡單，對於這條鏈上的任意一個非葉子節點，它有兒子的那一邊就不管，另一個子節點直接沿用上一棵線段樹的相應節點就行了。最後向上更新就行了。

給出參考程式碼：

#include <bits/stdc++.h>
using namespace std ;
bool Read ( int &x ) { char c = getchar() ; x = 0 ; bool f = 0 ; while ( !isdigit(c) ) { if ( c == '-' ) f = 1 ; if ( c == EOF ) return false ; c = getchar() ; } while ( isdigit(c) ) { x = 10 * x + c - '0' ; c = getchar() ; } if (f) x = -x ;return
 
 true ; }
void Print ( int x ) { int len = 0, a[50] ; if ( x == 0 ) { putchar('0') ; return ; } if ( x < 0 ) { putchar('-') ; x = -x ; } while (x) { a[++len] = x%10 ; x /= 10 ; } while (len) putchar(a[len--]+'0') ;}

const int maxn = 100010 ;
int n, m, rt[maxn], Rank[maxn], cnt ;
struct node {
    int l, r, v ;
} tree[maxn<<5] ;
struct nodd {
    int v, id ;
    friend bool operator < ( nodd a, nodd b ) {
        return a.v == b.v ? a.id < b.id : a.v < b.v ;
    }
} a[maxn] ;

void insert ( int K, int& x, int l, int r ) {
    tree[++cnt] = tree[x] ;
    x = cnt ;
    ++ tree[x].v ;
    int mid = l+r >> 1 ;
    if ( l == r ) return ;
    if ( K <= mid ) insert ( K, x[tree].l, l, mid ) ;
    else insert ( K, x[tree].r, mid+1, r ) ;
}

int query ( int rt1, int rt2, int l, int r, int K ) {
    if ( l == r ) return l ;
    int mid = l+r >> 1 ;
    int num = tree[rt2].l[tree].v - tree[rt1].l[tree].v ;
    if ( K <= num ) return query ( rt1[tree].l, rt2[tree].l, l, mid, K ) ;
    else return query ( rt1[tree].r, rt2[tree].r, mid+1, r, K-num ) ;
}

int main() {
    int i, j, k, x, y ;
    Read(n) ; Read(m) ;
    for ( i = 1 ; i <= n ; i ++ ) {
        Read(a[i].v) ;
        a[i].id = i ;
    }
    sort ( a+1, a+n+1 ) ;
    for ( i = 1 ; i <= n ; i ++ ) 
        a[i].id[Rank] = i ;

    for ( i = 1 ; i <= n ; i ++ ) {
        rt[i] = rt[i-1] ;
        insert ( Rank[i], rt[i], 1, n ) ;
    }

    while ( m-- ) {
        Read(x) ; Read(y) ; Read(k) ;
        Print( a[query( rt[x-1], rt[y], 1, n, k )].v ) ;
        putchar('\n') ;
    }

    return 0 ;
}

是不是挺簡單的啊~