主席树（可持久化线段树）
主席树
前言
主席树也是一种数据结构，是线段树的进阶，作用是可以保留历史版本，支持回退，就是回到之前某个未修改的状态。就像我们在写博客时如果误删了重要的内容，就可以用 Ctrl + z 撤回一次操作，也可以用Ctrl + Shift +z 还原我们撤回的操作，这就需要存下每次编辑的操作。
基本原理
可持久化线段树，顾名思义，是可持久的线段树（好像是废话）。那么问题就在于怎么去可持久化，支持访问历史版本。
最暴力的，直接复制整棵树，再对新的这棵树进行修改。但这样的话，节点数为 \(n\)，操作数为 \(m\)，时间复杂就是 \(O(nm)\)。
好了，直接 TLE。显然复制这棵树会有非常多的浪费，思考一下，我们只需要复制修改后发生改变的点就好了。
我们要复制的只是蓝色的点其他的保持不变，要在蓝色的点边上复制一个一模一样的点然后修改。如图：
红色的点即为修改后的点，继承原节点的所有信息，包括未修改的儿子。这样我们只需要存下每次修改后的根，就能访问该版本的树。修改的时间复杂度为 \(O(\log{n})\)。
操作
前置操作
定义节点，存 5 个信息：左右儿子，左右端点，权值。
#define lc a[u].l
#define rc a[u].r
#define L a[u].ls
#define R a[u].rs
struct tree
{
int l,r;
int ls,rs;
int v;
}a[N];
新建节点
int tot;
int New(int u)
{
a[++tot]=a[u];//结构体直接复制所有信息
return tot;
}
建树
和线段树类似，不过节点编号依次增加，但左右儿子不一定是乘二和乘二加一了。
int build(int u,int l,int r)
{
u=++tot;
L=l,R=r;//更新区间端点
if(l==r)
{
a[u].v=w[l];
return u;
}
int mid=(l+r)>>1;
lc=build(lc,l,mid);
rc=build(rc,mid+1,r);
return u;
}
修改
先新建节点，然后在新建的树中修改，要记得更新修改了的儿子。
int modify(int u,int x,int v)
{
u=New(u);
if(L==R) a[u].v=v;
else
{
int mid=(L+R)>>1;
if(x<=mid) lc=modify(lc,x,v);
else rc=modify(rc,x,v);
}
return u;
}
查询
和线段树一毛一样的。
int query(int u,int x)
{
if(L==R) return a[u].v;
else
{
int mid=(L+R)>>1;
if(x<=mid) return query(lc,x);
else return query(rc,x);
}
}
存根
每次修改后最终返回的是新的根节点，所以直接用数组存就好了。
P3919 【模板】可持久化线段树 1（可持久化数组）
code
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define lc a[u].l
#define rc a[u].r
#define L a[u].ls
#define R a[u].rs
const int M=3e7+5,N=1e6+5;
struct tree
{
int l,r;
int ls,rs;
int v;
}a[M];
int n,tot,w[N],rt,root[N],m;
int New(int u)
{
a[++tot]=a[u];//结构体直接复制所有信息
return tot;
}
int build(int u,int l,int r)
{
u=++tot;
L=l,R=r;//更新区间端点
if(l==r)
{
a[u].v=w[l];
return u;
}
int mid=(l+r)>>1;
lc=build(lc,l,mid);
rc=build(rc,mid+1,r);
return u;
}
int modify(int u,int x,int v)
{
u=New(u);
if(L==R) a[u].v=v;
else
{
int mid=(L+R)>>1;
if(x<=mid) lc=modify(lc,x,v);
else rc=modify(rc,x,v);
}
return u;
}
int query(int u,int x)
{
if(L==R) return a[u].v;
else
{
int mid=(L+R)>>1;
if(x<=mid) return query(lc,x);
else return query(rc,x);
}
}
int main ()
{
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
cin>>n>>m;
for(int i=1;i<=n;i++) cin>>w[i];
root[0]=build(0,1,n);
rt=0;
for(int i=1,op,x,y;i<=m;i++)
{
cin>>rt>>op>>x;
if(op==1) cin>>y,root[i]=modify(root[rt],x,y);
else cout<<query(root[rt],x)<<"\n",root[i]=root[rt];
}
return 0;
}
要注意节点实际个数。
P3834 【模板】可持久化线段树 2
分析
首先，因为数据跨度太大，所以先离散化。嗯，不会？没事，看 离散化。
然后，基于数值建立线段树，即权值线段树，维护一段值域内的数的个数。权值线段树求整个区间的第 \(k\) 小的数，就是在权值线段树上二分，从根节点开始，如果 \(k\) 比右儿子大，就说明第 \(k\) 小的数在右儿子所表示的值域中。接着，\(k\) 要减去左儿子，再进入右儿子中继续；如果 \(k\) 比左儿子小，就直接进入左儿子。
那么好，子区间 \([l,r]\) 的第 \(k\) 小的数怎么求呢？（区间都是离散化好了的）
首先思考求 \([1,r]\) 的第 \(k\) 小的数，用主席树，依次加入 \([1,r]\) 的值的节点，生成 \(r\) 个版本，从 \(root[r]\) 开始找就可以了。
那么右边有限制，左边也有限制，该怎么办呢？先明确一点，主席树，每次修改后，对于每个根节点对应的每一棵树，结构都是相同的，就是拓扑排序相同。
也就是说，所有节点对应的区间都是一一对应的。在根节点为 \(root[R]\) 的树中值域为 \([l,r]\) 的个数为 \(cnt1\)，在根节点为 \(root[L-1]\) 的树中值域为 \([l,r]\) 的个数为 \(cnt2\)，类似于前缀和的思想，\([L,R]\) 中 \([l,r]\) 的个数为 \(cnt1-cnt2\)。
这样就可以了，只需要在递归的时候统计个数，找到对应的那个数输出即可。
code
#include <bits/stdc++.h>
using namespace std;
#define lc a[u].l
#define rc a[u].r
#define L a[u].ls
#define R a[u].rs
const int N=2e5+5,M=3e7+5;
struct tree
{
int l,r;
int ls,rs;
int cnt;
}a[M];
int n,m,tot,root[N],rt,idx;
int b[N],c[N],C[N];
int New(int u)
{
a[++idx]=a[u];
return idx;
}
void pushup(int u)
{
a[u].cnt=a[lc].cnt+a[rc].cnt;
}
int build(int l,int r)
{
int u=++idx;
L=l,R=r;
if(l==r) return u;
int mid=(l+r)>>1;
lc=build(l,mid);
rc=build(mid+1,r);
return u;
}
int find(int x)
{
return lower_bound(c+1,c+tot+1,x)-c;
}
int modify(int u,int x)
{
u=New(u);
if(L==R)
{
a[u].cnt++;
return u;
}
int mid=(L+R)>>1;
if(x<=mid) lc=modify(lc,x);
else rc=modify(rc,x);
pushup(u);
return u;
}
int query(int u,int v,int x)
{
if(L==R) return R;
int cnt=a[a[v].l].cnt-a[a[u].l].cnt;
if(x<=cnt) return query(a[u].l,a[v].l,x);
else return query(a[u].r,a[v].r,x-cnt);
}
int main ()
{
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
cin>>n>>m;
for(int i=1;i<=n;i++) cin>>b[i],c[i]=b[i];
sort(c+1,c+n+1);
tot=n;//不用去重
root[0]=build(1,tot);
for(int i=1;i<=tot;i++) root[i]=modify(root[i-1],find(b[i]));
while(m--)
{
int l,r,k;
cin>>l>>r>>k;
cout<<c[query(root[l-1],root[r],k)]<<"\n";
}
}
本题离散化不需要去重，因为按值域加点每次只会增加一 QAQ。
