「洛谷P3384」树链剖分

题目描述

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

• 操作$1$： 格式： $1xyz$ 表示将树从x到y结点最短路径上所有节点的值都加上z
• 操作$2$： 格式： $2xy$ 表示求树从x到y结点最短路径上所有节点的值之和
• 操作$3$： 格式： $3xz$ 表示将以x为根节点的子树内所有节点值都加上z
• 操作$4$： 格式： $4x$ 表示求以x为根节点的子树内所有节点值之和

输入格式：

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

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

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

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

操作$1：1xyz$

操作$2：2xy$

操作$3：3xz$

操作$4：4x$

输出格式：

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

输入输出样例

输入样例#1：

5 5 2 24
7 3 7 8 0 
1 2
1 5
3 1
4 1
3 4 2
3 2 2
4 5
1 5 1 3
2 1 3

输出样例#1：

2
21

说明

时空限制：1s，128M
数据规模：$N,M<=10^5$

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

样例说明：

树的结构如下：

各个操作如下：

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

题意：

• 中文提就不用说题意了233

题解：树链剖分

• 众所周知剖出来的链用线段树维护就能实现树上两点之间点权修改，（如果没学过的话这里也丢一个链接：传送门）其实对于整个以某个节点为根节点的子树也是可以用树剖的DFS序完成更新的，因为这颗子树的$id$一定连续，放一张网上的树剖通用图，你大概就懂了：
  

附上代码（树剖模版）：

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=2e5+10;

vector<int> vec[maxn];
ll a[maxn],mod,l;
int n,m,roo,u,v,opt;
int h[maxn],fa[maxn],top[maxn],id[maxn],son[maxn],siz[maxn],rk[maxn],tot;
struct node{
	int l,r;ll sum,mark;
}tree[maxn<<2];

struct segment_tree{
	void build(int le,int ri,int id){
		tree[id].l=le,tree[id].r=ri;
		if(le==ri) {
			tree[id].sum=a[rk[le]]%mod;
			return;
		}
		int mid=(le+ri)>>1;
		build(le,mid,id<<1);
		build(mid+1,ri,id<<1|1);

		pushup(id);
	}

	void pushup(int id){
		tree[id].sum=(tree[id<<1].sum+tree[id<<1|1].sum)%mod;
	}

	void down(int id){
		tree[id<<1].mark=(tree[id<<1].mark+tree[id].mark)%mod;
		tree[id<<1|1].mark=(tree[id<<1|1].mark+tree[id].mark)%mod;
		tree[id<<1].sum=(tree[id<<1].sum+len(id<<1)*tree[id].mark)%mod;
		tree[id<<1|1].sum=(tree[id<<1|1].sum+len(id<<1|1)*tree[id].mark)%mod;
		tree[id].mark=0;
	}

	int len(int id){
		return tree[id].r-tree[id].l+1;
	}

	void update(int l,int r,int id,ll add){
		if(l<=tree[id].l&&r>=tree[id].r){
			tree[id].mark=(tree[id].mark+add)%mod;
			tree[id].sum=(tree[id].sum+add*len(id)%mod)%mod;
			return;
		}
		if(tree[id].mark) down(id);
		int mid=(tree[id].l+tree[id].r)>>1;
		if(l<=mid) update(l,r,id<<1,add);
		if(r>mid) update(l,r,id<<1|1,add);
		pushup(id);
	}

	ll query(int l,int r,int id){
		ll ans=0;
		if(l<=tree[id].l&&r>=tree[id].r) return tree[id].sum;

		if(tree[id].mark) down(id);
		int mid=(tree[id].l+tree[id].r)>>1;
		if(l<=mid) ans=(ans+query(l,r,id<<1))%mod;
		if(r>mid) ans=(ans+query(l,r,id<<1|1))%mod;

		pushup(id);
		return ans;
	}
}data;

struct tree{
	tree(){
		tot=0;
		memset(son,0,sizeof(son));
		memset(h,0,sizeof(h));
	}

	void build(){
		dfs1(roo,0,1);dfs2(roo,roo);
		data.build(1,n,1);
	}

	void dfs1(int cur,int fath,int he){ //dfs(root,0,1)
 		h[cur]=he;fa[cur]=fath;siz[cur]=1;
 		for(int i=0;i<vec[cur].size();i++){
 			if(vec[cur][i]!=fath){
 				dfs1(vec[cur][i],cur,he+1);
 				siz[cur]+=siz[vec[cur][i]];
 				if(siz[vec[cur][i]]>siz[son[cur]]) son[cur]=vec[cur][i];
 			}
		}
	}


	void dfs2(int cur,int topp){ //dfs2(root,root)
		id[cur]=++tot;
		rk[tot]=cur;
		top[cur]=topp;
		if(son[cur]) dfs2(son[cur],topp);
		for(int i=0;i<vec[cur].size();i++){
			if(vec[cur][i]!=fa[cur]&&vec[cur][i]!=son[cur]){
				dfs2(vec[cur][i],vec[cur][i]);
			}
		}
	}

	ll sum(int x,int y){
		int topx=top[x],topy=top[y];ll ans=0;
		while(topx!=topy){
			if(h[topx]>=h[topy]){
				ans=(ans+data.query(id[topx],id[x],1))%mod;
				x=fa[topx],topx=top[x];
			}else{
				ans=(ans+data.query(id[topy],id[y],1))%mod;
				y=fa[topy],topy=top[y];
			}
		}
		ans=(ans+data.query(min(id[x],id[y]),max(id[x],id[y]),1))%mod;
		return ans;
	}

	void update(int x,int y,ll add){
		int topx=top[x],topy=top[y];
		while(topx!=topy){
			if(h[topx]>=h[topy]){
				data.update(id[topx],id[x],1,add);
				x=fa[topx],topx=top[x];
			}else{
				data.update(id[topy],id[y],1,add);
				y=fa[topy],topy=top[y];
			}
		}
		data.update(min(id[x],id[y]),max(id[x],id[y]),1,add);
	}
	void update_son_tree(int x,ll add){
		data.update(id[x],id[x]+siz[x]-1,1,add);
	}

	ll query_son_tree(int u){
		return data.query(id[u],id[u]+siz[u]-1,1);
	}
}chain;



int main()
{
	scanf("%d %d %d %lld",&n,&m,&roo,&mod);
	for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
	for(int i=1;i<n;i++){
		scanf("%d %d",&u,&v);
		vec[u].push_back(v);
		vec[v].push_back(u);
	}

	chain.build();

	for(int i=1;i<=m;i++){
		scanf("%d",&opt);
		if(opt==1) {
			scanf("%d %d %lld",&u,&v,&l);
			chain.update(u,v,l);
		}else if(opt==2){
			scanf("%d %d",&u,&v);
			printf("%lld\n",chain.sum(u,v));
		}else if(opt==3){
			scanf("%d %lld",&u,&l);
			chain.update_son_tree(u,l);
		}else{
			scanf("%d",&u);
			printf("%lld\n",chain.query_son_tree(u));
		}
	}
}