关于可持久化数据结构的简单理解~

动态开点线段树

在讨论可持久化线段树之前，我们先来讨论一下动态开点的线段树，当我们需要建多棵树存储状态而且最终需要的状态并不是完全的时候，为了避免MLE，我们就需要动态开点的线段树，为什么可以动态开点呢，因为我们知道，每次对于线段树的单点更新操作，之会影响到一条链上的节点信息，所以我们只要将这一条链上的与更新信息有关的子树信息进行更新，其他的直接继承之前的信息，这样每次最多更新log个节点，总空间复杂度最多nlogn
题目链接
http://acm.hdu.edu.cn/showproblem.php?pid=6183
题意
$给你一个二维平面，最开始平面上没有任何点，有4种操作，$
$第一种操作是0表示清除这个平面上所有的点$
$第二种操作是1xyc表示在(x,y)上添加一个颜色为c的点$
$第三种操作是2x{y}_1{y}_2查询(1,y1),(x,y2)之间有多少种颜色$
$第四种操作是3表示直接退出程序$
$下标范围10^6,最多有50种颜色$
$1，2操作最多1.5\ast 10^5次$
做法
$我们想想只有一种颜色怎么办，由于左界限已经固定$
$这就意味着我们可以对y建立权值线段树$
$更新操作只要保留每个y位置最小的x就可以$
$这样查询的时候只要看这个颜色在(y1,y2)这个区间的最小值是不是小于x$
$小于则代表这个颜色在这个范围内出现过$
$但是本题有50种颜色，这就意味着我们可以建50颗线段树分别计算$
$但是这个数据范围明显会MLE，这时候我们就需要动态开点的线段树$
$每次更新一条链上的信息，返回这个颜色对应的新的根节点下标$
$这样每次更新操作只会产生log个新节点，就没有MLE的问题$
$注意一定要先继承之前的信息，再更新本次更新的信息，保证之前的信息被继承下来。$
代码

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e6+10;
int tot,minn[maxn*4],lson[maxn*4],rson[maxn*4],root[55];
void init()
{
    tot=0;
    memset(minn,INF,sizeof(minn));
    memset(lson,0,sizeof(lson));
    memset(rson,0,sizeof(rson));
    memset(root,0,sizeof(root));
}
void update(int &now,int l,int r,int pos,int val)
{
    if(!now)
    {
        now=++tot;
        minn[now]=val;
    }
    if(l==r)
    {
        minn[now]=min(minn[now],val);
        return ;
    }
    int mid=(l+r)>>1;
    if(pos<=mid) update(lson[now],l,mid,pos,val);
    else update(rson[now],mid+1,r,pos,val);
    minn[now]=min(minn[lson[now]],minn[rson[now]]);
    return ;
}
int query(int now,int ql,int qr,int l,int r,int maxx)
{
    if(!now) return 0;
    if(ql<=l&&qr>=r)
    {
        if(minn[now]<=maxx) return 1;
        else return 0;
    }
    int mid=l+r>>1;
    int ans=0;
    if(ql<=mid) ans=query(lson[now],ql,qr,l,mid,maxx);
    if(ans>0) return 1;
    if(qr>mid) ans=query(rson[now],ql,qr,mid+1,r,maxx);
    if(ans>0) return 1;
    else return 0;
}
int main()
{
    int op,x,y,c,y1,y2;
    while(scanf("%d",&op)!=EOF)
    {
        if(op==0)
        {
            init();
        }
        else if(op==1)
        {
            scanf("%d%d%d",&x,&y,&c);
            update(root[c],1,1000000,y,x);
        }
        else if(op==2)
        {
            scanf("%d%d%d",&x,&y1,&y2);
            int ans=0;
            for(int i=0;i<=50;i++)
            {
                ans+=query(root[i],y1,y2,1,1000000,x);
            }
            printf("%d\n",ans);
        }
        else
        {
            break;
        }
    }
    return 0;
}

---

---

可持久化线段树

