专题树链剖分保证你看不懂

最新推荐文章于 2022-08-14 21:21:11 发布

置顶「已注销」

最新推荐文章于 2022-08-14 21:21:11 发布

阅读量108

点赞数 1

本文链接：https://blog.csdn.net/weixin_44577381/article/details/99656180

版权

文章目录

算法简介
算法实现

算法简介

树链剖分，指一种对树进行划分，先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组，线段树等）来维护每一条链。它通常可以解决以下几个操作：

修改路径权值：给定两个节点，修改这两个节点间路径上的节点权值。
修改子树权值：给定一个节点，将修改以该节点为根的子树内的节点权值。
询问路径：询问某条路径上节点的权值。
询问子树：询问某个子树内节点的权值。
换根：将一个指定的节点设置为树的新根（这个不太常见）。

算法实现

基本概念

首先让我们来明确树链剖分的一些基本概念。

重儿子：父亲节点的所有儿子中子树结点数目最多（size最大）的结点；
轻儿子：父亲节点中除了重儿子以外的儿子；
重边：父亲结点和重儿子连成的边；
轻边：父亲节点和轻儿子连成的边；
重链：由多条重边连接而成的路径；
轻链：由多条轻边连接而成的路径；

以下图为例：
在这里插入图片描述
图中的黑色的边为轻边，红色边即为重边。重边连成的链为重链。与红色边相连的所有节点为重儿子。用一条重链上深度最小的节点（顶端节点）就是该重链的起点，也就是下文提到的 $t o p$ 结点。显然，重链不一定只有一条，每个子树都至少有一条重链，每个节点属于且仅属于一条重链。

变量声明

名称	解释
$f a [u]$	保存结点u的父亲节点
$d e p [u]$	保存结点u的深度值
$s i z e [u]$	保存以u为根的子树节点个数
$s o n [u]$	保存结点u的重儿子
$t o p [u]$	保存结点u所在链的顶端节点
$i d [u]$	保存结点u的剖分以后的新编号（即dfs的执行顺序）
$w t [i d [u]]$	保存剖分以后的新编号对应结点u的值

算法实现

例题1 洛谷 P3384 【模板】树链剖分

这是一道树链剖分的模板题。我们以此题为例，来讲解树链剖分的预处理和前 $4$ 个操作。

首先，第 $1$ 遍 $d f s$ ，对于一个节点 $u$ 我们首先求出它所在的子树大小 $s i z e [u]$ ，找到它的重儿子 $s o n [u]$ ，并同时处理处它的父亲节点 $f a [u]$ 和深度 $d e p [u]$ 。如果一个点的多个儿子所在子树大小相等且最大,那随便找一个当做它的重儿子即可。叶节点没有重儿子，非叶节点有且只有一个重儿子。

第 $1$ 遍 $d f s$ 的代码实现如下：

void dfs1(int u)
{
	size[u]=1;
	int maxson=-1;
	for(int i=head[u];~i;i=edge[i].next)
	{
		if(edge[i].v==fa[u]) continue;
		fa[edge[i].v]=u;
		dep[edge[i].v]=dep[u]+1;
		dfs1(edge[i].v);
		size[u]+=size[edge[i].v];
		if(size[edge[i].v]>maxson) maxson=size[edge[i].v],son[u]=edge[i].v;
	}
}

接着，第 $2$ 遍 $d f s$ ，ž根节点为起点，向下拓展构建重链（即维护出每个节点 $u$ 所在链的顶端节点 $t o p [u]$ ），选择重儿子继承当前重链，对于轻节点，都以该节点为起点向下重新拉一条重链。同时给每个结点分配一个位置编号，即标记每一个节点的 $d f s$ 序，这样每条重链就相当于一段区间，那么我们就可以用数据结构来维护这些重链。

第 $2$ 遍 $d f s$ 的代码实现如下：

void dfs2(int u,int topf)
{
	id[u]=++cnt; wt[id[u]]=a[u]; top[u]=topf;
	if(!son[u]) return;
	dfs2(son[u],topf);
	for(int i=head[u];~i;i=edge[i].next)
	{
		if(edge[i].v==son[u]) continue;
		if(edge[i].v==fa[u]) continue;
		dfs2(edge[i].v,edge[i].v);
	}
}

链上的修改和查询操作原理是类似的。以查询操作为例，其实就是个 $L C A$ ，不过这里使用了 $t o p$ 来进行加速，因为 $t o p$ 可以直接跳转到该重链的起始结点（轻链没有起始结点之说，他们的top就是自己）。需要注意的是，每次循环只能跳一次，并且让所在重链的起始结点深的那个节点 $u$ 来跳到 $t o p$ 的父亲节点位置（即 $f a [t o p [u]]$ ），避免两个一起跳从而插肩而过。当两个节点的 $t o p$ 相同时，结束循环，并修改或查询节点 $u$ 到节点 $v$ 的链。

