傳送門

解析：

其實用 $DFS$序可以將很多樹剖能做的東西的複雜度優化一個 $\log$

顯然這道題直接用樹剖做是 $O($

思路;

對於不同修改對每個詢問的影響我們分開統計，所以其實就是兩種問題

1.單點加，鏈求和

首先用差分的思想可以將路徑求和變為點到根的路徑求和，就是鏈求和。

考慮什麼樣的修改對什麼樣的詢問有貢獻。

一個修改 $(u,W)$（即將節點 $u$的權值加上 $W$）對詢問 $v$有貢獻，當且僅當 $v$在 $u$的子樹中，且貢獻為 $W$。

所以一個單點修改我們可以轉化為子樹加，鏈求和轉化為在鏈的底端單點求和，這樣 $DFS$序就可以做了。

2.子樹加，鏈求和

首先還是差分一下，求點到根的路徑和。

一個修改 $(u,W)$對詢問 $v$有貢獻，當且僅當 $v$在 $u$的子樹中，且貢獻為 $W\times (dep_v-dep_u+1)$。拆開變成 $W\times(dep_v+1)-W\times dep_u$。

發現後面的 $W\times dep_u$實際上不會隨著 $v$的改變而改變的，也就是說，子樹內每個點都會接受這個貢獻，直接子樹加，單點詢問，和操作1的樹狀陣列可以共用。

而前面的 $W\times(dep_v+1)$，實際上不變的只有 $W$，所以我們需要另外開一棵樹狀陣列，記錄每個點接受了多少 $W$，詢問的時候單獨 $×(dep_v+1)$。

於是這道題就在 $O(n\log n)$的時間內完美解決了。

程式碼：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define gc getchar
#define pc putchar
#define cs const
#define int ll

inline int getint(){
	re int num;
	re char c;
	re bool f=0;
	while(!isdigit(c=gc()))if(c=='-')f=1;num=c^48;
	while(isdigit(c=gc()))num=(num<<1)+(num<<3)+(c^48);
	return f?-num:num;
}

inline void outint(ll a){
	static char ch[23];
	if(a==0)pc('0');
	if(a<0)pc('-'),a=-a;
	while(a)ch[++ch[0]]=a-a/10*10,a/=10;
	while(ch[0])pc(ch[ch[0]--]^48);
}

cs int N=1000006;
vector<int> edge[N];
inline void addedge(int u,int v){
	edge[u].push_back(v);
	edge[v].push_back(u);
}
struct BIT{
	ll val[N];
	inline int lowbit(int x){return x&-x;}
	inline void add(int pos,ll v){for(;pos<N;pos+=lowbit(pos))val[pos]+=v;}
	inline ll query(int pos){ll res=0;for(;pos;pos-=lowbit(pos))res+=val[pos];return res;}
	inline void add(int l,int r,ll v){add(l,v);add(r+1,-v);}
}b0,b1;

int n,m,root;
int fa[N],dep[N],siz[N],son[N],top[N],val[N],in[N],tot,pos[N],out[N];
inline void dfs1(int u){
	siz[u]=1;
	for(int re e=0;e<edge[u].size();++e){
		int re v=edge[u][e];
		if(v==fa[u])continue;
		fa[v]=u;
		dep[v]=dep[u]+1;
		dfs1(v);
		siz[u]+=siz[v];
		if(siz[v]>siz[son[u]])son[u]=v;
	}
}

inline void dfs2(int u){
	pos[in[u]=++tot]=u;
	if(son[u]){
		top[son[u]]=top[u];
		val[son[u]]+=val[u];
		dfs2(son[u]);
	} 
	for(int re e=0;e<edge[u].size();++e){
		int re v=edge[u][e];
		if(v==fa[u]||v==son[u])continue;
		top[v]=v;
		val[v]+=val[u];
		dfs2(v);
	}
	out[u]=tot;
}

inline void tree_dissection(){
	dep[root]=1;
	dfs1(root);
	top[root]=root;
	dfs2(root);
}

inline int LCA(int u,int v){
	while(top[u]!=top[v]){
		if(dep[top[u]]>dep[top[v]])swap(u,v);
		v=fa[top[v]];
	}
	return dep[u]>dep[v]?v:u;
}

inline ll query(int a){
	if(a==0)return 0;
	return val[a]+b0.query(in[a])+b1.query(in[a])*(dep[a]+1);
}

signed main(){
	n=getint();
	m=getint();
	root=getint();
	for(int re i=1;i<=n;++i)val[i]=getint();
	for(int re i=1;i<n;++i){
		int u=getint(),v=getint();
		addedge(u,v);
	}
	tree_dissection();
	while(m--){
		int op=getint(),a=getint(),b=getint();
		switch(op){
			case 1:{
				b0.add(in[a],out[a],b);
				break;
			}
			case 2:{
				b1.add(in[a],out[a],b);
				b0.add(in[a],out[a],-1ll*b*(dep[a]));
				break;
			}
			case 3:{
				int lca=LCA(a,b);
				outint(query(a)+query(b)-query(lca)-query(fa[lca]));pc('\n');
				break;
			}
		}
	}
	return 0;
}