对于之前的动态开点线段树理解之后，可持久化线段树就非常好理解了，这就是一个权值线段树的前缀和操作，我们对每个原数组下标为新的根节点去更新权值线段树的信息时，就可以得到当前节点之前所表示的权值线段树的信息，再用前缀和的思想对某个区间内的权值线段树查询，就可以得到某个区间内的权值线段树的信息，也就是主席树。
题目链接
http://acm.hdu.edu.cn/showproblem.php?pid=2665
题意
$区间第k小$
做法
$如果给你某个完整序列的权值线段树信息$
$并求整个序列的第k小$
$我们就可以直接在权值线段树上进行查询$
$权值线段树每个节点存储当前区间点的个数和$
$每次访问一个节点，看这个节点的左子树的节点值是否大于等于k$
$若大于k则表示区间第k小一定在左子树$
$否则我们设左子树节点值为tmp,由于tmp<k,所以我们只要在右子树种查询区间第(k-tmp)小就可以了$
代码

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int maxn = 1e5+3;
int lson[maxn*20],rson[maxn*20],tot,sum[maxn*20],root[maxn];
int a[maxn],Hash[maxn],b[maxn];
void update(int &now,int pre,int l,int r,int pos)
{
    now=++tot;
    sum[now]=sum[pre]+1;
    lson[now]=lson[pre];
    rson[now]=rson[pre];
    if(l==r)    return ;
    int mid=l+r>>1;
    if(pos<=mid) update(lson[now],lson[pre],l,mid,pos);
    else update(rson[now],rson[pre],mid+1,r,pos);
}
int query(int st,int en,int l,int r,int k)
{
    if(l==r) return l;
    int tmp=sum[lson[en]]-sum[lson[st]];
    int mid=l+r>>1;
    if(tmp>=k) return query(lson[st],lson[en],l,mid,k);
    else return query(rson[st],rson[en],mid+1,r,k-tmp);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,q,x,y,k;
        tot=0;//0为根的树所有信息一直是0，每次得到第一棵树的信息都是从第0颗树传递，所以只重置tot即可，其他都不需要重置
        scanf("%d%d",&n,&q);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            Hash[i]=a[i];
        }
        sort(Hash+1,Hash+1+n);
        int d=unique(Hash+1,Hash+1+n)-Hash-1;
        for(int i=1;i<=n;i++)
        {
            int pos=lower_bound(Hash+1,Hash+1+d,a[i])-Hash;
            b[pos]=a[i];
            update(root[i],root[i-1],1,d,pos);
        }
        while(q--)
        {
            scanf("%d%d%d",&x,&y,&k);
            printf("%d\n",b[query(root[x-1],root[y],1,d,k)]);
        }
    }
    return 0;
}

可持久化01字典树

讨论可持久化01字典树之前，我们先来想一下01字典树的插入操作，插入操作就是从高位向低位去遍历，若当前包含本位则继续递归右儿子，否则递归左儿子，我们发现每次更新的信息还是一条链上的信息，所以如果我们想得到某个区间上的01字典树信息，我们也可以向可持久化线段树一样保存一个前缀和版本的01字典树信息，就可以了。
题目链接
http://acm.hdu.edu.cn/showproblem.php?pid=6191
题意
$给你一颗带权树，每次查询以u为根的子树上与x异或的最大值$
做法
$由于出现子树，我们就可以处理出dfs序$
$之后在dfs序上按顺序建立可持久化01字典树$
$之后就类似主席树用前缀和操作来获取某个区间的01字典树信息$
$进行正常的01字典树查询异或最大值就可以了$
代码

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
typedef long long ll;
#define dbg(x) cout<<#x<<" = "<<x<<endl
const int Mod= 1000000007;
const int maxn=2e5+5;
int fa[maxn];
int val[maxn];
struct node
{
    int to,nxt;
}edge[maxn];
int head[maxn],tot;
int in[maxn],out[maxn];
int num[maxn];
int coun;
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].nxt=head[u];
    head[u]=tot++;
}
void dfs(int u)
{
    in[u]=++coun;
    num[coun]=u;
    for(int i=head[u];i+1;i=edge[i].nxt)
    {
        dfs(edge[i].to);
    }
    out[u]=coun;
}
int tt,root[maxn],son[maxn*35][2],sum[maxn*35];
bool bs[35];
void insert_(int pos,int pre,int &now)
{
    now=++tot;
    son[now][0]=son[pre][0],son[now][1]=son[pre][1];
    sum[now]=sum[pre]+1;
    if(pos==0) return ;
    insert_(pos-1,son[pre][bs[pos-1]],son[now][bs[pos-1]]);
}
int query(int pos,int st,int en)
{
    if(pos==0) return 0;
    int tmp=sum[son[en][bs[pos-1]]]-sum[son[st][bs[pos-1]]];
    if(tmp>0) return query(pos-1,son[st][bs[pos-1]],son[en][bs[pos-1]])+(1<<(pos-1));
    else return query(pos-1,son[st][bs[pos-1]^1],son[en][bs[pos-1]^1]);
}
int main()
{
   int n,q,u,x;
   while(scanf("%d%d",&n,&q)!=EOF)
   {
       memset(head,-1,sizeof(head));
       memset(sum,0,sizeof(sum));
       tot=coun=0;
       tt=1;
       for(int i=1;i<=n;i++)   scanf("%d",&val[i]);
       for(int i=2;i<=n;i++)
        {
            scanf("%d",&x);
            addedge(x,i);
        }
        dfs(1);
        for(int i=1;i<=n;i++)
        {
            int pos=num[i];
            for(int j=0;j<30;j++)
            {
                bs[j]=1&(val[pos]>>j);
            }
            insert_(30,root[i-1],root[i]);
        }
        for(int i=1;i<=q;i++)
        {
            scanf("%d%d",&u,&x);
            for(int j=0;j<30;j++)
            {
                bs[j]=!(1&(x>>j));
            }
            int l=in[u],r=out[u];
            printf("%d\n",query(30,root[l-1],root[r]));
        }
   }
}