acm专题学习之数据结构（一）划分树+POJ 2104

划分树：

1 功能：查询区间第k大

2 复杂度：logn

3 思路：主要是两步，一个是建树，一个是查询。

4 建树：找到序列的中位数，把大于中位数的扔到中位数的左边，小于中位数的扔到数的右边。这样就被分成了两个字区间，然后在子区间再重复相同的步骤，直到没有数字。（递归的过程）

使用分层的二维数组tree[20][maxn]（一般十万级别的数字20层足够）。建树前需要重新排一次序，因为划分的标准是中位数（只需要排一次序，是因为中位数左边的数必定小于右边，可以看下面的图理解一下）。

注：出现了相同的数字怎么办？需要特殊处理，尽量使左右两边平均分配数（个数）。思路的话，每次递归还没分区的时候，用一个same变量记录和此前中位数相同的个数，先假设中位数中位数左边的数全部分到了左边same=mid-left+1，然后在遍历分区间的时候，遇到比中位数小的就是same--，遇到等于中位数的就分到左边且same--。（因为tree里面的序列是还没有排好序，如果只把小于等于中位数的进入到左子树，中位数重复个数的都放入，可能会导致左右子树两边的数量不等）

看看下图建树tree的变化来理解一下过程：（5,4,6,8,8,9,1,2序列）

5 查询：查询区间第k大。现初始的区间为[l,r]，现查询区间为[ql,qr]。每次递归查找需要找到，下一个小区间[newl,newr]还有下个一个对应小区间要查找的第k大的值，直到ql==qr。

首先我们要开一个数组toleft[20][MAXN]（toleft[p][i] 表示第 p 层从 1 到 i 有多少个数分入左子树 ），用来计算区间有多少个数进入左子树。

确定递归k：现初始区间[l,r]，查询区间[ql,qr]，计算[ql,qr]中有多少个数分入左子树（代表小于中位数）=toleft[dep][ql]-toleft[dep][qr-1]=k1（dep为层数），如果k1大于等于k，那么就是说明第k大的数在左子树；如果k1小于k，那么说明第k大的数在右子树，在右子树寻找的k=k-k1。

确定递归后的子区间（建议结合代码来理解）：如果是在左子树，求出查询区间第一个进入左子树的位置为新的左范围newl（现初始范围区间最左l+[l,ql]中进入左子树的）和最后一个进入的newr（newl+进入左子树的个数）。如果是右子树，求出查询区间第一个进入右子树的位置为新的右范围newr（qr+[qr,r]中进入左子树的）和最后一个进入的newl（newr+进入右子树的个数）。

6 代码：

int tree[20][maxn];//二维数组用来存树
int sorted[maxn];//排序后的数组
int toleft[20][maxn];//toleft[p][i] 表示第 p 层从 1 到 i 有多少个数分入左子树

void build(int l,int r,int dep)//建树dep是层数
{
    if(l==r)//如果遇到l==r就可以退出了
        return ;
    int mid=(l+r)>>1;
    int same=mid-l+1;
    for(int i=l;i<=r;i++)//如果中位数有重复的用来保证两边的数量相同
    {
        if(tree[dep][i]<sorted[mid])
        {
            same--;
        }
    }
    int ql=l;
    int qr=mid+1;
    for(int i=l;i<=r;i++)
    {
        if(tree[dep][i]<sorted[mid])//如果小于中位数去左子树
        {
            tree[dep+1][ql++]=tree[dep][i];
        }
        else if(tree[dep][i]==sorted[mid]&&same>0)//如果等于中位数且左子树要放入的中位数的数量还没有用完
        {
            tree[dep+1][ql++]=tree[dep][i];
            same--;
        }
        else//如果大于中位数，就直接进入右子树
        {
            tree[dep+1][qr++]=tree[dep][i];
        }
        toleft[dep][i]=toleft[dep][l-1]+ql-l;
    }
    build(l,mid,dep+1);//左子树
    build(mid+1,r,dep+1);//右子树
}
int query(int l,int r,int ql,int qr,int dep,int k)//查询
{
    if(l==r)
        return tree[dep][ql];
    int mid=(l+r)>>1;
    int cnt=toleft[dep][qr]-toleft[dep][ql-1];
    if(cnt>=k)//如果k小于进入左子树的，那么就说明这个数在左子树
    {
        int newl=l+toleft[dep][ql-1]-toleft[dep][l-1];//第一个进入左子树的数的序列位置
        int newr=newl+cnt-1;//新左边位置+进入左子树的个数
        return query(l,mid,newl,newr,dep+1,k);
    }
    else
    {
        int newr=qr+toleft[dep][r]-toleft[dep][qr];//右边位置+进入左子树的个数=最后一个进入右子树的数的序列位置
        int newl=newr-(qr-ql-cnt);//最后一个进入右子树的数的序列位置-（总个数-进入左子树的个数）=第一个进入右子树的数的序列位置
        return query(mid+1,r,newl,newr,dep+1,k-cnt);
    }
}

