主席树学习笔记

最新推荐文章于 2020-06-24 21:33:49 发布

APTX·4869

最新推荐文章于 2020-06-24 21:33:49 发布

阅读量228

点赞数 3

分类专栏： noip

本文链接：https://blog.csdn.net/atpx4689/article/details/97021727

版权

noip 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

主席树学习笔记

~~名称来源：~~
~~发明主席树的dalao首字母缩写为（HJT）正好是某位伟人的名字，因此得名主席树~~

本博客暂时只涉及主席树的单点更新~~区间更新涉及标记永久化，还没看。。。~~

简介

学习主席树之前，要先了解权值线段树。
权值线段树可以维护数字的个数，数组下表维护值域。
作用例：
询问整体第k大（query）：
在线段树上进行二分：
先看左子树数的个数，设其个数为f.
如果f>=t递归进入左子树寻找
如果f<k递归进入右子树寻找第f-k大
即整体二分
以上参考：权值线段树
内容比较简单，可以自行学习。

~~进入正题~~
主席树，也称可持久化线段树，经典的作用是维护区间kth的值。
主席树可以是动态的，也可以是静态的。下面会提供例题。
可持久化线段树应当能支持对曾经存在的状态的访问，所以不能简单的在原先的节点上修改。建立新的节点，是必然的。
那么，需要建立多少个新节点呢？
显然，对于每次单点更新，只需要新建叶节点到根节点路径上的点，数量为logn，==别的节点可以使用上个版本的节点。==实现方式将在例题1中提到。
图片帮助理解（摘自pengwill97的博客）
图片表示的是插入数值1后，2号根节点的儿子节点新建与继承。
在这里插入图片描述

例题部分

~~代码主要参考lyd与konjac_tbr~~

例题1：静态查询区间第k小

lyd关于ask函数分析如下：
以root[l],root[r]为根的两颗线段树对值域的划分是相同的，即除dat不同，两颗线段树内部结构与每个节点代表值域区间完全对应。这意味着：“root[r]的值域区间[L,R]的dat值-root[l-1]的值域区间[L,R]的dat就等于a[l~r]中有多少个数落在[L,R]内”

~~承认我看到这段分析时懵了1秒钟。。。~~
贴代码

#include<bits/stdc++.h>//第一个题，注释会稍微详细点
using namespace std;
const int MAXN=200001;
struct seg{
    int lc,rc,dat;//lc,rc:指针指向左右儿子
}tree[MAXN*20];
int tot,root[MAXN],a[MAXN],n,m,b[MAXN];
int build(int l,int r)
{
    int p=++tot;//新建节点
    tree[p].dat=0;
    if(l==r) {return p;}
    int mid=(l+r)>>1;
    tree[p].lc=build(l,mid),tree[p].rc=build(mid+1,r);//递归建树
    return p;//这里还可以用引用来实现
}
int insert(int now,int l,int r,int x,int val)//单点修改
{
    int p=++tot;
    tree[p]=tree[now];
    if(l==r)
    {
        tree[p].dat+=val;return p;
    }
    int mid=(l+r)>>1;
    if(x<=mid) tree[p].lc=insert(tree[now].lc,l,mid,x,val);
    else tree[p].rc=insert(tree[now].rc,mid+1,r,x,val);
    tree[p].dat=tree[tree[p].lc].dat+tree[tree[p].rc].dat;
    return p;
}
int ask(int p,int q,int l,int r,int k){//区间查询第k小
    if(l==r) return l;//刚好是多出来的第k项 返回l
    int mid=(l+r)>>1;
    //有多少个数落在值域[l,mid]内
    int lcnt=tree[tree[p].lc].dat-tree[tree[q].lc].dat;
    if(k<=lcnt) return ask(tree[p].lc,tree[q].lc,l,mid,k);//左子树的差足够就在左子树找
    else return ask(tree[p].rc,tree[q].rc,mid+1,r,k-lcnt);//否则在右子树找
}
int main()
{
    scanf("%d%d",&n,&m);int t=0;
    for(int i=1;i<=n;++i)
    {
        scanf("%d",&a[i]);b[++t]=a[i];
    }
    //离散化
    sort(b+1,b+t+1);
    t=unique(b+1,b+t+1)-(b+1);
    root[0]=build(1,t);
    for(int i=1;i<=n;++i)
    {
        int x=lower_bound(b+1,b+t+1,a[i])-b;
        root[i]=insert(root[i-1],1,t,x,1);
    }
    for(int i=1;i<=m;++i)
    {
        int l,r,k;scanf("%d%d%d",&l,&r,&k);
        int ans=ask(root[r],root[l-1],1,t,k);//插入第r个数后，插入第l-1个数后，两者的差距就是在[l,r]中新加入的数字
        printf("%d\n",b[ans]);//找回原值
    }
}

模板：可持久化线段树 1（主席树）

例题2：动态单点查询

