线段树合并：对多个有限制的动态开点线段树进行合并
大部分情况下，限制是指单个线段树上只有一条或数条单链存在。
不失一般性地，我们考虑每个线段树上只有一条单链的情况。考虑一个线段树在参与合并的过程中，这条单链上的点，只要已经被dfs过了，那么他就已经被加到另一个线段树的节点里去了（当然也可以是另外一个长得跟他相似的树被加到他这来了，效果相同），自己本身已经相当于被删除不会再被dfs到。因此我们考虑初始 n n n 个线段树的 n l o g n nlogn nlogn 个节点，每个节点相当于最多被dfs一次，因此时空复杂度是 O ( n l o g n ) O(nlogn) O(nlogn)。当然空间上由于题目不一定是 n n n 个单链线段树，因此会有一些常数，具体题目具体分析。
接下来我们来看几个题目。
全宇宙都知道的模板题：[Vani有约会]雨天的尾巴
事实上这个题高中的时候我是用树剖做的，也是因此没怎么学线段树合并，因为很多情况下线段树合并都能被其他算法平替，然而现在发现这玩意太好写了。
我们运用树上差分思想，显然对于一次修改可以变成端点上的+1和-1，于是对每个节点建立权值线段树后，我们就可以在dfs的时候回收这些差分值，在权值线段树上进行修改，然后在每个节点将其子树中的线段树全都合并了就可以查询答案。
由于一共最多可能有 4 m 4m 4m 次差分修改，所以空间复杂度上也会乘个 4 4 4
Code：
struct qry{
int x,y,z;
}q[maxn];
int root[maxn];
int maxx;
int cnt,ver[maxn<<1],nxt[maxn<<1],head[maxn];
int deep[maxn],F[maxn][22];
int ans[maxn],n,m;
struct Seg_Tree{
struct node{
int lson,rson,pre,pos;
}t[8000050];
int tot=0;
inline void pushup(int p)
{
if(t[t[p].lson].pre>=t[t[p].rson].pre) t[p].pre=t[t[p].lson].pre,t[p].pos=t[t[p].lson].pos;
else t[p].pre=t[t[p].rson].pre,t[p].pos=t[t[p].rson].pos;
}
inline int change(int p,int l,int r,int tar,int v)
{
if(!p) p=++tot;
if(l==r)
{
t[p].pre+=v;
t[p].pos=l;
return p;
}
int mid=(l+r)/2;
if(tar<=mid) t[p].lson=change(t[p].lson,l,mid,tar,v);
else t[p].rson=change(t[p].rson,mid+1,r,tar,v);
pushup(p);
return p;
}
inline int merge(int p,int q,int l,int r)
{
if(!p) return q;
if(!q) return p;
if(l==r)
{
t[p].pre+=t[q].pre;
t[p].pos=l;
return p;
}
int mid=(l+r)/2;
t[p].lson=merge(t[p].lson,t[q].lson,l,mid);
t[p].rson=merge(t[p].rson,t[q].rson,mid+1,r);
pushup(p);
return p;
}
}S;
inline void add(int x,int y)
{
cnt++;
ver[cnt]=y;
nxt[cnt]=head[x];
head[x]=cnt;
}
inline void dfs(int x,int fa)
{
deep[x]=deep[fa]+1;
F[x][0]=fa;
for(int i=head[x];i;i=nxt[i])
{
if(ver[i]==fa) continue;
dfs(ver[i],x);
}
}
inline int lca(int x,int y)
{
if(deep[x]<deep[y]) swap(x,y);
for(int i=20;i>=0;i--)
{
if(deep[F[x][i]]>=deep[y])
{
x=F[x][i];
}
}
if(x==y) return x;
for(int i=20;i>=0;i--)
{
if(F[x][i]!=F[y][i])
{
x=F[x][i];y=F[y][i];
}
}
return F[x][0];
}
inline void dfs2(int x,int fa)
{
for(int i=head[x];i;i=nxt[i])
{
if(ver[i]==fa) continue;
dfs2(ver[i],x);
root[x]=S.merge(root[x],root[ver[i]],1,maxx);
}
if(S.t[root[x]].pre) ans[x]=S.t[root[x]].pos;
}
signed main()
{
n=read();m=read();
rep(i,1,n-1)
{
int x=read(),y=read();
add(x,y);add(y,x);
}
dfs(1,0);
rep(i,1,20)
{
rep(j,1,n) F[j][i]=F[F[j][i-1]][i-1];
}
rep(i,1,m)
{
int x=read(),y=read(),z=read();
q[i]={x,y,z};
maxx=max(maxx,z);
}
rep(i,1,m)
{
int x=q[i].x,y=q[i].y,z=q[i].z;
int f=lca(x,y);
root[x]=S.change(root[x],1,maxx,z,1);
root[y]=S.change(root[y],1,maxx,z,1);
root[f]=S.change(root[f],1,maxx,z,-1);
if(F[f][0]) root[F[f][0]]=S.change(root[F[f][0]],1,maxx,z,-1);
}
dfs2(1,0);
rep(i,1,n) printf("%d\n",ans[i]);
}
这个题的第一想法是显然的，由于在每个点交换两个子树时，两个子树内部的逆序对不发生改变，因此只需要考虑两个子树间的逆序对，而这只有交换与不交换两种情况，只需要求个min就可以。那么求逆序对有什么好方法呢？线段树就可以。
实际上，我一开始的想法是合并两颗子树的权值线段树时，将右子树的所有值暴力记录下来然后用经典的求逆序对的方式从左子树的线段树来查找，然而这样不仅代码有点复杂，时间复杂度也会退化到 O ( n l o g 2 n ) O(nlog^2n) O(nlog2n) 。
仔细想想，在合并的过程中可不可以顺带算出两边之间的逆序对呢？可以！只需要在合并的时候在每一层算一下p树的rson.siz和q树的lson.siz的乘积即可，每一层都算完加起来就是答案。
Code：
struct qry{
int x,y,z;
}q[maxn];
int root[maxn];
int maxx;
ll ans,n,m,cnt;
struct Seg_Tree{
struct node{
int lson,rson;
ll siz;
}t[4000050];
ll u,v;
int tot=0;
inline void pushup(int p)
{
t[p].siz=t[t[p].lson].siz+t[t[p].rson].siz;
}
inline int change(int p,int l,int r,int tar,int v)
{
if(!p) p=++tot;
if(l==r)
{
t[p].siz=1;
return p;
}
int mid=(l+r)/2;
if(tar<=mid) t[p].lson=change(t[p].lson,l,mid,tar,v);
else t[p].rson=change(t[p].rson,mid+1,r,tar,v);
pushup(p);
return p;
}
inline int merge(int p,int q,int l,int r)
{
if(!p) return q;
if(!q) return p;
if(l==r)
{
t[p].siz+=t[q].siz;
return p;
}
u+=(t[t[p].rson].siz)*(t[t[q].lson].siz);
v+=(t[t[p].lson].siz)*(t[t[q].rson].siz);
int mid=(l+r)/2;
t[p].lson=merge(t[p].lson,t[q].lson,l,mid);
t[p].rson=merge(t[p].rson,t[q].rson,mid+1,r);
pushup(p);
return p;
}
}S;
inline int dfs()
{
int pos=++cnt,val=read();
if(val==0)
{
int lson=dfs(),rson=dfs();
S.u=0,S.v=0;
root[pos]=S.merge(root[lson],root[rson],1,n);
ans+=min(S.u,S.v);
}
else root[pos]=S.change(root[pos],1,n,val,1);
return pos;
}
signed main()
{
n=read();
dfs();
printf("%lld\n",ans);
}
空间上的优化：CF1009F
这个 O ( n l o g n ) O(nlogn) O(nlogn) 的空间复杂度事实上非常不优秀，在很多题目里是有可能被卡内存的，例如这个题，因此我们需要对空间复杂度进行优化。
其实这个优化非常简单，从上面两个题目我们也能看出来，很多时候你把子树的线段树合并起来以后，原本代表子树的那些节点就全都没用了，我们只需要把他们回收起来重复利用就可以，仔细想想，这样你每次合并完都会把没用的点存起来以后再用，那同时被利用的点是不是最多就是 2 ∗ 4 n 2*4n 2∗4n 个？( 4 n 4n 4n 是单个线段树的大小），这个 2 ∗ 4 n 2*4n 2∗4n 不保证是下限，看到有些大佬开的是 4 n 4n 4n ，但我能保证 2 ∗ 4 n 2*4n 2∗4n 是稳妥的。
那么CF1009F这个题就是一个裸题啦！
Code：
int n,cnt,ver[maxn<<1],nxt[maxn<<1],head[maxn];
int deep[maxn],root[maxn],ans[maxn];
struct Seg_Tree{
struct node{
int lson,rson,pre,pos;
inline void clear()
{
lson=rson=pre=pos=0;
}
}t[8000005];
int tot=0,top=0;
int st[8000005];
inline int newnode()
{
if(top) return st[top--];
else return ++tot;
}
inline void pushup(int p)
{
if(t[t[p].lson].pre>=t[t[p].rson].pre) t[p].pre=t[t[p].lson].pre,t[p].pos=t[t[p].lson].pos;
else t[p].pre=t[t[p].rson].pre,t[p].pos=t[t[p].rson].pos;
}
inline int change(int p,int l,int r,int tar,int v)
{
if(!p) p=newnode();
if(l==r)
{
t[p].pre+=v;
t[p].pos=l;
return p;
}
int mid=(l+r)/2;
if(tar<=mid) t[p].lson=change(t[p].lson,l,mid,tar,v);
else t[p].rson=change(t[p].rson,mid+1,r,tar,v);
pushup(p);
return p;
}
inline int merge(int p,int q,int l,int r)
{
if(!p) return q;
if(!q) return p;
if(l==r)
{
t[p].pre+=t[q].pre;
t[p].pos=l;
st[++top]=q;t[q].clear();
return p;
}
int mid=(l+r)/2;
t[p].lson=merge(t[p].lson,t[q].lson,l,mid);
t[p].rson=merge(t[p].rson,t[q].rson,mid+1,r);
st[++top]=q;t[q].clear();
pushup(p);
return p;
}
}S;
inline void add(int x,int y)
{
cnt++;
ver[cnt]=y;
nxt[cnt]=head[x];
head[x]=cnt;
}
inline void dfs(int x,int fa)
{
deep[x]=deep[fa]+1;
for(int i=head[x];i;i=nxt[i])
{
if(ver[i]==fa) continue;
dfs(ver[i],x);
root[x]=S.merge(root[x],root[ver[i]],1,n);
}
root[x]=S.change(root[x],1,n,deep[x],1);
ans[x]=S.t[root[x]].pos-deep[x];
}
signed main()
{
n=read();
rep(i,1,n-1)
{
int x=read(),y=read();
add(x,y);add(y,x);
}
dfs(1,0);
rep(i,1,n) printf("%d\n",ans[i]);
}
745
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
