划分树·详解·模板

用划分树来解决选定区间内的第K大值，其实也就两步！一步是建树，另一步则是查询。

     先说我对建树的理解吧！

    建树的过程很简单：两步就OK了！

   第一步：找到序列的中位数，把大于中位数的扔到中位数的左边，小于中位数的扔到数的右边。这样整个序列就被分成了两个区间。

   第二步：对每个子区间，也分别执行第一步操作，直到序列中只有一个元素为止。

   可以看出，建树是一个递归的过程，与线段树的建树有相似之处。

   划分树的建树需要注意以下几点：

     第一：建树是分层的，所以代码中用的是二维数组tree[20][M]。一般10W级别的数据，20层已经够了。

     第二：建树划分的标准是中位数，所以需要排序。而且只排一次序就OK了，为什么只排一次就OK了，我很久都没明白这一点。其实是这样的：对于任意序列： 划分后，左边的数据永远不会大于右边的数据。那么对左边数据单独排序与整体排序的结果是一样的，所以排一次序就OK了！

     第三：划分树划分好的数据永远在存放在下一层。比如数据：

tree[0][M]=1 5 2 6 3 7 4

排序后为：1 2 3 4 5 6 7

中位数为：4

划分后的结果为：tree[1][M]=1 2 3 4 5 6 7(这组数据有点特殊，划分后来就已经是排好序的了)红黑色字体都仍按原未排顺序排列

（红色表示划分到中位数的左边，黑色表示划分到中位数的右边）

接着划分：tree[2][M]=1 2 3 4 5 6 7

再接着分：tree[3][M]=1 2 3 4 5 6 0

到这里已经分完了，为什么最后是0呢？在第2层（tree[2][M]）,7已经分完了，所以不用再分

 第四：划分到最后，实际上已经对序列进行排序了。

     划分的时候还有一点需要处理：如果有多个数据相同怎么办呢？通过一种特殊的处理：尽量使左右两边平均分配相同的数。这个特殊处理是这样的：

    在没分之前，先假设中位数左边的数据suppose都已经分到左边了，所以suppose=mid-left+1;然后如果真的分在左边，即if(tree[level][i]

suppose--；suppose就减一！到最后，如果suppos=1，则说明中位数左边的数都小于中位数，如果有等于中位数的，则suppose大于1。

    最后分配的时候，把suppose个数，分到左边就可以了，剩下的分到右边！因为suppose的初值是mid-left+1,这样就能保证中位数左边和右边的数平衡了！

   第五：划分的过程，需要把每层的数据记录：toLeft[20][M]。toLeft[i][j]定义为：第i层,j属于区间[a,b],toLeft[i][j]:=有多少个数落于区间（a,j]

模板：

//注意：var[100][maxn],100是层数，一般100已经够用了
//此程序从deep从0开始，点：1-n

#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int MAXN=100010;
int num[MAXN];
int var[100][MAXN],toleft[100][MAXN];//var[i][j]:第i层的第j个数字，toleft[i][j]:第i层，j属于区间[a,b],有多少个数字落于区间(a,j]上
void build(int l,int r,int rt,int deep)//rt无所谓了
{
    if(l==r)return ;
    int m=l+r>>1;
    int midvar=num[m];//取中值
    int leftsame=m-l+1;//假设与中值相等的有m-l+1个
    for(int i=l;i<=r;i++)
        if(var[deep][i]midvar)
            var[deep+1][rpos++]=var[deep][i];//右孩子处
        else    //如果和midvar相等
        {
            if(leftsame>0)//位于左孩子
            {
                leftsame--;//!!!
                toleft[deep][i]++;//!!
                var[deep+1][lpos++]=var[deep][i];
            }
            else
                var[deep+1][rpos++]=var[deep][i];
        }
    }
    build(lson,deep+1);
    build(rson,deep+1);
}
int query(int l,int r,int rt,int deep,int L,int R,int k)//rt无所谓了
{
    if(L==R)return var[deep][L];
    int s;//代表[l,L]有多少元素被划到左边
    int ss;//代表[L,R]有多少元素被划到左边
    int m=l+r>>1;
    if(L==l)
    {
        s=0;
        ss=toleft[deep][R];
    }
    else
    {
        s=toleft[deep][L-1];
        ss=toleft[deep][R]-s;
    }
    int newl,newr;
    if(k<=ss)//查左边
    {
        newl=l+s;
        newr=l+s+ss-1;
        return query(lson,deep+1,newl,newr,k);
    }
    else//查右边
    {
        newl=m-l+1+L-s;
        newr=m-l+1+R-s-ss;
        return query(rson,deep+1,newl,newr,k-ss);
    }
}
void solve()
{
    for(int i=1;i<=n;i++)
    {
        cin>>num[i];
        var[0][i]=num[i];
    }
sort(num+1,num+1+n);//先排序再build()
build(1,n,1,0);
    query(1,n,1,0,a,b,c)//求解[a,b]，第c小
}