链上修改的代码实现如下：

void addRange(int u,int v,int k)
{
	k%=mod;
	while(top[u]!=top[v])
	{
		if(dep[top[u]]<dep[top[v]]) u^=v^=u^=v;
		updata(id[top[u]],id[u],k,1,n,1);
		u=fa[top[u]];
	}
	if(dep[u]>dep[v]) u^=v^=u^=v;
	updata(id[u],id[v],k,1,n,1);
}

链上询问的代码实现如下：

int qRange(int u,int v)
{
	int ans=0;
	while(top[u]!=top[v])
	{
		if(dep[top[u]]<dep[top[v]]) u^=v^=u^=v;
		ans+=query(id[top[u]],id[u],1,n,1);
		ans%=mod;
		u=fa[top[u]];
	}
	if(dep[u]>dep[v]) u^=v^=u^=v;
	ans+=query(id[u],id[v],1,n,1);
	return ans%mod;
}

子树的修改和查询操作原理是也是类似的。由于我们记录了每个非叶子节点的子树大小(含它自己)，并且每个子树的新编号都是连续的。于是直查询或修改 $i d [u]$ 到 $i d [u] + s i z e [u] - 1$ 的区间即可。

子树的修改代码如下：

void addSon(int x,int k)
{
	k%=mod;
	updata(id[x],id[x]+size[x]-1,k,1,n,1);
}

子树的查询代码如下：

int qSon(int x)
{
	return query(id[x],id[x]+size[x]-1,1,n,1);
}

最终，本题代码如下：

#include <bits/stdc++.h>
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define ll long long
using namespace std;

const ll MAXN=100005;
ll n,m,cnt=0,s,mod;
ll a[MAXN],wt[MAXN];
ll size[MAXN],dep[MAXN],fa[MAXN],son[MAXN];
ll id[MAXN],top[MAXN];
ll mark[MAXN<<2],sum[MAXN<<2]; 

ll esize=0;
ll head[MAXN];
struct EDGE
{
	ll u;
	ll v;
	ll next;
}edge[MAXN<<1];

inline ll read()
{
    ll X=0,f=1; char ch=getchar();
    while(ch<'0'||ch>'9') {if(ch=='-') f=-1; ch=getchar();}
    while(ch>='0'&&ch<='9') {X=(X<<1)+(X<<3)+ch-'0'; ch=getchar();}
    return X*f;
}

inline void addedge(ll u,ll v)
{
	edge[esize].u=u;
	edge[esize].v=v;
	edge[esize].next=head[u];
	head[u]=esize++;
}

void buildtree(ll l,ll r,ll rt)
{
	if(l==r){sum[rt]=wt[l]; return;}
	ll mid=(l+r)>>1;
	buildtree(lson);
	buildtree(rson);
	sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}

void updata(ll L,ll R,ll k,ll l,ll r,ll rt)
{
	sum[rt]=(sum[rt]+(R-L+1)*k)%mod;
	if(L==l&&r==R) {mark[rt]=(mark[rt]+k)%mod; return;}
	ll mid=(l+r)>>1;
	if(R<=mid) updata(L,R,k,lson);
	else if(mid+1<=L) updata(L,R,k,rson);
	else updata(L,mid,k,lson),updata(mid+1,R,k,rson);
}

ll query(ll L,ll R,ll add,ll l,ll r,ll rt)
{
	if(L==l&&r==R) return (sum[rt]+(R-L+1)*add)%mod;
	ll mid=(l+r)>>1;
	if(R<=mid) return query(L,R,add+mark[rt],lson)%mod;
	if(mid+1<=L) return query(L,R,add+mark[rt],rson)%mod;
	return (query(L,mid,add+mark[rt],lson)+query(mid+1,R,add+mark[rt],rson))%mod;
}

void dfs1(ll u)
{
	size[u]=1;
	ll maxson=-1;
	for(ll i=head[u];~i;i=edge[i].next)
	{
		if(edge[i].v==fa[u]) continue;
		dep[edge[i].v]=dep[u]+1;
		fa[edge[i].v]=u;
		dfs1(edge[i].v);
		size[u]+=size[edge[i].v];
		if(size[edge[i].v]>maxson) maxson=size[edge[i].v],son[u]=edge[i].v;
	}
}

