划分树的用法(一):查询区间第K大值值(poj2104)

    可能是我太笨的原因,一个简单的划分树竟然用了三四天才慢慢能把最基础的用法领悟到。其实也挺好的,用时间去拼聪明人的智力,只要能领悟到,我们的收获是相同的!

    好了,言归正传!划分树是线段树的深化,其本质还是线段树。划分树可以解决这样的问题(我现在也只读懂了怎么解决这一个问题):查询序列中动态区间的第k大值。比如:POJ2104(http://poj.org/problem?id=2104)。

    我看了好多的博客和代码才慢慢明白怎么用划分树解决这一道题。如果还不懂线段树的孩子,建议先把线段树的基础用法领悟到了再看这篇博客。

     用划分树来解决选定区间内的第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]<sorted[mid])

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

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

   第五:划分的过程,需要把每层的数据记录:toLeft[20][M]。toLeft[i][j]定义为:第i层[1,j]之间有多个数据被分到了左边(注意这里用的是闭区间)。

   我能理解到建树的过程,就这么多了!

 

  
  
  
  
  1. void build(int level,int left,int right){ 
  2.     if(left==right)return ; 
  3.     int mid=(left+right)>>1; 
  4.     int i; 
  5.     int suppose;//假设在中位数sorted[mid]左边的数都全部小于sorted[mid] 
  6.     suppose=mid-left+1; 
  7.     for(i=left;i<=right;i++){ 
  8.         if(tree[level][i]<sorted[mid]){ 
  9.             suppose--; 
  10.         } 
  11.     } 
  12.     //如果suppose==1,则说明数组中值为sorted[mid]只有一个数。比如序列:1 3 4 5 6,sorted[mid]=4 
  13.     /*如果suppose>1,则说明数组中左半边值为sorted[mid]的不止一个数,为mid-suppose。比如序列:1 4 4 4 6,sorted[mid]=4 
  14.      * 
  15.      * */ 
  16.     int lpos=left,rpos=mid+1; 
  17.     for(i=left;i<=right;i++){ 
  18.         if(i==left){//这里是预处理,相当与初始化 
  19.             toLeft[level][i]=0; 
  20.         }else
  21.             toLeft[level][i]=toLeft[level][i-1]; 
  22.         } 
  23.         if(tree[level][i]<sorted[mid]){//划分到中位数左边 
  24.             toLeft[level][i]++; 
  25.             tree[level+1][lpos++]=tree[level][i]; 
  26.         }else if(tree[level][i]>sorted[mid]){//划分到中位数右边 
  27.             tree[level+1][rpos++]=tree[level][i]; 
  28.         }else{//这里,suppose大于0的数划分到中位数的左边 
  29.             if(suppose!=0){//这里的处理太巧妙了!帅气! 
  30.                 suppose--; 
  31.                 toLeft[level][i]++; 
  32.                 tree[level+1][lpos++]=tree[level][i]; 
  33.             }else{//表示 
  34.                 tree[level+1][rpos++]=tree[level][i]; 
  35.             } 
  36.         } 
  37.     } 
  38.     build(level+1,left,mid); 
  39.     build(level+1,mid+1,right); 

下面是查询的过程:

    建树建立好了,查询也是需要费一定的时间来理解的!

    查询最重要的有4个元素,

int s;//代表[left,qleft)之间被划分到左子树的元素数目

int ss;//代表[qleft, qright]内将被划分到左子树的元素数目

int newl;//代表新确定查询的区间左边界

int newr; //代表新确定查询区间的右边界

    很显然(一般老师说这三个字,接下来的内容都不怎么容易理解):如果K值大于ss,我们该查询划分树当前序列的右区间,否则,查询划分树当前序列的左区间。

