從暑假前拖到現在，菜雞總算自己獨立地寫出了樹剖了（多菜）

題目描述

如題，已知一棵包含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 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;
}