hdu 2665Kth-number 划分树

函数式线段树也叫可持久化线段树，也叫主席树~

第一道划分树题AC~~~~~可持久化数据结构(Persistent data structure)就是利用函数式编程的思想使其支持询问历史版本、

同时充分利用它们之间的共同数据来减少时间和空间消耗。
因此可持久化线段树也叫函数式线段树又叫主席树。。。

附上代码：

#include <iostream>
#include <cmath>
#include <stdio.h>
#include <string.h>
#include <string>
#include <algorithm>
const int maxn=100001;
using namespace std;
struct node
{ 
 int ls,rs; //左右区间
 int cnt;   //记录该区间的插入值的个数
}tr[maxn*20];//数组开的得足够大  
int cur,rt[maxn];//rt[]存的是n个不同的历史版本，每插入一个就会更新一次历史版本
void init()
{
 cur=0;
}
inline void push_up(int o)  //回溯获取cnt
{
  tr[o].cnt=tr[tr[o].ls].cnt+tr[tr[o].rs].cnt;
}
int build(int l,int r) //建树返回根节点的下标
{
 int k=cur++;
 if(l==r)
 {
   tr[k].cnt=0;
   return k;
 }
 int mid=(r+l)>>1;
 tr[k].ls=build(l,mid);
 tr[k].rs=build(mid+1,r);
 push_up(k);
 return k;
}
int updata(int o,int l,int r,int pos,int val) //更新，注意每次更新不改变原来的版本，只是在原来的基础上复制
{
  int k=cur++;
  tr[k]=tr[o];
  if(l==pos&&r==pos)
  {
    tr[k].cnt+=val;
    return k;
  }
  int mid=(r+l)>>1;
  if(pos<=mid)tr[k].ls=updata(tr[o].ls,l,mid,pos,val);
  else tr[k].rs=updata(tr[o].rs,mid+1,r,pos,val);
  push_up(k);
  return k;
}
int query(int l,int r,int o,int v,int kth)
{
  if(l==r)return l;
  int mid=(l+r)>>1;
  int res=tr[tr[v].ls].cnt-tr[tr[o].ls].cnt;
  if(kth<=res)return query(l,mid,tr[o].ls,tr[v].ls,kth);
  else return query(mid+1,r,tr[o].rs,tr[v].rs,kth-res);
}
int b[maxn];  //存给定的数
int sortb[maxn];//将给的数从小到大排序
int main()
{
 int T,n,m;
 cin>>T;
 while(T--)
 {
  init();
  scanf("%d%d",&n,&m);
  for(int i=1;i<=n;i++)
  {
    scanf("%d",&b[i]);
    sortb[i]=b[i];
  }
  sort(sortb+1,sortb+1+n);
  int cnt=1;
  for(int i=2;i<=n;i++) //因为可能有重复的数，所以得去重
  {
    if(sortb[i]!=sortb[cnt])sortb[++cnt]=sortb[i];
  }
  rt[0]=build(1,cnt);//最初始的版本
  for(int i=1;i<=n;i++)
  {
    int p=lower_bound(sortb+1,sortb+1+cnt,b[i])-sortb;//low_bound（）函数是表示b[i]在sortb[]数组中排第几位
    rt[i]=updata(rt[i-1],1,cnt,p,1);
  }
  for(int i=0;i<m;i++)
  {
    int a,b,k;
    scanf("%d%d%d",&a,&b,&k);
    int idx=query(1,cnt,rt[a-1],rt[b],k);
    printf("%d\n",sortb[idx]);
  }
 }
 return 0;
}

2014-8-11

今天又看懂了划分树的另一种表示（树的隐式表示法）

<pre name="code" class="cpp">#include<iostream>
#include<algorithm>
#include <string.h>
#include <stdio.h>
int MIN(int a,int b){ if( a<b )  return a;  else return b; }
int MAX(int a,int b){ if( a>b )  return a;  else return b; }
#define CLR(NAME,VALUE) memset(NAME,VALUE,sizeof(NAME))
using namespace std;
const int N=100000+10;
const int DEEP=20;
struct NODE
{
 int l,r;
}tr[N*4];
int data[N];
int seg[DEEP][N];
int lessMid[DEEP][N];
void Build(int l,int r,int root,int d)
{
 tr[root].l=l;
 tr[root].r=r;
 if( l==r )return;
 int i,mid=(l+r)>>1;
 int lsame=mid-l+1;   //这个变量表示左边最多可放几个与DATA[MID]相同的数
 for(i=l;i<=r;++i)
 {  //得出实际能放几个相同的数
  if( seg[d][i]<data[mid] )
  {
   --lsame;
  }
 }
 int tl=l,tr=mid+1,same=0;
 for(i=l;i<=r;++i)
 {
  if( i==l )
  {
   lessMid[d][i]=0;  //表示在[L，R]内有几个数小于等于DATA[MID]
  }
  else
  {
    lessMid[d][i]=lessMid[d][i-1];
  }
  if( seg[d][i]<data[mid] )
  {
   ++lessMid[d][i];
   seg[d+1][tl++]=seg[d][i];
  }
  else if( seg[d][i]>data[mid] )
  {
   seg[d+1][tr++]=seg[d][i];
  }
  else
  {
   if( same<lsame )
   {
    ++same;
    ++lessMid[d][i];
    seg[d+1][tl++]=seg[d][i];
   }
   else
   {
    seg[d+1][tr++]=seg[d][i];
   }
  }
 }
 Build(l,mid,root*2,d+1);
 Build(mid+1,r,root*2+1,d+1);
}

int Query(int l,int r,int root,int d,int cnt)
{
  if( l==r )
   return seg[d][l];
 int s;   //表示在[L，R]内有几个小于等于DATA[MID]的个数
 int ss;  //表示在[tr[root].l,l-1]内有几个小于等于DATA[MID]的个数
 if( l==tr[root].l )
 {
  s=lessMid[d][r];
  ss=0;
 }
 else
 {
  s=lessMid[d][r]-lessMid[d][l-1];
  ss=lessMid[d][l-1];
 }
 if( s>=cnt )
 {
  return Query(tr[root].l+ss,tr[root].l+ss+s-1,root*2,d+1,cnt);
 }
 else
 {
  int mid=(tr[root].l+tr[root].r)>>1;
  int bb=l-tr[root].l-ss;  //表示 [tr[root].l , l-1 ]有多少个分到右边
  int b=r-l+1-s;           //表示 [l , r]有多少个分到右边
  return Query(mid+bb+1,mid+bb+b,2*root+1,d+1,cnt-s);
 }
}

int main() 
{
  int n,m,l,r,cnt,i;
  int t;
  cin>>t;
  while( t-- )
  {
   cin>>n>>m;
   for(i=1;i<=n;++i)
   {
    scanf("%d",data+i);
    seg[1][i]=data[i];
   }
   sort(data+1,data+n+1);
   Build(1,n,1,1);
   while( m-- )
   {
    scanf("%d%d%d",&l,&r,&cnt);
    printf("%d\n",Query(l,r,1,1,cnt));
   }
  }

     return 0;
}