划分树学习笔记——NOJ[1458] Teemo，POJ2761——Feed the dogs

这两个题都是划分树的模板题，下面来介绍下划分树，由于本人也是初次入门，如果有不对的地方，还请各位指正。

划分树是一种基于线段树的数据结构。主要用于快速求出(在log(n)的时间复杂度内）序列区间的第k大值 。

如图即一棵划分树：

    

 

先来看下结构体：

struct node
{
	int val[maxn];
	int num[maxn];
}tree[30];

树形结构都有层次之分，我们假设根为第0层。

上面的val数组是用来记录当前层的元素的，而num数组则是用来存当前位置以前的被划到左子树的元素个数。

接下来讲下建树过程

    划分树建树基于一个已排完序的数组，将比中值大的元素划到右子树，比中值小的元素划到左子树，如果有多个和中值一样大的元素，那么用一个变量isame=(mid-l+1)，先假设用这么多个和中值一样大的，然后for循环一遍，踢掉比中值小的，最后的isame就是要划到左子树的。其实isame原理是这样的，本来左子树就应该有mid-l+1个元素，减去那些比中值小的(即本来就要划到左子树的)，那么此时isame就是左子树还需要的元素个数，那么就从中值元素中去isame个来放到左边，其他的放到右边。

具体看下面代码：

void build(int ind,int l,int r)
{
	if(l == r)//到叶子
	  return ;
    int mid=(l+r)>>1;
    int isame=mid-l+1,same=0;
    for(int i=l;i<=r;i++)
      if(sorted[mid] > tree[ind].val[i])
        isame--;//排除比中值小的
    int ln=l;//划分给下一层左子树的，开始位置
    int rn=mid+1;//划分给下一层右子树的，开始位置
    for(int i=l;i<=r;i++)
    {
    	if(l == i)//第一个元素之前没有被划到左子树的,所以初始化为0
    	{
	    	tree[ind].num[i]=0;
	    }
	    else
	    {
    		tree[ind].num[i]=tree[ind].num[i-1];
    	}
    	if(tree[ind].val[i] > sorted[mid])//如果大于中值，划到右边
    	{
	    	tree[ind+1].val[rn++]=tree[ind].val[i];
	    }
	    else if(tree[ind].val[i] < sorted[mid])//小于中值，分给左边
	    {
    		tree[ind+1].val[ln++]=tree[ind].val[i];
    		tree[ind].num[i]++;
    	}
    	else//和中值一样大
    	{
	    	if(isame >same)//还要划到左边
	    	{
	    		same++;
	    		tree[ind+1].val[ln++]=tree[ind].val[i];
	    		tree[ind].num[i]++;
	    	}
	    	else//划给右边
	    	{
	    		tree[ind+1].val[rn++]=tree[ind].val[i];
	    	}
	    }
    }
    build(ind+1,l,mid);//递归左右子树
    build(ind+1,mid+1,r);
}

建树小结：

    小的给左边，大的给右边，一样的话，根据isame来决定多少个中值放左边，多少个放右边。还有就是记得维护num，这个数组在查询时起到很大的作用。

接着是查询

     一般是给定一个区间[a,b]，问你其中第k大的元素是什么，这是就要靠num数组了。我们假设此时子树的区间是[l,r] ,我们用一个s0变量保存区间[l,a-1]之间被划到左边的元素的个数，用s1保存区间[a,b]之间被划到左边的元素个数。那么递归左右子树的条件又是什么？这个容易，判断k和s1的大小，如果s1>=k，那么递归左子树，否则递归右子树(如果不懂的话，可以这么想，要查的区间里被划到左边的个数超过了k个，而左边的数大小一定小于等于右边的，所以第k大元素一定被包含在左子树，否则就在右子树)。递归子树的问题是解决了，那么新的查询区间怎么办呢？先来看递归左子树时的情况，这里就要用到s0，s1了，s0是区间 [l,a-1]里被划到左边的元素个数，那么他一定在左子树的最左边，而我们要查的第k大元素绝不可能是这s0个元素里的，换句话说，这s0个元素不是在区间[a,b]里的，但又被划到了左子树，所以，新的查询区间的左极限可以是l+s0，即第k大元素至少在区间向右移动s0个单位上。那么右边极限怎么办？ [a,b]里有s1个被划到左子树的，此时第k大元素定在这s1个元素中产生，所以右极限就是l+s0+s1-1。这之后的元素一定不要，所以区间就可以卡在这里。

if(s1 >= k)
    {
    	a=l+s0;
    	b=l+s0+s1-1;
    	return query(ind+1,l,mid,a,b,k);
    }

   再来看递归到右子树的情况，这个时候要注意递归查的不再是第k大了，而是第k-s1大元素，因为前s1大元素都在左子树了。同样也是递归区间的问题，还是要用到s0和s1，a-l-s0表示区间[l,a-1]里被划到右边的元素，b-a-1-s1表示区[a,b]里被划到右边的元素（减1是为了处理边界问题），右子树的开始位置是mid+1，同上，所以第k-s1大元素至少是从mid+1+a-l-s0开始的，至多在位置mid-l+1+b-s0-s1，至此，递归区间已分析完成。

else
    {
    	a=mid-l+1+a-s0;
    	b=mid-l+1+b-s0-s1;
    	return query(ind+1,mid+1,r,a,b,k-s1);
    }

下面的是POJ2761和NOJ1458的题解。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>

using namespace std;

const int maxn=100011;

int sorted[maxn];

struct node
{
	int val[maxn];
	int num[maxn];
}tree[30];

void build(int ind,int l,int r)
{
	if(l == r)
	  return ;
    int mid=(l+r)>>1;
    int isame=mid-l+1,same=0;
    for(int i=l;i<=r;i++)
      if(sorted[mid] > tree[ind].val[i])
        isame--;
    int ln=l;
    int rn=mid+1;
    for(int i=l;i<=r;i++)
    {
    	if(l == i)
    	{
	    	tree[ind].num[i]=0;
	    }
	    else
	    {
    		tree[ind].num[i]=tree[ind].num[i-1];
    	}
    	if(tree[ind].val[i] > sorted[mid])
    	{
	    	tree[ind+1].val[rn++]=tree[ind].val[i];
	    }
	    else if(tree[ind].val[i] < sorted[mid])
	    {
    		tree[ind+1].val[ln++]=tree[ind].val[i];
    		tree[ind].num[i]++;
    	}
    	else
    	{
	    	if(isame >same)
	    	{
	    		same++;
	    		tree[ind+1].val[ln++]=tree[ind].val[i];
	    		tree[ind].num[i]++;
	    	}
	    	else
	    	{
	    		tree[ind+1].val[rn++]=tree[ind].val[i];
	    	}
	    }
    }
    build(ind+1,l,mid);
    build(ind+1,mid+1,r);
}

int query(int ind,int l,int r,int a,int b,int k)//在区间[a,b]里找第k大，现在在区间[l,r] 
{
	if(a == b)
	  return tree[ind].val[a];
    int s0,s1,mid=(l+r)>>1;
    if(a == l)
    {
    	s0=0;
    	s1=tree[ind].num[b];
    }
    else
    {
    	s0=tree[ind].num[a-1];
    	s1=tree[ind].num[b]-s0;
    }
    if(s1 >= k)
    {
    	a=l+s0;
    	b=l+s0+s1-1;
    	return query(ind+1,l,mid,a,b,k);
    }
    else
    {
    	a=mid-l+1+a-s0;
    	b=mid-l+1+b-s0-s1;
    	return query(ind+1,mid+1,r,a,b,k-s1);
    }
}

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