【虚树】学习笔记

NND，跟我玩虚的是吧

在某些题目中，我们可能需要在树中求解多组询问，而如果直接暴力解决，显然T飞，此时，我们需要删除一些没有对本组询问没有意义的点，来降低时间复杂度。而通过上面的操作所得到的“有意义”的树，我们称之为虚树。

感觉很抽象？

我们以下面的题目为例

Eg. [SDOI2011] 消耗战

假设有这样的一棵树：

如果以 $3,5,7$ 作为关键节点，那么，虚树应该长这样：

显然，如果我们在虚树上来解决这个问题，时间复杂度会大幅降低

那么，怎么求虚树？

有一个暴力的想法：

虚树上的节点为所有的关键节点并上每两个关键节点求LCA所得到的点集的集合

那你怎么搞还不如不建虚树

有这样的一个定理：

设树上有三个节点 $a,b,c$，满足其dfs序从小到大排序，则LCA(a,c)=LCA(a,b) or LCA(b,c)

水水的证明：

假设 $x=\mathrm{LCA}(a,c)$

如果 $x=a$，说明 $a$ 是 $c$ 的祖先，则 $a$ 是 $b$ 的祖先，则必有 $\mathrm{LCA}(a,b)=a=x$

如果 $x\ne a$，说明 $a$ 与 $c$ 是在 $x$ 节点上的不同子节点的子树上的，此时，假设 $b$ 与 $a$ 在同一子树上，则有 $\mathrm{LCA}(b,c)=\mathrm{LCA}(a,c)=x$；反之，则有 $\mathrm{LCA}(a,b)=\mathrm{LCA}(a,c)=x$

证毕

那么，暴力的想法就可以转变为正解想法：

先将所有的关键节点按照dfs序从小到大排序，则虚树上的节点为所有的关键节点并上排序后相邻两个关键节点求LCA所得到的点集的集合

好了，这样虚树就建完了。。。？

实际上，我们并不会专门为虚树建一个图（这也是为什么我们称虚树是“虚”的）

我们建虚树的目的，是为了跑树形DP时，而树形DP的本质为dfs

考虑dfs的本质，不难发现，我们可以使用一个栈，就可以实现dfs了，也就没必要建图了

这样一来，我们就完成了有关虚树的基本操作（DP有关的就省略了）

有关栈代替dfs的部分，详见代码注释

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=500005;
int n,m,maxn;
int x,y,z;
int ver[N],edge[N],Next[N],head[N],len;
void add(int x,int y,int z){
	ver[++len]=y,edge[len]=z,Next[len]=head[x],head[x]=len;
}
int dfsin[N],dfsout[N],dfslen;
//使用欧拉序，刚遍历到该节点时以及该节点将要遍历结束时都要记录下来
int deep[N];
int fa[N][40];
int minn[N];//DP用
void dfs(int x,int pre){
	dfsin[x]=++dfslen;//开始遍历
	fa[x][0]=pre;
	deep[x]=deep[pre]+1;
	for(int i=1;i<=maxn;i++){
		fa[x][i]=fa[fa[x][i-1]][i-1];
	}
	for(int i=head[x];i;i=Next[i]){
		int y=ver[i],z=edge[i];
		if(y^pre){
			minn[y]=min(minn[x],z);
			dfs(y,x);
		}
	}
	dfsout[x]=++dfslen;//结束遍历
}
int lca(int x,int y){
	if(deep[x]>deep[y]){
		swap(x,y);
	}
	for(int i=maxn;i>=0;i--){
		if(deep[x]<=deep[fa[y][i]]){
			y=fa[y][i];
		}
	}
	if(x==y){
		return x;
	}
	for(int i=maxn;i>=0;i--){
		if(fa[x][i]^fa[y][i]){
			x=fa[x][i];
			y=fa[y][i];
		}
	}
	return fa[x][0];
}
struct node{
	int x;//当x为正数时，表示该节点是刚开始被遍历的状态；反之，表示该节点是即将被遍历完毕的状态
	bool operator<(const node other)const{
		int k1,k2;
		if(x>0){
			k1=dfsin[x];
		}else{
			k1=dfsout[-x];
		}
		if(other.x>0){
			k2=dfsin[other.x];	
		}else{
			k2=dfsout[-other.x];
		}
		return k1<k2;
	}
}a[N];
int flag[N];
int dp[N];
stack<int> s;
int read(){
	int a=1,b=0;
	char ch=getchar();
	while(ch<'0'||ch>'9'){
		a=ch=='-'?-1:1,ch=getchar();
	} 
	while(ch>='0'&&ch<='9'){
		b=(b<<1)+(b<<3)+ch-'0',ch=getchar();
	}
	return a*b;
}
signed main(){
	n=read();
	maxn=(int)(log2(n)+1);
	for(int i=1;i<n;i++){
		x=read(),y=read(),z=read();
		add(x,y,z),add(y,x,z);
	}
	minn[1]=214748364711451419,flag[0]=1;
	dfs(1,0);
	m=read();
	while(m--){
		int len=read();
		for(int i=1;i<=len;i++){
			a[i].x=read();
			flag[a[i].x]=1;//标记关键点
			dp[a[i].x]=minn[a[i].x];//预处理DP
		}
		sort(a+1,a+1+len);//排序，求虚树上的节点
		int llen=len;
		for(int i=1;i<len;i++){
			int LCA=lca(a[i].x,a[i+1].x);
			if(!flag[LCA]){//没有被塞进过
				flag[LCA]=1;//塞进虚树
				a[++len].x=LCA;
			}
		}
		llen=len;
		for(int i=1;i<=llen;i++){//每一个节点都有“开始遍历”和“结束遍历”两个状态
			a[++len].x=-a[i].x;
		}
		if(!flag[1]){//1号节点必须被塞入虚树
			a[++len].x=1;
			a[++len].x=-1;
		}
		sort(a+1,a+1+len);
		for(int i=1;i<=len;i++){
			if(a[i].x>0){//开始遍历，塞入栈中，表示正处于递归
				s.push(a[i].x);
			}else{//结束遍历，此时，栈顶的第二个元素取绝对值必为第一个元素取绝对值的父亲，在此DP
				int Now=s.top();
				s.pop();
				if(Now==1){//特别的，完成了DP，输出结果
					printf("%lld\n",dp[1]);
				}else{
					dp[s.top()]+=min(minn[Now],dp[Now]);
				}
				dp[Now]=flag[Now]=0;//初始化喵
			}
		}
	}
	return 0;
}