变种线段树 提高篇
可持久化线段树
注意，它的全称为可持久化权值线段树。
例题 \(1\)：可持久化线段树
首先我们考虑几个暴力：
对于每次询问，找出区间中的所有数，直接排序求第 \(k\) 小。这样做的时间复杂度为 \(O(nq\log n)\) 的。
对于每次询问，建出一棵权值线段树，然后权值线段树上二分查找即可。
发现瓶颈在于建树，如果忽略建树则复杂度为 \(O(q\log n)\) 的。
我们把每次插入一个数后看做一个历史版本，那么区间 \([l,r]\) 内的数就是 \(r\) 历史版本与 \(l-1\) 历史版本做差。这就是我们的询问。
考虑每次插入一个数改变了什么，改变了一条链上的信息，链最长不过树高，树高为 \(\log n\)，所以每次插入一个数是 \(O(\log n)\) 的，建树总时间复杂度 \(O(n\log n)\)。
查询的时候，因为做了前缀和，所以我们考虑左子树内的数的数量是否不小于当前的\(k\)，如果是，递归左子树；否则递归右子树，同时 \(k\) 减去左子树内数的数量，查询最后会返回这个被离散化后的值，还原一下即可。
代码：
#include<bits/stdc++.h>
#define int long long
#define N 200005
using namespace std;
int n,m,a[N],b[N],rt[N];
struct dsgt{
struct node{
int l,r,v;
}tr[N<<5];
int cnt=0;
int build(int L,int R){
int u=++cnt;
tr[u]={0,0,0};
if(L<R){
int mid=L+R>>1;
tr[u].l=build(L,mid);//动态开点的建树方法
tr[u].r=build(mid+1,R);
}
return u;
}
int modify(int las,int L,int R,int x){
int u=++cnt;
tr[u]={tr[las].l,tr[las].r,tr[las].v+1};//继承上一个历史版本，x一定在改的东西代表的区间内
if(L<R){
int mid=L+R>>1;
if(x<=mid)tr[u].l=modify(tr[las].l,L,mid,x);//这里保证改的是一条链，同时所有区间包含x
else tr[u].r=modify(tr[las].r,mid+1,R,x);
}
return u;
}
int qry(int las,int now,int L,int R,int k){
if(L==R)return L;//返回离散化后的值（排名）
int mid=L+R>>1;
int num=tr[tr[now].l].v-tr[tr[las].l].v;
if(num>=k)return qry(tr[las].l,tr[now].l,L,mid,k);//分讨在哪个子树内
else return qry(tr[las].r,tr[now].r,mid+1,R,k-num);
}
//可持久化线段树需要使用动态开点，否则空间会炸
//注意全名叫可持久化“权值”线段树
}dsgt;
signed main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
cin>>a[i];
b[i]=a[i];
}
sort(b+1,b+n+1);
int cnt=unique(b+1,b+n+1)-b-1;//离散化
rt[0]=dsgt.build(1,cnt);//建出空版本
for(int i=1;i<=n;i++){
int tmp=lower_bound(b+1,b+cnt+1,a[i])-b;
rt[i]=dsgt.modify(rt[i-1],1,cnt,tmp);//依次插入新数
}
while(m--){
int l,r,k;
cin>>l>>r>>k;
int res=dsgt.qry(rt[l-1],rt[r],1,cnt,k);//询问[l,r]相当于两个历史版本做差
cout<<b[res]<<'\n';//还原会最初的值
}
return 0;
}
例题 \(2\)：美味
我们考虑一个按位贪心。先分类讨论一下，这里假设当前最优的答案为 \(ans\)：
-
\(b\) 的第 \(j\) 位为 \(0\)：最好使 \(a\) 的第 \(j\) 位为 \(1\)，故最优区间 \([ans+2^j,ans+2^{j+1}-1]\)。
-
\(b\) 的第 \(j\) 位为 \(1\)：最好使 \(a\) 的第 \(j\) 位为 \(0\)，故最优区间 \([ans,ans+2^j-1]\)。
于是我们使用主席树快速查找这个区间内有没有数即可。
代码：
#include<bits/stdc++.h>
#define int long long
#define N 500005
using namespace std;
int n,q,a[N],rt[N];
struct dsgt{
struct node{
int l,r,v;
}tr[N<<5];
int cnt=0;
void modify(int las,int &now,int l,int r,int x){
if(l>x||r<x)return;
now=++cnt;
tr[now]={tr[las].l,tr[las].r,tr[las].v+1};
if(l==r)return;
int mid=l+r>>1;
modify(tr[las].l,tr[now].l,l,mid,x);
modify(tr[las].r,tr[now].r,mid+1,r,x);
}
int qry(int las,int now,int l,int r,int L,int R){
int num=tr[now].v-tr[las].v;
int mid=l+r>>1;
if(l>=L&&r<=R)return num;
if(l>R||r<L||num==0)return 0;
return qry(tr[las].l,tr[now].l,l,mid,L,R)+qry(tr[las].r,tr[now].r,mid+1,r,L,R);
}
}dsgt;
signed main(){
cin>>n>>q;
int mx=0;
for(int i=1;i<=n;i++){
cin>>a[i];
mx=max(mx,a[i]);
}
for(int i=1;i<=n;i++){
dsgt.modify(rt[i-1],rt[i],0,mx,a[i]);
}
while(q--){
int b,x,l,r;
cin>>b>>x>>l>>r;
int res=0;
for(int i=18;~i;i--){
if(b>>i&1){
if(dsgt.qry(rt[l-1],rt[r],0,mx,res-x,res-x+(1<<i)-1)==0)res+=1<<i;
}
else{
if(dsgt.qry(rt[l-1],rt[r],0,mx,res-x+(1<<i),res-x+(1<<i+1)-1)!=0)res+=1<<i;
}
}
cout<<(res^b)<<'\n';
}
return 0;
}
线段树分治
线段树分治是一种按照时间分治的技巧，适用于支持插入，不支持删除的数据结构的维护。我们可以使用线段树分治将其转化为撤销操作。
考虑如何撤销。使用一个栈记录修改操作，撤销时弹栈回退即可。
我们使用线段树维护时间轴，对于每个操作离线后得到它影响的时间段 \([l,r]\)，然后在线段树上找到代表的区间被它完全包含的位置加入这个操作。
接下来我们对整棵线段树进行中序遍历。如果这一步是向儿子走的，则代表我们计入该子节点的操作带来的贡献；如果这一步是向父亲走的，则代表我们撤销当前节点的所有操作。
那么，对于时刻 \(t\) 的答案，就是从根走到代表区间 \([t,t]\) 的叶子节点的答案。
例题 \(1\)：线段树分治
首先使用拓展域并查集判定二分图，这里要使用可撤销并查集，所以不能路径压缩，需要使用按秩合并。
代码：
#include<bits/stdc++.h>
#define int long long
#define N 100005
#define pii pair<int,int>
#define x first
#define y second
using namespace std;
int n,m,k,fa[N<<1],siz[N<<1],chk[N<<2];
vector<pii>tr[N<<2];
int find(int x){
if(fa[x]!=x)return find(fa[x]);//不能使用路径压缩
return fa[x];
}
void modify(int u,int l,int r,int L,int R,pii v){
if(l>=L&&r<=R){
tr[u].push_back(v);//如果当前操作的时间完全包含这个点的时间，就加入这个操作
return;
}
int mid=l+r>>1;
if(L<=mid)modify(u<<1,l,mid,L,R,v);
if(R>mid)modify(u<<1|1,mid+1,r,L,R,v);
}
void undo(vector<pii>&x){
for(auto it:x){
siz[it.x]-=siz[it.y];//撤销
fa[it.y]=it.y;
}
}
void qry(int x,int l,int r){
vector<pii>s;
if(chk[x]){//如果可能可行
for(auto it:tr[x]){
int u=it.x,v=it.y,uu=u+n,vv=v+n;
u=find(u);v=find(v);uu=find(uu);vv=find(vv);
if(u==v){//如果在一部里还有边，就不是二分图
chk[x]=0;
break;
}
if(siz[u]<siz[vv])swap(u,vv);
if(siz[v]<siz[uu])swap(v,uu);//按秩合并
s.push_back({u,vv});
s.push_back({v,uu});//用栈记录操作，用于可撤销并查集
siz[u]+=siz[vv];fa[vv]=u;
siz[v]+=siz[uu];fa[uu]=v;
}
}
if(l==r){//到达叶子
cout<<(chk[x]?"Yes\n":"No\n");
undo(s);//撤销
return;
}
chk[x<<1]=chk[x<<1|1]=chk[x];//如果父亲可行，还有可能可行；否则一定不可行
int mid=l+r>>1;
qry(x<<1,l,mid);
qry(x<<1|1,mid+1,r);
undo(s);//递归后撤销
}
signed main(){
cin>>n>>m>>k;
chk[1]=1;//初始可行
for(int i=1;i<=n<<1;i++){
fa[i]=i;
siz[i]=1;
}
for(int i=1;i<=m;i++){
int x,y,l,r;
cin>>x>>y>>l>>r;
if(l==r)continue;//同时出现和消失相当于没有出现
modify(1,0,k-1,l,r-1,{x,y});//因为r-1<k，所以只需要到k-1
}
qry(1,0,k-1);//这里同理，到k-1即可
return 0;
}
