划分树

HDU2665
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int maxn = 100000 + 1000 ;
/*
划分树是一个基于线段树的二叉检索树
与线段树用一维数组不区分深度不同
划分树使用二维数组tree[20][maxn]，前一个下标表示深度，以便区分子树 
划分树使用logn的复杂度查询给定区间的第k大的数
查询区间第k大也可以用快排来做，不过复杂度是nlogn,划分树预处理构建了一颗二叉检索树
*/ 
//划分树构造的二叉检索树结构，实际上将划分树的叶节点按照中序遍历等方法输出得到的就是排好序的序列 
int tree[20][maxn] ; 
//对输入的数字序列排序，为在构树的时候提供中位数 
int sorted[maxn] ;
//toleft[p][i]表示第p层的一个区间[L,R]中，他的[L,i]区间里被划分到他的坐姿区间的数的个数
int toleft[20][maxn] ;

void build( int l , int r  , int dep){
    if( l == r) return ;
    //区间中点 
    int mid = ( l + r) >> 1 ;
    //当前same表示区间左子树的数字个数 
    int same = mid - l + 1 ;
    //遍历区间[l,r] ,same减去区间中小于中位数的个数,之后same表示需要放入左子树的等于中位数的数字的个数
    for( int i = l  ; i <= r ; i ++)
         if( tree[dep][ i ] < sorted[mid])
            same -- ;

    //左子树的起点是l 
    int lpos = l  ;
    //右子树的起点是mid + 1  
    int rpos = mid + 1 ;

    for( int i = l ; i<= r ;i++){
        //要相信lpos++ 和 rpos ++ 一定会正确的把[L,R] 区间的数分到对应的左右子树，并且不会有重复或者错误 
        //区间[L,R]内小于中位数的放入左子树 
        if( tree[dep][i] < sorted[mid])
            tree[dep+ 1] [lpos++] = tree[dep][i] ;
        //如果same>0代表等于中位数的树还可以放入左边，否则放入右边 
        else if( tree[dep][i] == sorted[mid] && same > 0 ) 
            tree[dep + 1][lpos++] = tree[dep][i] , same -- ;
        //放入右子树的数 
        else
            tree[dep + 1][rpos++] = tree[dep][i] ;
        //下面计算 区间[L,i]的放入左子树的数字个数 ， 你会发现区间[L,R] 的toleft[dep]序列的数字不递减的，并且最大的数就是左子树的元素个数 
        toleft[dep][i] = toleft[dep][l-1] + lpos - l ;  
    }
    //左子树 
    build( l , mid , dep + 1) ;
    //右子树 
    build( mid + 1 , r , dep + 1) ; 

} 

int query( int L , int R , int l , int r , int dep , int k ){
    //就像线段树一样，叶节点是[l,r] , l == r 的点区间，就是一个点，他的取值从tree获得 
    if( l == r) return tree[dep][l] ;

    int mid = ( L + R ) >> 1 ;
    //cnt求区间[l , r ] 里面放到[L, R] 左子树的数字的个数 ， 注意是左右都闭的闭区间 
    int cnt = toleft[ dep][r] - toleft [dep][l-1] ;

    //如果cnt>= k 代表区间[l,r] 的第k大是被和[l,r]区间的其他被放到左子区间的数一样放到了左子区间，那我们就要遍历[L,R}的左子区间 
    if( cnt >= k ){
        //注： 无特殊说明， 左子区间和右子区间都是指大区间的左子区间和右子区间 
        //区间[l,r]的第k大被放到了大区间[L,R] 的左子区间，但是想想被放到了哪里呢？注意区间[l,r] 的被放到左子区间的书是连在一起的，并且第一个被放到左子区间的数的下标不一定是l啊 
        //如果我们知道了第一个被放到左子区间的数的下标newl，那么通过 newl+cnt-1 我们就可以求得最后一个被放入左子区间的数的下标，那么就求出了被放入左子区间的数的区间范围[newl , newr]
        //因为cnt >= k ， 所以区间[l , r] 的第k大也是新区间[newl , newr] 的第k大 

        //toleft[dep][l-1] - toleft [dep][L-1] ; 表示[L , l ] 区间被放入左子区间的个数，那么加上L就是新区间的左边界 
        int newl = L + toleft[dep][l-1] - toleft [dep][L-1] ;
        //右边界，公式是显然的，想想就知道了 
        int newr = newl + cnt -1 ;

        return query( L , mid , newl , newr , dep + 1 , k ) ;
    } 
    else{
        //如果k<cnt ，代表区间[l,r] 的第k大不再被放入左子区间的数里面，那么就只能是放入右子区间了
        //那么和上一个一样，我们要确定这个被放入右子区间的数的第一个和最后一个的下标，从而做成新区间[newl , newr]
        //同时，还要求第k大在新的区间里是第几大，答案是 k - cnt 大，这里就要理解划分树在将区间划分后，左子区间的数一定小于右子区间的数，无一例外

        //toleft[dep][R] - toleft[dep][r]  代表[r,R]区间被放入左子区间的数字个数
        //为什么newr = r +  toleft[dep][R] - toleft[dep][r]
        //可以这样想， 在将[L , r] 的数划分成左子区间和右子区间的过程中， left1表示[L , r]里面被放入左子区间的个数、放入右子区间的个数是right ， [r+1 , R] 里面被放入左子区间的个数是Left2
        //我们要明白[L,r]里面最后被放入右子区间的那个数的下标是最大的，也是我们要求的区间[l,r] 最后被放入右子区间的那个数的下标
        //这个下标是Left1 + Left2 + right = left1 + right +Left2 = r + left2 =   r + toleft[dep][R] - toleft[dep][r] 
        int newr = r + toleft[dep][R] - toleft[dep][r] ;
        //( r - l +1 - cnt ) 表示被放入右子区间的数字的个数 
        int newl = newr - ( r - l +1 - cnt ) + 1 ; 

        return query( mid + 1 , R , newl , newr , dep + 1 , k - cnt) ; 
    }
} 


int main(){
    int n , m , T ;
    scanf("%d" , & T) ;
    while( T --){
        scanf("%d%d" , & n , & m) ;
        memset( tree , 0 , sizeof( tree)) ;
        for(int i = 1 ; i <= n ; i ++){
            scanf("%d" , & tree[0][i]) ;
            sorted [ i] = tree[0][i] ;
        }

        sort( sorted + 1 , sorted + n + 1) ;
        build( 1 , n , 0) ;

        int l , r , k ;
        while( m --){
            scanf("%d%d%d" , & l , & r , & k ) ;
            printf("%d\n" , query ( 1 , n , l , r , 0 , k ) ) ;
        }
    }
    return 0 ;
}