查询最难理解的是newl,newr的确定,这里我暂时也没完全弄明白,只理解到这里了,把所有的代码贴上来吧!有时间再好好研究!

 

  
  
  
  
  1. #include<stdio.h> 
  2. #include<algorithm> 
  3. using namespace std; 
  4. #define M 100005 
  5. int tree[20][M],sorted[M]; 
  6. int toLeft[20][M]; 
  7. void build(int level,int left,int right){ 
  8.     if(left==right)return ; 
  9.     int mid=(left+right)>>1; 
  10.     int i; 
  11.     int suppose;//假设在中位数sorted[mid]左边的数都全部小于sorted[mid] 
  12.     suppose=mid-left+1; 
  13.     for(i=left;i<=right;i++){ 
  14.         if(tree[level][i]<sorted[mid]){ 
  15.             suppose--; 
  16.         } 
  17.     } 
  18.     //如果suppose==1,则说明数组中值为sorted[mid]只有一个数。比如序列:1 3 4 5 6,sorted[mid]=4 
  19.     /*如果suppose>1,则说明数组中左半边值为sorted[mid]的不止一个数,为mid-suppose。比如序列:1 4 4 4 6,sorted[mid]=4 
  20.      * 
  21.      * */ 
  22.     int lpos=left,rpos=mid+1; 
  23.     for(i=left;i<=right;i++){ 
  24.         if(i==left){//这里是预处理,相当与初始化 
  25.             toLeft[level][i]=0; 
  26.         }else
  27.             toLeft[level][i]=toLeft[level][i-1]; 
  28.         } 
  29.         if(tree[level][i]<sorted[mid]){//划分到中位数左边 
  30.             toLeft[level][i]++; 
  31.             tree[level+1][lpos++]=tree[level][i]; 
  32.         }else if(tree[level][i]>sorted[mid]){//划分到中位数右边 
  33.             tree[level+1][rpos++]=tree[level][i]; 
  34.         }else{//这里,suppose大于0的数划分到中位数的左边 
  35.             if(suppose!=0){//这里的处理太巧妙了!帅气! 
  36.                 suppose--; 
  37.                 toLeft[level][i]++; 
  38.                 tree[level+1][lpos++]=tree[level][i]; 
  39.             }else{//表示 
  40.                 tree[level+1][rpos++]=tree[level][i]; 
  41.             } 
  42.         } 
  43.     } 
  44.     build(level+1,left,mid); 
  45.     build(level+1,mid+1,right); 
  46. //在[left,right]数据中查询[qleft,qright]中第k大的数据 
  47. int query(int level,int left,int right,int qleft,int qright,int k){ 
  48.     if( qleft==qright) 
  49.         return tree[level][qleft]; 
  50.     int s;//代表[left,qleft)之间有多个个元素被分到左边 
  51.     int ss;//[qleft, qright]内将被划分到左子树的元素数目 
  52.     int mid=(left+right)>>1; 
  53.     if(left==qleft){ 
  54.         s=0; 
  55.         ss=toLeft[level][qright]; 
  56.     }else
  57.         s=toLeft[level][qleft-1]; 
  58.         ss=toLeft[level][qright]-s; 
  59.     } 
  60.     int newl,newr; 
  61.     if(k<=ss){//查询左边 
  62.         newl=left+s; 
  63.         newr=left+s+ss-1; 
  64.         return query(level+1,left,mid,newl,newr,k); 
  65.     }else{//查询右边 
  66.         newl=mid-left+1+qleft-s; 
  67.         newr=mid-left+1+qright-s-ss; 
  68.         return query(level+1,mid+1,right,newl, newr,k - ss); 
  69.     } 
  70. int main(){ 
  71.     int n,m; 
  72.     while
  73.             scanf("%d %d",&n,&m)!=EOF 
  74. //  ; 
  75.     ){ 
  76.     int i; 
  77.     for(i=1;i<=n;i++){ 
  78.         scanf("%d",&tree[0][i]); 
  79.         sorted[i]=tree[0][i]; 
  80.     } 
  81.     sort(sorted+1,sorted+n+1); 
  82.     build(0,1,n); 
  83.     for(i=0;i<n;i++){ 
  84.         for(int j=1;j<=n;j++){ 
  85.             printf("%d ",toLeft[i][j]); 
  86.         } 
  87.         printf("\n"); 
  88.     } 
  89.     int ql,qr,k; 
  90.     for(i=0;i<m;i++){ 
  91.         scanf("%d %d %d",&ql,&qr,&k); 
  92.         printf("%d\n",query(0,1,n,ql,qr,k)); 
  93.     } 
  94.     } 
  95.     return 0; 

参考博客:

    http://www.notonlysuccess.com/index.php/divide-tree/#more-142

    http://blog.csdn.net/fp_hzq/article/details/7993364

    http://www.cnblogs.com/pony1993/archive/2012/07/17/2594544.html

本文出自 “每天进步一点点” 博客,请务必保留此出处http://sbp810050504.blog.51cto.com/2799422/1008930

你可能感兴趣的:(划分树,动态区间求Kth值,poj2104)