可持久化线段树
作者：互联网
现想现写的，没有借鉴别人的任何东西。
考虑不会变得太多，每次该值操作只会改变一个位置的值，其它位置是可以继承的。如果用数组，那就是下标继承。如果把数组分成 \(2\) 半，那改一个值，就一半继承，另一半重新赋值。而用线段树，就可以做到区间继承 \(\log\) 的时间复杂度。
所以就是：当前区间分成 \(2\) 半，一半直接继承原来的，另一半继续递归下去，又可以分。
查询跟普通线段树一样。
时间复杂度 \(O(q\log_{2}n)\)。
点击查看代码
#include <bits/stdc++.h>
using namespace std;
const int MAXN=2e7+4e6;
int tr[MAXN],ls[MAXN],rs[MAXN],tot;
int Root[MAXN];
void Add(int &u1,int u2,int l,int r,int id,int Val)
{
if(!u1)
{
u1=++tot;
}
if(l==r)
{
tr[u1]=Val;
return;
}
int Mid=l+r>>1;
if(id<=Mid)
{
rs[u1]=rs[u2];
Add(ls[u1],ls[u2],l,Mid,id,Val);
}
else
{
ls[u1]=ls[u2];
Add(rs[u1],rs[u2],Mid+1,r,id,Val);
}
}
int Query(int u,int l,int r,int x)
{
if(l==r)
{
return tr[u];
}
int Mid=l+r>>1;
if(x<=Mid)
return Query(ls[u],l,Mid,x);
else
return Query(rs[u],Mid+1,r,x);
}
int N,Q;
int a[MAXN];
void Build(int &u,int l,int r)
{
if(!u)
{
u=++tot;
}
if(l==r)
{
tr[u]=a[l];
return;
}
int Mid=l+r>>1;
Build(ls[u],l,Mid);
Build(rs[u],Mid+1,r);
}
int main()
{
scanf("%d%d",&N,&Q);
for(int i=1;i<=N;i++)
{
scanf("%d",&a[i]);
}
Build(Root[0],1,N);
for(int i=1;i<=Q;i++)
{
int v,op,Loc,Value;
scanf("%d%d%d",&v,&op,&Loc);
if(op==1)
{
scanf("%d",&Value);
Add(Root[i],Root[v],1,N,Loc,Value);
}
if(op==2)
{
Root[i]=Root[v];
printf("%d\n",Query(Root[v],1,N,Loc));
}
}
}
离散化，建权值线段树。对于第 \(i\) 个值，才建一棵线段树包含 \(a_1\) 至 \(a_i\) 的值，这可以持久化。
记录每个值域线段树每个值域区间的 Size 表示这里面有多少个有被用的叶子，上述操作相当于每次新建一棵线段树，新将一个叶子赋值为被用过。
然后查询区间 \([L,R]\) 第 \(k\) 大，对于当前递归到的区间，如果左区间的 \(Size_R-Size_{L-1}\) 比 \(k\) 小，那就说明左区间的数不够 \(k\) 个，第 \(k\) 大一定为右区间的第 \(k-(Size_R-Size_{L-1})\) 大，再递归下去。反之就不减，递归到左区间。
最后一定会出结果，除非这个区间一共都没有 \(k\) 个值。
时间复杂度 \(O((n+q)\log_2 n)\)
点击查看代码
#include <bits/stdc++.h>
using namespace std;
const int MAXN=5e6+50;
int N,Q;
int a[MAXN];
vector<int>lsh;
int Size[MAXN];
int ls[MAXN],rs[MAXN];
int tot;
int Root[MAXN];
void Add(int &u1,int u2,int l,int r,int Val)
{
if(!u1)
u1=++tot;
if(l==r)
{
Size[u1]=Size[u2]+1;
return;
}
int Mid=l+r>>1;
if(Val<=Mid)
{
rs[u1]=rs[u2];
Add(ls[u1],ls[u2],l,Mid,Val);
}
else
{
ls[u1]=ls[u2];
Add(rs[u1],rs[u2],Mid+1,r,Val);
}
Size[u1]=Size[ls[u1]]+Size[rs[u1]];
}
int Query(int u1,int u2,int l,int r,int k)
{
if(l==r)
{
return l;
}
int Mid=l+r>>1;
if(k<=Size[ls[u1]]-Size[ls[u2]])
{
return Query(ls[u1],ls[u2],l,Mid,k);
}
else
{
k-=(Size[ls[u1]]-Size[ls[u2]]);
return Query(rs[u1],rs[u2],Mid+1,r,k);
}
}
int Back[MAXN];
int main()
{
scanf("%d%d",&N,&Q);
for(int i=1;i<=N;i++)
{
scanf("%d",&a[i]);
lsh.push_back(a[i]);
}
sort(lsh.begin(),lsh.end());
int Cnt=unique(lsh.begin(),lsh.end())-lsh.begin();
for(int i=1;i<=N;i++)
{
a[i]=lower_bound(lsh.begin(),lsh.begin()+Cnt,a[i])-lsh.begin()+1;
Back[a[i]]=lsh[a[i]-1];
}
for(int i=1;i<=N;i++)
{
Add(Root[i],Root[i-1],1,Cnt,a[i]);
}
while(Q--)
{
int l,r,k;
scanf("%d%d%d",&l,&r,&k);
printf("%d\n",Back[Query(Root[r],Root[l-1],1,Cnt,k)]);
}
}
每次持久化都会增加 \(\log_2 n\) 个节点，加上最开始的 \(4n\) 左右个的节点，所以数组大小至少为 \(n\log_2 n+4n\)，当然要视具体题目调整。
一般二维数点的题可持久化线段树都能做。二维数点的其它做法也都挺厉害。
经常与整体二分搭配使用。
最常出现的关键词就是“区间第 \(k\) 大”。
注意第二题的 Add 操作递归到底层后，Size 不能直接赋值为 1，而要加上前一棵线段树的同一节点的 Size，当有重复数字时这样做才对，而如果没有重复就不需要考虑。
标签：持久,int,线段,u1,MAXN,区间,Size 来源： https://www.cnblogs.com/0htoAi/p/16663455.html