void dfs2(ll u,ll topf)
{
	id[u]=++cnt;
	wt[cnt]=a[u]%mod;
	top[u]=topf;
	if(!son[u]) return;
	dfs2(son[u],topf);
	for(ll i=head[u];~i;i=edge[i].next)
	{
		if(edge[i].v==fa[u]) continue;
		if(edge[i].v==son[u]) continue;
		dfs2(edge[i].v,edge[i].v);
	}
}

void addRange(ll u,ll v,ll k)
{
	k%=mod;
	while(top[u]!=top[v])
	{
		if(dep[top[u]]<dep[top[v]]) swap(u,v);
		updata(id[top[u]],id[u],k,1,n,1);
		u=fa[top[u]];
	}
	if(dep[u]>dep[v]) swap(u,v);
	updata(id[u],id[v],k,1,n,1);
}

ll qRange(ll u,ll v)
{
	ll ans=0;
	while(top[u]!=top[v])
	{
		if(dep[top[u]]<dep[top[v]]) swap(u,v);
		ans+=query(id[top[u]],id[u],0,1,n,1);
		ans%=mod;
		u=fa[top[u]];
	}
	if(dep[u]>dep[v]) swap(u,v);
	ans+=query(id[u],id[v],0,1,n,1);
	return ans%mod;
}

void addSon(ll x,ll k)
{
	k%=mod;
	updata(id[x],id[x]+size[x]-1,k,1,n,1);
}

ll qSon(ll x)
{
	return query(id[x],id[x]+size[x]-1,0,1,n,1);
}

void readdata()
{
	memset(head,-1,sizeof(head));
	n=read(); m=read(); s=read(); mod=read();
	for(ll i=1;i<=n;++i) a[i]=read();
	for(ll i=1;i<n;++i)
	{
		ll u=read(),v=read(); 
		addedge(u,v);
		addedge(v,u);
	}
}

void work()
{
	dfs1(s);
	dfs2(s,s);
	buildtree(1,n,1);
    for(ll i=1;i<=m;++i)
    {
        ll op=read();
        if(op==1)
        {
            ll u=read(),v=read(),k=read();
            addRange(u,v,k);
        }
        else if(op==2)
        {
            ll u=read(),v=read();
            printf("%d\n",qRange(u,v));
        }
        else if(op==3)
        {
            ll x=read(),k=read();
            addSon(x,k);
        }
        else if(op==4)
        {
            ll x=read();
            printf("%d\n",qSon(x));
        }
    }	
}

int main()
{
//	freopen("input.txt","r",stdin);
//	freopen("output.txt","w",stdout);
	readdata();
	work();
	return 0;
}

例题2 洛谷 P3979 遥远的国度

我们已经学会了链和子树的修改和查询。现在，就让我们以本题为例，来讲解树链剖分的换跟操作。

显然，换跟操作不会对链的修改和查询产生影响，只会对子树的修改和查询产生影响。记当前根为 $r t$ ，查询节点 $u$ ，换根无非三种情况；

当 $u = = r t$ ， $r e t u r n M i n [1]$ ；
$u$ 不是 $r t$ 的祖先，即 $u$ 不在 $1\rightarrow rt$ 这条路径上，无所谓，直接按 $u$ 为根的子树返回；
$u$ 是 $r t$ 的祖先，即 $u$ 在 $1\rightarrow rt$ 这条路径上，最特殊的情况，找到路径 $u\rightarrow rt$ 上的 $u$ 的直系儿子 $v$ ，就会发现 $r t$ 为根时, $u$ 子树覆盖不到的地方是 $v$ 及 $v$ 的子树。那么我们就可以把那一段抠出来，（因为子树的重儿子序一定是连续），之后计算剩余部分就可以了。

本题的代码实现如下：

#include <bits/stdc++.h>
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
using namespace std;

const int MAXN=1e5+5;
int n,m,cnt=0,root;
int fa[MAXN],son[MAXN],size[MAXN],dep[MAXN],top[MAXN];
int wt[MAXN],a[MAXN],id[MAXN];
int Min[MAXN<<2],lazy[MAXN<<2];

int esize=0;
int head[MAXN];
struct EDGE
{
	int u;
	int v;
	int next;
}edge[MAXN<<1];

inline int read()
{
	int X=0,f=1; char ch=getchar();
	while(ch<'0'||ch>'9') {if(ch=='-') f=0; ch=getchar();}
	while(ch>='0'&&ch<='9') {X=(X<<1)+(X<<3)+(ch^'0'); ch=getchar();}
	return X*f;
}

inline void addedge(int u,int v)
{
	edge[esize].u=u;
	edge[esize].v=v;
	edge[esize].next=head[u];
	head[u]=esize++;
}