#include<bits/stdc++.h>
using namespace std;
#define reg register
#define MAXN 2000001
inline int read(){
    reg char ch=getchar();reg int i=0,f=1;
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){i=(i<<1)+(i<<3)+ch-'0';ch=getchar();}
    return i*f;
}
struct seg{
	int l,r,val;
}tr[MAXN*20];
int n,m,a[MAXN],root[MAXN],cnt;
int build(int l,int r)
{
	int k=++cnt;
	if(l==r)
	{
		tr[cnt].val=a[l];return k;
	}
	int mid=(l+r)>>1;
	tr[k].l=build(l,mid),tr[k].r=build(mid+1,r);
	return k;
}
int change(int now,int l,int r,int x,int val)
{
	int k=++cnt;tr[k]=tr[now];
	if(l==r&&l==x)
	{
		tr[cnt].val=val;return k;
	}
	int mid=(l+r)>>1;
	if(x<=mid) tr[k].l=change(tr[now].l,l,mid,x,val);
	else tr[k].r=change(tr[now].r,mid+1,r,x,val);
	return k;
}
int query(int k,int l,int r,int x)
{
	if(l==r&&l==x) return tr[k].val;
	int mid=(l+r)>>1;
	if(x<=mid) return query(tr[k].l,l,mid,x);
	return query(tr[k].r,mid+1,r,x);
}
int main()
{
	n=read(),m=read();
	for(reg int i=1;i<=n;++i) a[i]=read();
	root[0]=build(1,n);
	for(reg int i=1;i<=m;++i)
	{
		int  version=read(),chk=read();
		if(chk==1)
		{
			int loc=read(),val=read();
			root[i]=change(root[version],1,n,loc,val);//更新旧版
		}
		else if(chk==2){
			int loc=read();
			root[i]=root[version];//查询也会生成新版本
			printf("%d\n",query(root[version],1,n,loc));
		}
	}
}

模版：可持久化数组

例题3：可持久化并查集

注意可持久化并查集不能使用路径压缩，故需要用按秩合并优化

#include<bits/stdc++.h>
using namespace std;
#define reg register
#define MAXN 200001
inline int read()
{
    reg int x=0,f=1;reg char c=getchar();
    while(c<'0'||c>'9') {if(c=='-') f=-1;c=getchar();}
    while(c>='0'&&c<='9') x=x*10+c-48,c=getchar();
    return x*f;
}
struct node{
	int l,r,val;
}tr[MAXN*20];
int n,m,fa[MAXN],root[MAXN<<1],cnt,t,dep[MAXN];
int build(int l,int r)
{
	int p=++cnt;
	if(l==r){
		tr[p].val=fa[l];return p;
	}
	int mid=(l+r)>>1;
	tr[p].l=build(l,mid),tr[p].r=build(mid+1,r);
	return p;
}
int query(int k,int l,int r,int x)
{
	if(l==r) return tr[k].val;
	int mid=(l+r)>>1;
	if(x<=mid) return query(tr[k].l,l,mid,x);
	return query(tr[k].r,mid+1,r,x);
}
int change(int now,int l,int r,int x,int val)
{
	int p=++cnt;tr[p]=tr[now];
	if(l==r)
	{
		tr[p].val=val;return p;
	}
	int mid=(l+r)>>1;
	if(x<=mid) tr[p].l=change(tr[now].l,l,mid,x,val);
	else tr[p].r=change(tr[now].r,mid+1,r,x,val);
	return p;
}
inline int get(int x)
{
	int f=query(root[t],1,n,x);
	if(x!=f) return get(f);
	return x;
}
inline void add(int k,int l,int r,int x)
{
	if(l==r)
	{
		++dep[k];return;
	}
	int mid=(l+r)>>1;
	if(x<=mid) add(tr[k].l,l,mid,x);
	else add(tr[k].r,mid+1,r,x);
}
int main()
{
	n=read(),m=read();
	for(reg int i=1;i<=n;++i) fa[i]=i;
	root[0]=build(1,n);
	for(reg int i=1;i<=m;++i)
	{
		int chk=read();
		if(chk==1)
		{
			int x=read(),y=read();
			int x0=get(x),y0=get(y);
			if(x0!=y0){
				//按秩合并
				if(dep[x0]>dep[y0]) swap(x0,y0);
				root[i]=change(root[t],1,n,x0,y0);
				if(dep[x0]==dep[y0]) add(root[i],1,n,y0);//更新深度
			}
			else root[i]=root[t];
			t=i;
		}
		else if(chk==2){
			t=read();root[i]=root[t];
		}
		else if(chk==3)
		{
			int x=read(),y=read();
			int x0=get(x),y0=get(y);
			root[i]=root[t];
			t=i;
			printf("%d\n",(x0==y0)?1:0);//三目输出 来自konjac_tbr
		}
	}
}```
[模版： 可持久化并查集](https://www.luogu.org/problemnew/show/P3402)