2019.03.21【SPOJ-QTREE4】Query on a tree IV（LCT）

传送门

---

解析：

考虑用LCT来乱搞，同时维护一些简单的子树信息就可以乱搞了。

首先我们将边权下放到每个儿子节点处方便维护，同时放弃LCT中的makeroot操作（不然没法维护）。

每个点开两个multiset，一个维护所有虚子树中的答案，另一个维护所有从当前点叉出去到每个虚子树中白点的最远距离。

显然我们只需要在access的同时根据虚实链的变化来同步维护这两个multiset就行了。

现在考虑pushup。

显然这个pushup就是拼接两条链和一个点。

用sum表示链的总长，显然这个随便更新。

用lmx表示从链上的最浅的点向下走能够走到的最远的白点的距离。
用rmx表示从链上的最深的点向上走能够走到的最远的白点的距离

这两个转移时，先处理出向所有虚子树走的最远的白点距离，向上和向下走的最远的白点的距离，同时利用上下链的总长就可以转移了。

用mx表示考虑当前点即当前点的Splay子树中所有点和这些点的虚子树的答案。

显然除了考虑虚子树的答案，上下链的答案，再把上下链的一部分拼接起来的答案和虚子树中最大链和次大链的答案考虑进去就行了，注意特判当前点是白点的情况

注意由于我们下放了边权到点上面，从上向下的转移和从下向上的转移有所不同。

具体的细节可以直接看pushup

---

代码：

#include<bits/stdc++.h>
#define ll long long
#define re register
#define gc get_char
#define cs const

namespace IO{
	inline char get_char(){
		static cs int Rlen=1<<20|1;
		static char buf[Rlen],*p1,*p2;
		return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,Rlen,stdin),p1==p2)?EOF:*p1++; 
	}
	
	inline int getint(){
		re char c;
		re bool f=0;
		while(!isdigit(c=gc()))if(c=='-')f=1;re int num=c^48;
		while(isdigit(c=gc()))num=(num+(num<<2)<<1)+(c^48);
		return f?-num:num;
	}
	inline char getalpha(){
		re char c;
		while(!isalpha(c=gc()));return c;
	}
}
using namespace IO;

using std::cout;
cs int N=2e5+5;
int last[N],nxt[N<<1],to[N<<1],ecnt;
int w[N<<1];
inline void addedge(int u,int v,int val){
	nxt[++ecnt]=last[u],last[u]=ecnt,to[ecnt]=v,w[ecnt]=val;
	nxt[++ecnt]=last[v],last[v]=ecnt,to[ecnt]=u,w[ecnt]=val;
}

std::multiset<int> subans[N],sub[N];
inline int fir(cs std::multiset<int> &s){return s.empty()?-0x3f3f3f3f:*s.rbegin();}
inline int sec(cs std::multiset<int> &s){return s.size()>=2?*++s.rbegin():-0x3f3f3f3f;}

int fa[N],son[N][2],mx[N],lmx[N],rmx[N],val[N],len[N],sum[N];
bool col[N];
inline void pushup(int u){
	int lc=son[u][0],rc=son[u][1];
	sum[u]=sum[lc]+sum[rc]+len[u];
	int out=std::max(val[u],fir(sub[u]));
	int L=std::max(out,rmx[lc]+len[u]);
	int R=std::max(out,lmx[rc]);
	lmx[u]=std::max(lmx[lc],R+sum[lc]+len[u]);
	rmx[u]=std::max(rmx[rc],L+sum[rc]);
	mx[u]=std::max(mx[lc],mx[rc]);
	mx[u]=std::max(mx[u],fir(subans[u]));
	mx[u]=std::max(mx[u],std::max(R+len[u]+rmx[lc],L+lmx[rc]));
	mx[u]=std::max(mx[u],fir(sub[u])+sec(sub[u]));
	if(!col[u])mx[u]=std::max(mx[u],std::max(0,fir(sub[u])));
}


inline bool which(int u){return son[fa[u]][1]==u;}
inline bool isroot(int u){return son[fa[u]][0]!=u&&son[fa[u]][1]!=u;}
inline void Rotate(int u){
	int Fa=fa[u],FA=fa[Fa];
	bool pos=which(u);
	if(FA&&!isroot(Fa))son[FA][which(Fa)]=u;
	son[Fa][pos]=son[u][!pos];
	if(son[Fa][pos])fa[son[Fa][pos]]=Fa;
	fa[Fa]=u;fa[u]=FA;
	son[u][!pos]=Fa;
	pushup(Fa);
	pushup(u); 
} 

inline void Splay(int u){
	for(int re Fa=fa[u];!isroot(u);Rotate(u),Fa=fa[u])
	if(!isroot(Fa))Rotate(which(Fa)==which(u)?Fa:u);
}

inline void access(int u){
	for(int re ch=0;u;u=fa[ch=u]){
		Splay(u);
		if(son[u][1])subans[u].insert(mx[son[u][1]]),sub[u].insert(lmx[son[u][1]]);
		if(ch)subans[u].erase(subans[u].find(mx[ch])),sub[u].erase(sub[u].find(lmx[ch]));
		son[u][1]=ch;
		pushup(u);
	}
}

void dfs(int u){
	for(int re e=last[u],v=to[e];e;v=to[e=nxt[e]])
	if(v!=fa[u]){
		fa[v]=u;
		len[v]=w[e];
		dfs(v);
		subans[u].insert(mx[v]);
		sub[u].insert(lmx[v]);
	}
	pushup(u);
}

int n,ans;
signed main(){
	n=getint();
	memset(mx,-0x3f,sizeof mx);
	memset(lmx,-0x3f,sizeof lmx);
	memset(rmx,-0x3f,sizeof rmx);
	for(int re i=1;i<n;++i){
		int u=getint(),v=getint(),val=getint();
		addedge(u,v,val);
	}
	dfs(1);ans=mx[1];
	n=getint();
	while(n--)switch(getalpha()){
		case 'A':{
			ans<0?cout<<"They have disappeared.\n":cout<<ans<<"\n";
			break;
		}
		case 'C':{
			int u=getint();
			access(u);Splay(u);
			col[u]^=1;
			val[u]=col[u]?-0x3f3f3f3f:0;
			pushup(u);ans=mx[u];
			break;
		}
	}
	return 0;
}