划分树

        对于区间第k大值，除了我们之前介绍的归并树之外。现在要登场的数据结构将比归并树的效率更高，他就是划分树。我们学习归并树的时候了解到：归并树 = 线段树 + 归并排序。那么我们今天要介绍的划分树就是：线段树 + 快排。要说有什么不同的，那就是归并树是从有序到无序，而划分树是从无序到有序。

1、划分树的定义

        给定一序列a[1...n]，sorted[1...n]为序列从小到大的排列结果。对于划分树的每一个节点(叶子节点除外)，其保存的区间[left, right]中小于等于sorted[(left+right)/2]的进入该结点的左子树，否则进入该节点的右子树。如图所示：

        

从划分树的定义来看，我们不难发现我们使用层状的储存较为方便于是我们，定义划分树的储存结构如下：

const int MAXN = 100001;
const int DEEP = 18;
//DEEP = ceil(log2(MAXN))+1
//ceil是天花板函数,ceil(x)的取值为大于等于x的最小整数
using namespace std;
typedef struct{
    int num[MAXN];  //num记录第k层当前位置的元素的值
    int cnt[MAXN]; //cnt记录元素所在区间的当前位置之前进入左孩子的个数
}PartitionTree;
PartitionTree tree[DEEP];
int sorted[MAXN];   //对原来集合中的元素排序后的值。

2、建树

        我们知道只要小于等于当前结点的区间中值的数字就进入左子树，否则进入右子树。为了方便我们的查询我们增加一个数组cnt[1...n]用来记录元素所在区间的当前位置之前进入左孩子的个数。根据这些信息我们可以写出建树的代码，如下：

void build(int deep, int lft, int rht){
    if(lft == rht) return ;
    int mid = (lft + rht) >> 1;
    int scnt = mid - lft + 1;
    //为了使划分树的每一节点的元素等于区间长度
    //我们对于相等的数，就不能全部放到左子树
    //只能放一部分给左子树
    //下面是计算能够放几个与sorted[mid]相等的数到左子树
    for(int i = lft; i <= rht; i++){
        if(tree[deep].num[i] < sorted[mid]) scnt--;
    }
    int p = lft, r = mid + 1;
    for(int i = lft, cnt_in_left = 0; i <= rht; i++){
        int num = tree[deep].num[i];
        //如果小于sorted[mid]或者相等且scnt!=0，那么则放入左子树
        if(num < sorted[mid] || (num == sorted[mid] && scnt)){
            if(num == sorted[mid]) scnt--;
            cnt++;
            tree[deep+1].num[p++] = num;
        }//否则进入右子树
        else tree[deep+1].num[r++] = num;
        //记录元素所在区间的当前位置之前进入左孩子的个数
        tree[deep].cnt[i] = cnt_in_left;
    }
    //递归建树
    build(deep+1, lft, mid);
    build(deep+1, mid+1, rht);
}

3、查询

划分树的查询只要想明白了，他就很简单。我们在文章前面已经明白了，划分树的定义以及是如何建树的。划分树的查询就是基于我们建树时保存的信息，就是那个cnt数组。如果我们要查找区间[qlft, qrht]内的第k大数，这里就可以小小的是有下cnt数组了。如果tree[deep].cnt[qrht] - tree[deep].cnt[qlft-1] >= K。区间[qlft, qrht]内有超过k个值进入左子树，我们不难发现我们的目标值，已经进入了左子树。反之如果tree[deep].cnt[qrht] - tree[deep].cnt[qlft-1]  < K，那么我们的目标值则进入了右子树。于是我们顺藤摸瓜就能找到目标值了，如：

那么，现在对于查询我们还有一个问题要解决，那就是更新查询的区间。什么意思呢，就是原先我们查找的是[4,7]这个区间内的第k大数，那么当我们进入右子树之后，已经不存在[4,7]这个区间了，既然区间都没有了，那么自然k也就变了。经过一番思考，我们可以得到查询代码如下：

