【树链剖分】【模板】洛谷3384

题目描述
如题，已知一棵包含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取模）

 上上周末和ZWR，QZZ他们打南昌邀请赛的网络赛的时候，出现了一道用树链剖分的题，当时我和QZZ都没打过树链剖分，ZWR打过但似乎并不是很熟练。幸运的是后来想到了一种用树状数组完全离线的办法，把题从ZWR手里抢走了（感觉有点不太绅士hh）。
 之前总以为，ACM不会考这类数据结构，事实证明我错了。后来春训的时候再次考了树链剖分（就是洛谷2146），这次就没那么幸运了，非树剖的解法有是有，但异常麻烦。因此好好掌握数据结构还是很必要的。
 话不多说，看这道模板题。首先，树链剖分要解决的就是这种树的路径的修改和查询（主要就是因为修改，否则LCA倍增就可以搞定了）。那么子树的修改怎么办呢？事实上，大多数树链剖分的板子不是把每条链分开来建立线段树，而是求出了按照重边优先的原则构建dfs序，使得每棵树链的线段树树对应一棵大大的线段树的不同区间，这样效率稍微慢一些，但是非常方便，而且有dfs序的话，子树也会对应一个连续线段。这样的话子树的修改和查询也就不成问题了。
 感觉树剖还是很简单的，原理和细节百度一大把，这里不详细叙述，只是记录模板。

树链剖分（洛谷3384）

#include
#include
#define kl (k<<1)
#define kr (k<<1|1)
#define M (L+R>>1)
#define lin L,M
#define rin M+1,R
using namespace std;
using LL=long long;

const int maxn=1E5+10;

struct node
{
	int val,add;
}T[1<<18];

int sz[maxn],top[maxn],son[maxn],dep[maxn],fa[maxn],dfn[maxn],rdfn[maxn],dfs_clock;
int n,m,r,mo,o,val[maxn];
vector<int> E[maxn];

void build_tree(int k, int L, int R)
{
	if(L==R)
	{
		T[k].val=val[rdfn[L]];
		T[k].add=0;
		return ;
	}
	build_tree(kl,lin);
	build_tree(kr,rin);
	T[k].val=(T[kl].val+T[kr].val)%mo;
	T[k].add=0;
}

int query(int k, int L, int R, int l, int r, int tmp)
{
	if(l<=L&&R<=r)
		return (T[k].val+(LL)(tmp+T[k].add)*(R-L+1))%mo;
	int res=0;
	if(l<=M)
		res+=query(kl,lin,l,r,(tmp+T[k].add)%mo);
	if(r>M)
		res+=query(kr,rin,l,r,(tmp+T[k].add)%mo);
	return res%mo;
}

void modify(int k, int L, int R, int l, int r, int d)
{
	if(l<=L&&R<=r)
	{
		T[k].add=(T[k].add+d)%mo;
		return ;
	}
	if(l<=M)
		modify(kl,lin,l,r,d);
	if(r>M)
		modify(kr,rin,l,r,d);
	T[k].val=((T[kl].val+T[kr].val)%mo+((LL)T[kl].add*(M-L+1)+(LL)T[kr].add*(R-M))%mo)%mo;
}

void dfs1(int u, int f, int d)
{
	dep[u]=d,fa[u]=f,sz[u]=1;
	for(int &v:E[u])
		if(v!=f)
		{
			dfs1(v,u,d+1);
			sz[u]+=sz[v];
			if(!son[u]||sz[v]>sz[son[u]])
				son[u]=v;
		}
}

void dfs2(int u, int t)
{
	top[u]=t,dfn[u]=++dfs_clock;
	rdfn[dfs_clock]=u;
	if(!son[u])
		return ;
	dfs2(son[u],t);
	for(int &v:E[u])
		if(v!=son[u]&&v!=fa[u])
			dfs2(v,v);
}

int query_path(int x, int y)
{
	int ans=0,fx=top[x],fy=top[y];
	while(fx!=fy)
	{
		if(dep[fx]>=dep[fy])
			ans=(ans+query(1,1,n,dfn[fx],dfn[x],0))%mo,x=fa[fx];
		else
			ans=(ans+query(1,1,n,dfn[fy],dfn[y],0))%mo,y=fa[fy];
		fx=top[x],fy=top[y];
	}
	if(dfn[x]>dfn[y])
		swap(x,y);
	ans=(ans+query(1,1,n,dfn[x],dfn[y],0))%mo;
	return ans;
}

void modify_path(int x, int y, int z)
{
	int fx=top[x],fy=top[y];
	while(fx!=fy)
	{
		if(dep[fx]>dep[fy])
			modify(1,1,n,dfn[fx],dfn[x],z),x=fa[fx];
		else
			modify(1,1,n,dfn[fy],dfn[y],z),y=fa[fy];
		fx=top[x],fy=top[y];
	}
	if(dfn[x]>dfn[y])
		swap(x,y);
	modify(1,1,n,dfn[x],dfn[y],z);
}

int main()
{
	scanf("%d%d%d%d",&n,&m,&r,&mo);
	for(int i=1;i<=n;i++)
		scanf("%d",&val[i]);
	for(int i=1,x,y;i<n;i++)
		scanf("%d%d",&x,&y),E[x].push_back(y),E[y].push_back(x);
	dfs1(r,0,0);
	dfs2(r,r);
	build_tree(1,1,n);
	for(int i=1,x,y,z;i<=m;i++)
	{
		scanf("%d",&o);
		switch(o)
		{
			case 1:
				scanf("%d%d%d",&x,&y,&z);
				modify_path(x,y,z);
				break;
			case 2:
				scanf("%d%d",&x,&y);
				printf("%d\n",query_path(x,y));
				break;
			case 3:
				scanf("%d%d",&x,&z);
				modify(1,1,n,dfn[x],dfn[x]+sz[x]-1,z);
				break;
			default:
				scanf("%d",&x);
				printf("%d\n",query(1,1,n,dfn[x],dfn[x]+sz[x]-1,0));
		}
	}
	return 0;
}

 另外，春训的题解我这边也会慢慢更新，会加入自己的详细的理解，敬请期待。