void pushup(int rt)
{
	Min[rt]=min(Min[rt<<1],Min[rt<<1|1]);	
}

void pushdown(int rt)
{
	if(!lazy[rt]) return;
	lazy[rt<<1]=lazy[rt<<1|1]=lazy[rt];
	Min[rt<<1]=Min[rt<<1|1]=Min[rt];
	lazy[rt]=0;
}

void build(int l,int r,int rt)
{
	lazy[rt]=0;
	if(l==r) {Min[rt]=wt[l]; return;}
	int mid=(l+r)>>1;
	build(lson);
	build(rson);
	pushup(rt);
}

void updata(int L,int R,int k,int l,int r,int rt)
{
	if(L<=l&&r<=R)
	{
		lazy[rt]=Min[rt]=k;
		return;
	}
	pushdown(rt);
	int mid=(l+r)>>1;
	if(L<=mid) updata(L,R,k,lson);
	if(mid+1<=R) updata(L,R,k,rson);
	pushup(rt);
}

int query(int L,int R,int l,int r,int rt)
{
	if(L<=l&&r<=R) return Min[rt];
	pushdown(rt);
	int mid=(l+r)>>1,ans=INT_MAX;
	if(L<=mid) ans=min(ans,query(L,R,lson));
	if(mid+1<=R) ans=min(ans,query(L,R,rson));
	pushup(rt);	
	return ans;
}

void dfs1(int u)
{
	size[u]=1;
	int maxson=-1;
	for(int i=head[u];~i;i=edge[i].next)
	{
		if(edge[i].v==fa[u]) continue;
		fa[edge[i].v]=u;
		dep[edge[i].v]=dep[u]+1;
		dfs1(edge[i].v);
		size[u]+=size[edge[i].v];
		if(size[edge[i].v]>maxson) maxson=size[edge[i].v],son[u]=edge[i].v;
	}
}

void dfs2(int u,int topf)
{
	id[u]=++cnt; wt[id[u]]=a[u]; top[u]=topf;
	if(!son[u]) return;
	dfs2(son[u],topf);
	for(int i=head[u];~i;i=edge[i].next)
	{
		if(edge[i].v==son[u]) continue;
		if(edge[i].v==fa[u]) continue;
		dfs2(edge[i].v,edge[i].v);
	}
}

void change(int u,int v,int k)
{
	while(top[u]!=top[v])
	{
		if(dep[top[u]]<dep[top[v]]) swap(u,v);
		updata(id[top[u]],id[u],k,1,n,1);
		u=fa[top[u]];
	}
	if(dep[u]>dep[v]) swap(u,v);
	updata(id[u],id[v],k,1,n,1);
}

int find(int u)
{
	if(u==root) return -1;
	if(id[u]>=id[root]||id[u]+size[u]-1<id[root]) return 0;
	int cur=root;
	while(top[cur]!=top[u])
	{
		if(fa[top[cur]]==u) return top[cur];
		cur=fa[top[cur]];
	}	
	return son[u];
}

int qtree(int u)
{
	int op=find(u);
	if(op==-1) return Min[1];
	if(op==0) return query(id[u],id[u]+size[u]-1,1,n,1);
	else
	{
		int ans=query(1,id[op]-1,1,n,1);
		if(id[op]+size[op]-1!=n) ans=min(ans,query(id[op]+size[op],n,1,n,1));
		return ans;
	}
}

void readdata()
{
	memset(head,-1,sizeof(head));
	n=read(); m=read();
	for(int i=1;i<n;++i)
	{
		int u=read(),v=read();
		addedge(u,v);
		addedge(v,u);
	}
	for(int i=1;i<=n;++i) a[i]=read();
	root=read();	
}

void work()
{
	dfs1(1);
	dfs2(1,1);
	build(1,n,1);
	for(int i=1;i<=m;++i)
	{
		int op=read();
		if(op==1) root=read();
		else if(op==2) {int u=read(),v=read(),k=read(); change(u,v,k);}
		else if(op==3) {int x=read(); printf("%d\n",qtree(x));}
	}
}

int main()
{
//	freopen("input.txt","r",stdin);
	readdata();
	work();
	return 0;
}

「已注销」

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
专题树链剖分保证你看不懂

文章目录算法简介算法实现基本概念变量声明算法实现算法简介树链剖分，指一种对树进行划分，先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组，线段树等）来维护每一条链。它通常可以解决以下几个操作：修改路径权值：给定两个节点，修改这两个节点间路径上的节点权值。修改子树权值：给定一个节点，将修改以该节点为根的子树内的节点权值。询问路径：询问某条路径上节点...
复制链接

扫一扫