2018.09.30【ZJOI2008】【BZOJ1036】【洛谷P2590】树的统计（树链剖分）（线段树）

BZOJ传送门

洛谷传送门

---

解析:

好久没写过这么长的题了。。。（虽然说本来可以几个函数封装在一起的）
这大概是我碰树链剖分的第一道题吧，上一次写这道题是很久之前了，现在开了博客再写一遍。

深刻理解树链剖分后再回头看，发现这真是一道简单的好题。

想写长链剖分的童鞋请自重，毕竟那复杂度是要看运气的。

这道题一般的做法是轻重链剖分加线段树。（当然还有树分块） 树分块的题解我会在以后更新，复杂度没有轻重链剖分优秀但是值得了解。

思路：

回到轻重链剖分。

刚才说了轻重链剖分深刻理解后这就是一道简单的好题。

那么轻重链剖分的资料请自行百度，这篇博客主要讲思想在这里的深刻体现。

这里要询问路径和，路径最大值，那么我们可以把它转化成区间问题，就可以开心地使用线段树这个利器了。这就需要将树形结构转化成线性结构。首先我们有$dfs$序这件利器，但是这里$dfs$序明显不好维护，而且复杂度也不稳定。

那么我们可以采用轻重链剖分将大量的节点维护在线段树的同一区间，保证询问不会断成太多区间。我们可以感性理解一下：我们任选一条树上路径，其中某个点落在根的那个子树里面概率最大？显然是最大的子树。

其实轻重链的思想就一句话，维护大量，暴力少量。

我们将重链上的节点在线段树置于同一区间后，我们对每条路径的询问就能够被斩断成几条路径，并且全部都是重链维护，不会超过$lo{g}_{2}n$条复杂度能够保证。

而斩断成链的操作在代码里面有具体的体现，我采用的是递归处理。也可以不用递归写。

---

代码：

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

inline
int getint(){
	re int num;
	re char c;
	re bool f=0;
	while(!isdigit(c=gc()))f^=c=='-';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);
}

inline
char getalpha(){
	re char c;
	while(!isalpha(c=gc()));
	return c;
}

cs int N=30005;
int n,q;
int last[N],nxt[N<<1],to[N<<1],ecnt;
inline
void addedge(int u,int v){
	nxt[++ecnt]=last[u],last[u]=ecnt,to[ecnt]=v;
	nxt[++ecnt]=last[v],last[v]=ecnt,to[ecnt]=u;
}

int son[N],siz[N],fa[N],top[N],dep[N];
int pos[N],in[N],tot;
int val[N];
inline
void dfs1(int u){
	siz[u]=1;
	for(int re e=last[u],v=to[e];e;v=to[e=nxt[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];
		dfs2(son[u]);
	}
	for(int re e=last[u],v=to[e];e;v=to[e=nxt[e]]){
		if(v==son[u]||v==fa[u])continue;
		top[v]=v;
		dfs2(v);
	}
}

inline
void tree_dissection(){
	dfs1(1);
	tot=0;top[1]=1;
	dfs2(1);
}

ll sum[N<<2];
int maxn[N<<2];

inline
void pushup(int k){
	sum[k]=sum[k<<1]+sum[k<<1|1];
	maxn[k]=max(maxn[k<<1],maxn[k<<1|1]);
}

inline
void build(int k,int l,int r){
	if(l==r){
		sum[k]=maxn[k]=val[pos[l]];
		return ;
	}
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
	pushup(k);
}

inline
ll querysum(int k,int l,int r,cs int &ql,cs int &qr){
	if(ql<=l&&r<=qr)return sum[k];
	int mid=(l+r)>>1;
	if(mid<ql)return querysum(k<<1|1,mid+1,r,ql,qr);
	if(qr<=mid)return querysum(k<<1,l,mid,ql,qr);
	return querysum(k<<1,l,mid,ql,qr)+querysum(k<<1|1,mid+1,r,ql,qr);
}

inline
int querymax(int k,int l,int r,cs int &ql,cs int &qr){
	if(ql<=l&&r<=qr)return maxn[k];
	int mid=(l+r)>>1;
	if(mid<ql)return querymax(k<<1|1,mid+1,r,ql,qr);
	if(qr<=mid)return querymax(k<<1,l,mid,ql,qr);
	return max(querymax(k<<1,l,mid,ql,qr),querymax(k<<1|1,mid+1,r,ql,qr));
}

inline
void update(int k,int l,int r,cs int &p){
	if(l==r){
		sum[k]=maxn[k]=val[pos[p]];
		return ;
	}
	int mid=(l+r)>>1;
	if(mid>=p)update(k<<1,l,mid,p);
	else update(k<<1|1,mid+1,r,p);
	pushup(k);
}

inline
int pathmax(int u,int v){
	if(top[u]!=top[v]){
		if(dep[top[u]]>dep[top[v]])swap(u,v);
		return max(pathmax(fa[top[v]],u),querymax(1,1,n,in[top[v]],in[v]));
	}
	if(dep[u]>dep[v])swap(u,v);
	return querymax(1,1,n,in[u],in[v]);
}

inline
ll pathsum(int u,int v){
	if(top[u]!=top[v]){
		if(dep[top[u]]>dep[top[v]])swap(u,v);
		return pathsum(fa[top[v]],u)+querysum(1,1,n,in[top[v]],in[v]);
	}
	if(dep[u]>dep[v])swap(u,v);
	return querysum(1,1,n,in[u],in[v]);
}

signed main(){
	n=getint();
	for(int re i=1;i<n;++i){
		int u=getint(),v=getint();
		addedge(u,v);
	}
	tree_dissection();
	for(int re i=1;i<=n;++i)val[i]=getint();
	build(1,1,n);
	q=getint();
	while(q--){
		char op=getalpha();
		if(op=='Q')op=getalpha();
		switch(op){
			case 'M':{
				int u=getint(),v=getint();
				outint(pathmax(u,v)),pc('\n');
				break;
			}
			case 'S':{
				int u=getint(),v=getint();
				outint(pathsum(u,v)),pc('\n');
				break;
			}
			case 'C':{
				int p=getint();
				val[p]=getint();
				update(1,1,n,in[p]);
				break;
			}
		}
	}
	return 0;
}