Luogu P3384 【模板】树链剖分

最新推荐文章于 2025-09-22 23:15:58 发布

原创最新推荐文章于 2025-09-22 23:15:58 发布 · 201 阅读

0 ·

CC 4.0 BY-SA版权

模板同时被 2 个专栏收录

12 篇文章

订阅专栏

树链剖分

3 篇文章

订阅专栏

本文深入解析树剖算法，一种高效处理树形结构数据的算法，尤其适用于处理树上路径和子树的操作。通过实例讲解如何将树转化为一系列序列进行高效处理，包括树剖的原理、关键概念和具体实现步骤。

https://www.luogu.org/problemnew/show/P3384

~~从暑假前拖到现在，菜鸡总算自己独立地写出了树剖了（多菜）~~

题目描述

如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作：

操作1：格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z

操作2：格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和

操作3：格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z

操作4：格式： 4 x 表示求以x为根节点的子树内所有节点值之和

输入输出格式

输入格式：

第一行包含4个正整数N、M、R、P，分别表示树的结点个数、操作个数、根节点序号和取模数（即所有的输出结果均对此取模）。

接下来一行包含N个非负整数，分别依次表示各个节点上初始的数值。

接下来N-1行每行包含两个整数x、y，表示点x和点y之间连有一条边（保证无环且连通）

接下来M行每行包含若干个正整数，每行表示一个操作，格式如下：

操作1： 1 x y z

操作2： 2 x y

操作3： 3 x z

操作4： 4 x

输出格式：

输出包含若干行，分别依次表示每个操作2或操作4所得的结果（对P取模）

输入输出样例

输入样例#1： 复制

输出样例#1： 复制

2
21

说明

时空限制：1s，128M

数据规模：

对于30%的数据： N \leq 10, M \leq 10N≤10,M≤10

对于70%的数据： N \leq {10}^3, M \leq {10}^3N≤103,M≤103

对于100%的数据： N \leq {10}^5, M \leq {10}^5N≤105,M≤105

（其实，纯随机生成的树LCA+暴力是能过的，可是，你觉得可能是纯随机的么233 ）

样例说明：

树的结构如下：

各个操作如下：

故输出应依次为2、21(重要的事情说三遍：记得取模)

其实这只涉及了两个知识点：前向星（~~暑假前还不会~~），线段树

树剖就是根据重链把一棵树硬生生变成一堆序列，然后各种高级的数据结构强上的一种“算法”

后面就是各种数据结构，没什么好说的，（~~不会线段树，树状数组的当我没说~~）

精髓就是前面的根据重链把树硬生生剖开来

慨念：重儿子：比较胖的儿子（以节点为根个数最多）

轻儿子：除了胖儿子外所有的儿子（~~所以说还是胖胖的好，更被重视~~）

重链：节点到重儿子的边

轻链：同重链

蓝书上还有各种有关树链性质的介绍和证明（~~说实话码风是真的臭~~）

那些性质可以证明该算法时间是O(n lg n lg n)（~~菜鸡会，但懒得写~~）

剖分用两边dfs实现

求出数组：dad（父亲），dep（深度），siz（胖的程度，子树大小），son（重儿子）

id（映射在数据结构上的编号），top（链的顶部）

#include<cstdio>
#include<iostream>
#define ll long long
using namespace std;

