可持久化线段树——Step 1 静态区间第K大

考虑这样一个问题：
给出一段长度为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 
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 ;
}

是不是挺简单的啊~