//deep为树的深度，[lft, rht]为节点对应的区间
//查询区间[qlft, qrht]中的第k大值
int query(int deep, int lft, int rht, int qlft, int qrht, int k){
    //但区间仅剩下一个点了，显然我们已经找到答案了
    if(lft == rht) return tree[deep].num[lft];
    int mid = (lft + rht) >> 1;
    //left表示区间[lft, qlft-1]中进入左子树中的元素个数
    //sum_in_left表示区间[qlft, qrht]进入左子树的元素个数
    //当查询区间的左边界qlft等于结点区间的左边界lft时,
    //left = 0, sum_in_left = tree[deep].cnt[qrht]
    int left = 0, sum_in_left = tree[deep].cnt[qrht];
    //当他们不重叠的时候
    //那么left=tree[deep].cnt[qlft-1],sum_in_left=tree[deep].cnt[qrht]-tree[deep].cnt[qlft-1]
    //至于为什么要分情况讨论，就留给读者慢慢思考了
    if(qlft != lft){
        left = tree[deep].cnt[qlft-1];
        sum_in_left -= left;
    }
    //目标值在左子树
    if(sum_in_left >= k){
        int new_qlft = lft + left;
        int new_qrht = new_qlft + sum_in_left - 1;
        return query(deep+1, lft, mid, new_qlft, new_qrht, k);
    }
    //目标值在右子树
    else{
        int a = qlft - lft - left;
        int b = qrht - qlft - sum_in_left;
        int new_qlft = mid + 1 + a;
        int new_qrht = new_qlft + b;
        return query(deep+1, mid+1, rht, new_qlft, new_qrht, k-sum_in_left);
    }
}

3、复杂度

很容易得出时间复杂度为总的时间复杂度为O(n log n)。每一次查询的时间复杂度为O(logn)。空间复杂度为O(n*logn)。显然划分树的时间复杂度要优于归并树。

4、实战演练

pku2104 K-th Number 
hdu 2665 Kth number 
前两个是基础，后一个是上面所得带sum域的加强版。 
hdu 3743 Minium_Number 

附上pku2104的代码：

#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 100000 + 1;
const int DEEP = 18;
typedef struct{
    int num[MAXN];
    int cnt[MAXN];
}PartitionTree;
PartitionTree tree[DEEP];
int sorted[MAXN];

void build(int deep, int lft, int rht){
    if(lft == rht) return ;
    int mid = (lft + rht) >> 1;
    int key = sorted[mid];
    int scnt = mid - lft + 1;
    for(int i = lft; i <= rht; ++i){
        if(tree[deep].num[i] < key) --scnt;
    }
    int p = lft-1, r = mid;
    for(int i = lft, cnt = 0; i <= rht; ++i){
        int num = tree[deep].num[i];
        if(num < key || (num == key && scnt)){
            if(num == key) --scnt;
            ++cnt;
            tree[deep+1].num[++p] = num;
        }
        else tree[deep+1].num[++r] = num;
        tree[deep].cnt[i] = cnt;
    }
    build(deep+1, lft, mid);
    build(deep+1, mid+1, rht);
}

int query(int deep, int lft, int rht, int qlft, int qrht, int k){
    if(lft == rht) return tree[deep].num[lft];
    int mid = (lft + rht) >> 1;
    int left = 0, sum_in_left = tree[deep].cnt[qrht];
    if(lft != qlft){
        left = tree[deep].cnt[qlft-1];
        sum_in_left -= left;
    }
    if(sum_in_left >= k){
        int new_qlft = lft + left;
        int new_qrht = new_qlft + sum_in_left - 1;
        return query(deep+1, lft, mid, new_qlft, new_qrht, k);
    }
    else{
        int a = qlft - lft - left;
        int b = qrht - qlft - sum_in_left;
        int new_qlft = mid + 1 + a;
        int new_qrht = new_qlft + b;
        return query(deep+1, mid+1, rht, new_qlft, new_qrht, k-sum_in_left);
    }
}

int main(){
    int n, m, qlft, qrht, k;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++){
        scanf("%d", &sorted[i]);
        tree[0].num[i] = sorted[i];
    }
    sort(sorted+1, sorted+1+n);
    build(0, 1, n);
    while(m--){
        scanf("%d%d%d", &qlft, &qrht, &k);
        printf("%d\n", query(0, 1, n, qlft, qrht, k));
    }
    return 0;
}