int read()
{
	int ret=0;  bool f=0;
	char ch=getchar();
	while(ch<'0'||ch>'9') 
	{
		if(ch=='-') f=1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
		ret=(ret<<1)+(ret<<3)+ch-'0',ch=getchar();
	return f?-ret:ret;
}

const int N=1e6+5;
int n,m,r,mo,a[N],b[N];
int cnt,he[N],to[N],nxt[N];
int tot,dad[N],dep[N],siz[N],son[N],id[N],top[N];

inline int get(int x)
{
	return x>=mo?x-mo:x;
}

inline void add(int u,int v)
{
	to[++cnt]=v,nxt[cnt]=he[u],he[u]=cnt;
}

void dfs1(int fa,int u)  //求出dad,dep,siz,son
{
	dad[u]=fa; dep[u]=dep[fa]+1; siz[u]=1;
	int mx=0;
	for(int e=he[u];e;e=nxt[e])
	{
		int v=to[e];
		if(v!=fa) 
		{
			dfs1(u,v),siz[u]+=siz[v];
			if(mx<siz[v]) son[u]=v,mx=siz[v];
		}
	}
}

void dfs2(int fa,int u,int t) //求出top,id
{
	id[u]=++tot;
	top[u]=t;
	if(!son[u]) return;
	dfs2(u,son[u],t);
	for(int e=he[u];e;e=nxt[e])
	{
		int v=to[e];
		if(v!=fa&&v!=son[u]) dfs2(u,v,v);
	}
}

struct NA1    //线段树模板
{
	ll c[N],t[N];
	
	inline void up(int p)
	{
		c[p]=get(c[p<<1]+c[p<<1|1]);	
	}
	
	inline void down(int p,int l,int r,int mid)
	{
		if(l!=r)
		{
			t[p<<1]=get(t[p]+t[p<<1]);
			c[p<<1]=get(c[p<<1]+t[p]*(mid-l+1)%mo);
			t[p<<1|1]=get(t[p]+t[p<<1|1]);
			c[p<<1|1]=get(c[p<<1|1]+t[p]*(r-mid)%mo);
		}
		t[p]=0;
	}
	
	void build(int p,int l,int r)
	{
		if(l==r)
		{
			c[p]=b[l]; return; 
		}
		int mid=l+r>>1;
		build(p<<1,l,mid);
		build(p<<1|1,mid+1,r);
		up(p);
	}
	
	void add(int p,int l,int r,int x,int y,ll k)
	{
		if(l==x&&r==y)
		{
			t[p]=get(t[p]+k);
			c[p]=get(k*(r-l+1)%mo+c[p]); 
			return;
		}
		int mid=(l+r)>>1;
		down(p,l,r,mid);
		if(mid>=y) add(p<<1,l,mid,x,y,k);
			else if(mid<x) add(p<<1|1,mid+1,r,x,y,k);
				else add(p<<1,l,mid,x,mid,k),
					 add(p<<1|1,mid+1,r,mid+1,y,k);
		up(p);
	}
	
	int sum(int p,int l,int r,int x,int y)
	{
		if(l==x&&r==y) return c[p];
		int mid=l+r>>1;
		down(p,l,r,mid);
		if(mid>=y) return sum(p<<1,l,mid,x,y);
			else if(mid<x) return sum(p<<1|1,mid+1,r,x,y);
				else return get(sum(p<<1,l,mid,x,mid)+sum(p<<1|1,mid+1,r,mid+1,y)); 
	}
	
}tree;

void add1(int u,int v,int k)  
{
	while(top[u]!=top[v])
	{
		if(dep[top[u]]>dep[top[v]]) swap(u,v);
		tree.add(1,1,n,id[top[v]],id[v],k);
		v=dad[top[v]];
	}
	if(id[u]>id[v]) swap(u,v);
	tree.add(1,1,n,id[u],id[v],k);
}

int sum(int u,int v)
{
	int ret=0;
	while(top[u]!=top[v])
	{
		if(dep[top[u]]>dep[top[v]]) swap(u,v);
		ret=get(ret+tree.sum(1,1,n,id[top[v]],id[v]));
		v=dad[top[v]];
	}
	if(id[u]>id[v]) swap(u,v);
	ret=get(ret+tree.sum(1,1,n,id[u],id[v]));
	return ret;
}

int main()
{
	n=read(),m=read(),r=read(),mo=read();
	for(int i=1;i<=n;i++) a[i]=read()%mo;
	for(int i=1;i<n;i++) 
	{
		int u=read(),v=read(); 
		add(u,v),add(v,u);
	}
	dfs1(0,r); 
	dfs2(0,r,0);
	for(int i=1;i<=n;i++) b[id[i]]=a[i];
	tree.build(1,1,n);
	while(m--)
	{
		int t=read();
		if(t==1)
		{
			int x=read(),y=read(),z=read()%mo;
			add1(x,y,z);
		}else 
			if(t==2)
			{
				int x=read(),y=read();
				printf("%d\n",sum(x,y));
			}else
				if(t==3)
				{
					int x=read(),y=read()%mo;
					tree.add(1,1,n,id[x],id[x]+siz[x]-1,y);
				}else
				{
					int x=read();
					printf("%d\n",tree.sum(1,1,n,id[x],id[x]+siz[x]-1));
				}
	}
	return 0;
}