众所周知,线段树是一个非常好用也好写的数据结构,
因此,我们今天的前置技能:线段树.
然而,可持久化到底是什么东西?
别急,我们一步一步来...
step 1
首先,一道简化的模型:
给定一个长度为\(n\)的序列,\(m\)个操作,支持两种操作:
- 修改某个点\(i\)的权值
- 查询历史上某个版本\(u\)中点\(i\)的权值
同时,每个操作都会生成一个新的版本(也就是说修改是改的一个新的版本,而查询是直接\(copy\)上一个版本.
那么,暴力的做法来了:
直接维护\(m\)棵线段树,先\(copy\)一遍,再直接修改/查询.
然而时间空间都得炸啊啊啊
别急,让我们仔细想想...
首先,我们考虑一下每次修改会发生什么(看图):
(其中修改的是6号节点,红色是经过的路径),
我们可以发现,每次修改都只改了一条链.
也就是说,对于上一个版本,就只有一条链不一样(查询就是一模一样了).
因此,对于上一个版本中一样的其他的链,我们就可以直接沿用.
比如说,上一个版本长这样:
而沿用后的图就长这样选点时的随意导致了图片的丑陋:
那么,我们就只需要在更新版本时,新建一个根节点\(rt[i]\),
并且只需要新建修改的那条链,其他的沿用上一个版本的就行了.
代码也很简单:
void update(int &k/*动态加的点(当前节点)*/,int p/*沿用的点,即上个版本中这个位置的节点编号*/,int l,int r,int pla/*修改的元素位置*/,int x/*修改的权值*/){
k=++tot;t[k]=t[p];//先copy一波
if(l==r){t[k].val=x;return ;}
int mid=(l+r)>>1;//这里就和线段树一样了
if(pla<=mid) update(t[k].l,t[p].l,l,mid,pla,x);
else update(t[k].r,t[p].r,mid+1,r,pla,x);
}顺便把建树和询问也贴上来吧(其实和线段树一样):
void build(int &x,int l,int r){
x=++tot;
if(l==r){t[x].val=a[l];return ;}
int mid=(l+r)>>1;
build(t[x].l,l,mid);build(t[x].r,mid+1,r);
}
int query(int p,int l,int r,int x){
if(l==r) return t[p].val;
int mid=(l+r)>>1;
if(x<=mid) return query(t[p].l,l,mid,x);
else return query(t[p].r,mid+1,r,x);
}到这里,一个简单的模板就结束啦.
例题:[模板]可持久化数组
这题就和模板一模一样,
在叶子节点记录权值,每次单点修改即可.
注意一下,询问是复制的询问的那个版本(不是上一个)因为这个调了好久qwq
上完整代码吧其实都在上面了~:
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
inline int read(){
int sum=0,f=1;char c=getchar();
while(c>'9'||c<'0'){if(c=='-') f=-1;c=getchar();}
while(c<='9'&&c>='0'){sum=sum*10+c-'0';c=getchar();}
return sum*f;
}
const int MX=1000005;
struct tree{int l,r,val;}t[MX*30];
int n,m,a[MX];
int rt[MX],tot=0;
void build(int &x,int l,int r){
x=++tot;
if(l==r){t[x].val=a[l];return ;}
int mid=(l+r)>>1;
build(t[x].l,l,mid);build(t[x].r,mid+1,r);
}
void update(int &k,int p,int l,int r,int pla,int x){
k=++tot;t[k]=t[p];
if(l==r){t[k].val=x;return ;}
int mid=(l+r)>>1;
if(pla<=mid) update(t[k].l,t[p].l,l,mid,pla,x);
else update(t[k].r,t[p].r,mid+1,r,pla,x);
}
int query(int p,int l,int r,int x){
if(l==r) return t[p].val;
int mid=(l+r)>>1;
if(x<=mid) return query(t[p].l,l,mid,x);
else return query(t[p].r,mid+1,r,x);
}
int main(){
n=read();m=read();
for(int i=1;i<=n;i++) a[i]=read();
build(rt[0],1,n);
for(int i=1;i<=m;i++){
int tt=read(),opt=read(),pla=read();
if(opt==1){int x=read();update(rt[i],rt[tt],1,n,pla,x);}
else if(opt==2){printf("%d\n",query(rt[tt],1,n,pla));rt[i]=rt[tt];}
}
return 0;
}
step 2
接下来,就是我们喜闻乐见的主席树了(话说有哪位\(dalao\)能告诉我为什么叫这名字?).
我们以一道模板题开始吧:[模板]可持久化线段树 1(主席树)
给出一个长度为\(n\)的序列,\(m\)个询问,每次询问区间\([l,r]\)中第\(k\)小的数.
这题暴力很好写吧(然而我们并不满足于暴力).
我们还是一步步来,
首先,先考虑下如果是区间\([1,n]\)的第\(k\)小该怎么做:
这时候,我们可以考虑到权值线段树.
将原序列离散化,再建一棵线段树,
但这个线段树维护的区间并不是序列的区间,
而是权值的区间.
比如说区间\([l,r]\),其实指的是离散化后的权值\(l\)~\(r\),
也就是第\(l\)大到第\(r\)大.
还是举个栗子吧:
假设我们现在有一个序列\(a\):1,3,3,5,5,5,8,8,8,8.
那么离散化以后就是:1,2,2,3,3,3,4,4,4,4.
然后我们再建一棵权值线段树:
其中黑色的代表节点编号,红色的代表权值区间,
而蓝色的是接下来我们要讲的每个节点维护的一个值:\(cnt\).
这个\(cnt\)表示的是当前节点的权值区间内有几个节点.
听不懂?没关系我们接着看:
当我们讲第一个元素(在离散化后就是\(1\))插入以后,树就变成了这样:
所有权值区间包括\(1\)的\(cnt\)都加了\(1\).
而当我们将所有数都插进去后,树就成了这样:
于是,我们就可以清楚地看到,在序列中,权值在区间\([l,r]\)的数有多少个.
插入的代码如下:
int update(int p/*节点编号*/,int l,int r/*l,r为权值区间*/,int k/*插入的权值*/){
int x=++tot;t[x]=t[p];t[x].cnt++;
if(l==r) return x;
int mid=(l+r)>>1;
if(k<=mid) t[x].l=build(t[p].l,l,mid,k);
else t[x].r=build(t[p].r,mid+1,r,k);
return x;
}然后我们在求第\(k\)小时,先与左子树的\(cnt\)比较,
若\(k<=cnt\),那答案就在左子树的权值区间里,
否则,将\(k\)减去\(cnt\),再在右子树里找,
一直到最底层就行了.
查询代码如下:
int query(int p/*当前节点*/,int l,int r,int k/*第k小*/){
if(l==r) return l;
int mid=(l+r)>>1;
if(k<=t[t[p].l].cnt) return query(t[p].l,l,mid,k);
else return query(t[p].r,mid+1,r,k-t[t[p].l].cnt);
}那么接下来,我们来考虑区间\([l,r]\)的第\(k\)小:
仔细想想,其实我们可以用前缀和的思想,
一个权值为\(x\)的数在\(1\)~\(l-1\)中出现了\(a\)次,
在\(1\)~\(r\)中出现了\(b\)次,
那么它在区间\([l,r]\)中就出现了\(a-b\)次.
因此,我们可以对每个区间\([1,i],i\in [1,n]\)建一颗权值线段树,
在查询时,用前缀和的思想计算\(cnt\),再查找就行啦.
然而到这里就结束了吗?
我们注意到,对于区间\([1,i]\)的权值线段树,
与区间\([1,i-1]\)比起来仅仅是多插入了一个\(i\)的权值而已.
想到了什么? 可持久化线段树!
没错,我们可以像可持久化线段树一样,
沿用相同的节点,只新建需要更新的一条链就行了.
贴上新的询问代码:
int query(int L/*区间[1,l-1]的节点*/,int R/*区间[1,r]的节点*/,int l,int r,int k/*第k小*/){
if(l==r) return l;
int mid=(l+r)>>1,sum=t[t[R].l].cnt-t[t[L].l].cnt;//前缀和
if(sum>=k) return ask(t[L].l,t[R].l,l,mid,k);
else return ask(t[L].r,t[R].r,mid+1,r,k-sum);
}到这里,主席树就讲完啦.
上完整代码吧:
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
inline int read(){
int sum=0,f=1;char c=getchar();
while(c<'0'||c>'9'){if(c=='-') f=-1;c=getchar();}
while(c>='0'&&c<='9'){sum=sum*10+c-'0';c=getchar();}
return sum*f;
}
struct tree{int cnt,l,r;}t[5000001];
int n,m,a[1000001],c[1000001];
int rt[500001],tot=0;
int build(int p,int l,int r,int k){
int x=++tot;
t[x]=t[p];t[x].cnt++;
if(l==r) return x;
int mid=(l+r)>>1;
if(k<=mid) t[x].l=build(t[p].l,l,mid,k);
else t[x].r=build(t[p].r,mid+1,r,k);
return x;
}
int ask(int L,int R,int l,int r,int k){
if(l==r) return l;
int mid=(l+r)>>1,sum=t[t[R].l].cnt-t[t[L].l].cnt;
if(sum>=k) return ask(t[L].l,t[R].l,l,mid,k);
else return ask(t[L].r,t[R].r,mid+1,r,k-sum);
}
int main(){
n=read();m=read();
for(int i=1;i<=n;i++) a[i]=read();
memcpy(c,a,sizeof(c));sort(c+1,c+n+1);
int T=unique(c+1,c+n+1)-c-1;
for(int i=1;i<=n;i++) a[i]=lower_bound(c+1,c+T+1,a[i])-c;
for(int i=1;i<=n;i++) rt[i]=build(rt[i-1],1,T,a[i]);
for(int i=1;i<=m;i++){
int l=read(),r=read(),k=read();
printf("%d\n",c[ask(rt[l-1],rt[r],1,T,k)]);
}
return 0;
}
以后可能还会更新(埋个坑在这)...