poj2104||hdu2665 归并树|划分树

这题是一道经典的一题多解，很多姿势都可以实现

题目大意：就是q个询问，问给定区间内的第k小数是多少，允许重复

姿势1：归并树

姿势2：划分树

这是一个很神奇的东西，网上很多都人云亦云，讲不清楚

划分树其实是一个类似快排的思想，每次以区间的中位数为界，将区间划分成2个小块,左右块的数字还是保持原有的顺序

对比归并排序可以看到划分树把数字严格的划分开来，如果说归并树是自底朝上的排序的话，划分树就是自上而下的排序

对下面的数组a,以及将a排序后的b,红色部分是每次要划分到左子树的部分:

b:              [1 2 3 4 5 6 7]

a:              [1 5 2 6 4 7 3]

          [1 2 4 3]            [5 6 7]

    [1 2]      [4 3]      [5 6]     [7]

  [1]   [2]   [3]  [4]   [5]  [6]

那么下面有2个问题：1.怎么建树 2.怎么查询

传统的建树实现比较复杂，那么我们换个思路，对于每一层建树，每一层维护两个数组

lsum:表示从区间的l位置到下标i有多少被安排到了左子树

t:表示这一层数字的排列情况

每一层的中位数到b里面可以找到，这里还要注意考虑重复数字的情况

那么查询的时候对于区间[l,r]的第k小数的时候,

令y=lsum[i][l-1],当l是当前区间的左边界的时候,y=0(否则右子树左边界就会错)

维护第i层该区间被分配到左子树的数字个数cnt=lsum[i][r]-y

如果cnt>=k,递归到左子树，访问的区间调整到[l+y,l+lsum[i][r]+1]找第k小,层数i+1

如果cnt<k  ,递归到右子树，访问的区间调整到[mid+1+l-a[k].l-y,mid+1+r-a[k].l-lsum[i][r]]找k-cnt小的,层数i+1

可以看到划分树每次做查询的时候数字都减半了，而且区间可以进行重定位

所以划分树的时空复杂度均为O(nlogn）,很好很强大

但是如果要支持修改，划分树貌似就跪了

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <map>
#define maxn 100010
using namespace std;
int n,m;
int s[maxn];
struct tree{
    int l,r;
}a[maxn*3];
int lsum[20][maxn],t[20][maxn];
void build(int l,int r,int k,int dep){
    a[k].l=l,a[k].r=r;
    if(l==r) return;
    int mid=(l+r)>>1;
    int low=0;
    for(int i=l;i<=r;i++){
        if(t[dep][i]<s[mid]) low++;
    }
    //cout<<l<<" "<<r<<endl;
    int lp=l,rp=mid+1,x;
    for(int i=l;i<=r;i++){
        x=t[dep][i];
        if(x<s[mid]) t[dep+1][lp++]=x;
        else if(x>s[mid]) t[dep+1][rp++]=x;
        else{
            if(low<mid-l+1) t[dep+1][lp++]=x,low++;
            else t[dep+1][rp++]=x;
        }
        //cout<<dep<<" "<<i<<" "<<lp-l<<endl;
        lsum[dep][i]=lp-l;
    }
    build(l,mid,k<<1,dep+1);
    build(mid+1,r,k<<1|1,dep+1);
}
int query(int l,int r,int z,int k,int dep){
    //cout<<l<<" "<<r<<" "<<z<<" "<<dep<<" "<<a[k].l<<" "<<a[k].r<<endl;
    if(a[k].l==a[k].r) return t[dep][l];
    int mid=(a[k].l+a[k].r)>>1,y;
    if(l==a[k].l) y=0;
    else y=lsum[dep][l-1];
    int tmp=lsum[dep][r]-y;
    //cout<<tmp<<endl;
    if(tmp>=z) return query(a[k].l+y,a[k].l+lsum[dep][r]-1,z,k<<1,dep+1);
    else return query(mid+1+l-a[k].l-y,mid+r-a[k].l+1-lsum[dep][r],z-tmp,k<<1|1,dep+1);
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        for(int i=1;i<=n;i++)scanf("%d",&t[1][i]),s[i]=t[1][i];
        sort(s+1,s+1+n);
        build(1,n,1,1);
        int l,r,k;
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&l,&r,&k);
            printf("%d\n",query(l,r,k,1,1));
        }
    }
    return 0;
}