POJ 2104

题意：给你有n个数字的序列，m个询问，每个询问[a,b]区间的第k大的数字。

思路：裸的划分树

代码：

#include <algorithm>
#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace::std;
const int maxn=100005;
int tree[20][maxn];//二维数组用来存树
int sorted[maxn];//排序后的数组
int toleft[20][maxn];//toleft[p][i] 表示第 p 层从 1 到 i 有多少个数分入左子树

void build(int l,int r,int dep)//建树dep是层数
{
    if(l==r)//如果遇到l==r就可以退出了
        return ;
    int mid=(l+r)>>1;
    int same=mid-l+1;
    for(int i=l;i<=r;i++)//如果中位数有重复的用来保证两边的数量相同
    {
        if(tree[dep][i]<sorted[mid])
        {
            same--;
        }
    }
    int ql=l;
    int qr=mid+1;
    for(int i=l;i<=r;i++)
    {
        if(tree[dep][i]<sorted[mid])//如果小于中位数去左子树
        {
            tree[dep+1][ql++]=tree[dep][i];
        }
        else if(tree[dep][i]==sorted[mid]&&same>0)//如果等于中位数且左子树要放入的中位数的数量还没有用完
        {
            tree[dep+1][ql++]=tree[dep][i];
            same--;
        }
        else//如果大于中位数，就直接进入右子树
        {
            tree[dep+1][qr++]=tree[dep][i];
        }
        toleft[dep][i]=toleft[dep][l-1]+ql-l;
    }
    build(l,mid,dep+1);//左子树
    build(mid+1,r,dep+1);//右子树
}
int query(int l,int r,int ql,int qr,int dep,int k)
{
    if(l==r)
        return tree[dep][ql];
    int mid=(l+r)>>1;
    int cnt=toleft[dep][qr]-toleft[dep][ql-1];
    if(cnt>=k)//如果k小于进入左子树的，那么就说明这个数在左子树
    {
        int newl=l+toleft[dep][ql-1]-toleft[dep][l-1];//第一个进入左子树的数的序列位置
        int newr=newl+cnt-1;//新左边位置+进入左子树的个数
        return query(l,mid,newl,newr,dep+1,k);
    }
    else
    {
        int newr=qr+toleft[dep][r]-toleft[dep][qr];//左边位置-进入左子树的个数=最后一个进入右子树的数的序列位置
        int newl=newr-(qr-ql-cnt);//最后一个进入右子树的数的序列位置-（总个数-进入左子树的个数）=第一个进入右子树的数的序列位置
        return query(mid+1,r,newl,newr,dep+1,k-cnt);
    }
}
int main()
{
    int n,m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; ++i) 
    {
        scanf("%d", &sorted[i]);
        tree[0][i] = sorted[i];
    }
    sort(sorted + 1, sorted + n + 1);
    build(1, n, 0);
    while(m--) 
    {
        int l, r, k;
        scanf("%d%d%d", &l, &r, &k);
        printf("%d\n", query(1, n,l, r, 0,k));
    }
    return 0;
}