洛谷 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： 复制
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

数据规模：

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

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

树剖裸题，我们可以通过树剖的性质而得：以X为根节点的子树，子树所有节点的在数据结构的序号值（第二次dfs时，所确定的点或边，在你要用的数据结构的序号），一定大于x，并且一颗树里的序号值连续，所以我们第二次dfs时，开一个maxxu数组记录一下：节点i的的子孙的最大序号值。

#include
#include
using namespace std;
int n; 
int ha;
const int maxn=4e5+50;
struct Tree
{
	int l;
	int r;
	int add;
	int sum;
}tr[maxn];
struct Edge
{
	int f;
	int to;
	int next;
}edge[maxn];

int tot=1;
int head[maxn];
void add_e(int f,int t)
{
	edge[tot].f=f;
	edge[tot].to=t;
	edge[tot].next=head[f];
	head[f]=tot;
	tot++;
}

int deep[maxn];
int fa[maxn];
int son[maxn];
int siz[maxn];
void dfs1(int f,int t)
{
	deep[t]=deep[f]+1;
	fa[t]=f;
	for(int i=t[head];i;i=edge[i].next)
	{
		Edge e=edge[i];
		if(!deep[e.to])
		{
			dfs1(t,e.to);
			if(siz[e.to]>siz[t[son]])
			{
				t[son]=e.to;
			}
		}
	}
	siz[f]+=siz[t];
}
int top[maxn];
int xdscnt;
int pos[maxn];
int maxxv[maxn];
void dfs2(int topp,int t)
{
	top[t]=topp;
	pos[t]=++xdscnt;
	maxxv[t]=xdscnt;
	if(t[son])
	{
		dfs2(topp,t[son]);
		maxxv[t]=max(maxxv[t],maxxv[t[son]]);
	}
	for(int i=t[head];i;i=edge[i].next)
	{
		Edge e=edge[i];
		if(deep[e.to]>deep[t]&&e.to!=t[son])
		{
			dfs2(e.to,e.to);
			maxxv[t]=max(maxxv[t],maxxv[e.to]);
		}
	}
}
//chushihua
void up(int x)
{
	tr[x].sum=(tr[x<<1].sum%ha+tr[x<<1|1].sum%ha)%ha;
}
void buff(int x)
{
	if(tr[x].add)
	{
		tr[x<<1|1].sum+=(((tr[x<<1|1].r-tr[x<<1|1].l+1)%ha)*tr[x].add%ha)%ha;
		tr[x<<1|1].sum%=ha;
		tr[x<<1].sum+=(((tr[x<<1].r-tr[x<<1].l+1)%ha)*tr[x].add%ha)%ha;
		tr[x<<1].sum%=ha;
	
		
		tr[x<<1|1].add+=tr[x].add%ha;
		tr[x<<1|1].add%=ha;
		tr[x<<1].add+=tr[x].add%ha;
		tr[x<<1].add%=ha;
		tr[x].add=0;
	}
}
void expand(int l,int r,int x)
{
	tr[x].l=l,tr[x].r=r;
	if(l==r)
		return;
	int mid=(l+r)>>1;
	expand(l,mid,x<<1);
	expand(mid+1,r,x<<1|1);
}
void add_v(int l,int r,int x,int v)
{
	buff(x); 
	if(l<=tr[x].l&&tr[x].r<=r)
	{
		tr[x].add+=v%ha;
		tr[x].add%=ha;
		tr[x].sum+=(v%ha*(tr[x].r-tr[x].l+1)%ha)%ha;
		tr[x].sum%=ha;
		return;
	} 
	int mid=(tr[x].l+tr[x].r)>>1;
	if(l<=mid)
		add_v(l,r,x<<1,v);
	if(mid+1<=r)
		add_v(l,r,x<<1|1,v);
	up(x);

}
void poi_change(int pos,int x,int v)
{
	buff(x); 
	if(tr[x].l==tr[x].r)
	{
		tr[x].sum=v%ha;
		return;
	} 
	int mid=(tr[x].l+tr[x].r)>>1;
	if(pos<=mid)
		poi_change(pos,x<<1,v);
	if(mid+1<=pos)
		poi_change(pos,x<<1|1,v);
	up(x);
}
int ask_sum(int l,int r,int x)
{
	int ans=0;
	buff(x); 
	if(l<=tr[x].l&&tr[x].r<=r)
	{
		return tr[x].sum%ha;
	} 
	int mid=(tr[x].l+tr[x].r)>>1;
	if(l<=mid)
		ans+=ask_sum(l,r,x<<1)%ha,ans%=ha;
	if(mid+1<=r)
		ans+=ask_sum(l,r,x<<1|1)%ha,ans%=ha;
	up(x);
	return ans%ha;
}
//xianduanshu 
void lca_add(int x,int y,int v)
{
	while(top[x]!=top[y])
	{
		if(deep[top[x]]