2018.11.06【LOJ147】DFS序4（DFS序）（树状数组）

传送门

---

解析：

其实用$DFS$序可以将很多树剖能做的东西的复杂度优化一个$\log$，不过需要一点小小的转化，因为$DFS$序只能处理子树问题。

显然这道题直接用树剖做是$O(n{\log }^{2}n)$的，但是用纯粹的$DFS$序+树状数组可以做到$O(n\log n)$。

思路;

对于不同修改对每个询问的影响我们分开统计，所以其实就是两种问题

1.单点加，链求和

首先用差分的思想可以将路径求和变为点到根的路径求和，就是链求和。

考虑什么样的修改对什么样的询问有贡献。

一个修改$(u,W)$（即将节点$u$的权值加上$W$）对询问$v$有贡献，当且仅当$v$在$u$的子树中，且贡献为$W$。

所以一个单点修改我们可以转化为子树加，链求和转化为在链的底端单点求和，这样$DFS$序就可以做了。

2.子树加，链求和

首先还是差分一下，求点到根的路径和。

一个修改$(u,W)$对询问$v$有贡献，当且仅当$v$在$u$的子树中，且贡献为$W\times (de{p}_v-de{p}_u+1)$。拆开变成$W\times (de{p}_v+1)-W\times de{p}_u$。

发现后面的$W\times de{p}_u$实际上不会随着$v$的改变而改变的，也就是说，子树内每个点都会接受这个贡献，直接子树加，单点询问，和操作1的树状数组可以共用。

而前面的$W\times (de{p}_v+1)$，实际上不变的只有$W$，所以我们需要另外开一棵树状数组，记录每个点接受了多少$W$，询问的时候单独$\times (de{p}_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;
}