虚树

例：luogu2495

虚树是一种把树上无用信息浓缩的想法，类似于前缀和？？一般用于只与部分点有关的树状dp，具体可以参见例题，我只需树上的询问点的它们的lca来做dp即可，可以证明每个询问点最多生成一个lca，于是复杂度不就小了

证明复杂度很简单，如果有一个点与前面的点$y$，$z$都生成了新的lca，记为$ly$,$lz$,那么$lca(y,z)$等于$ly$，$lz$中深度较小的一个，假设不成立，于是可证一棵虚树的大小最大只有关键点数量的两倍

---

下面到最重要的地方了：怎么构建虚树：

构建虚树，即是把一些指定点和它们的lca从原树中抽出来。

先把关键点按dfs序排个序，然后我们就可以感性理解了：

维护一个栈，其中是所有子树中还可能产生新点的点，使从栈顶到栈底的深度是递减的（其实就是栈顶元素到根的，当前已加入虚树的点的一条链），一开始先把根丢进去。

记当前要加的关键点为$now$，栈顶为$x$，他们的$lca$为$lc$,如果$de{p}_{lc}=de{p}_x$，压now入栈结束，因为我不知到now子树中还有没有新点

如果$de{p}_{lc}<de{p}_x$,我就知道$x$的子树中不可能有任何新点了（别忘了关键点是按dfs序排过序），但我想知道栈里其他元素是不是也不可能了，很简单我先取出第二个栈中点$y$，一样如果$de{p}_{lc}<de{p}_y$,那y的子树里也不可能有新点了,那我就把x和y连起来没有任何问题，然后用y代替x继续此过程，在过程中：

如果出现$de{p}_{lc}=de{p}_y$即就是$lc=y$，x子树不可能y还有可能，但新点不会出现在x至y中的点（不然lca就不是lc了），那x连y，弹出x压进now，因为不知道now子树中还有没有新点，结束；

如果出现$de{p}_{lc}=de{p}_y$，我们先把lc加入虚树，然后连边lc与x（与前一种一样的道理），弹出x，压入now，因为不知道now子树中还有没有新点

做完以后别忘把栈里元素依次连接

构建过程有点抽象，一定要注意反复强调的黑体，为什么要把元素压入，为什么要弹出，这样才能理解，代码还有解释

---

例题的树上dp方程我就直接给了（$dp[i]$表示处理完i的子树，即使i自身为关键点也不计入$dp[i]$）：

1. $dp[fa]+=len(fa,son)$ (son为关键点)
2. $dp[fa]+=min(dp[son],len(fa,son))$ (son不是关键点)

做的时候要小心不要触及原树大小的复杂度，不然。。就白做了

代码算我恢复以来打的最长的了。。。

例题代码：

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <string.h>
#include <stack>
using namespace std;
#define lowbit(x) (x&-x)
typedef pair<int,int> pii;
typedef long long ll;
const int N=3e5+50;
int n,m,now,dfncnt,ki;
vector<pii > gg[N],xs[N];
int dep[N],req[N],dfn[N],fa[N][20];
ll dis[N],dp[N];
bool xu[N];
stack<int> ss;
vector<int> xuf;

void dfs(int now,int pre){
	for(int a=1;a<=18;a++)
		fa[now][a]=fa[fa[now][a-1]][a-1];
	dfn[now]=++dfncnt;
	int sz=gg[now].size();
	for(int i=0;i<sz;i++)
	{
		int nex=gg[now][i].first;
		ll len=gg[now][i].second;
		if(nex==pre) continue;
		dep[nex]=dep[now]+1;
		dis[nex]=min(dis[now],len);
		fa[nex][0]=now;
		dfs(nex,now);
	}
}

int lca(int x,int y)
{
	if(dep[y]>dep[x]) swap(x,y);
	for(int a=18;a>=0;a--)
		if(dep[fa[x][a]]>=dep[y])
			x=fa[x][a];
	if(x==y) return x;
	for(int a=18;a>=0;a--)
		if(fa[x][a]!=fa[y][a]){
			x=fa[x][a];
			y=fa[y][a];
		}
	return fa[x][0];
}

bool cmp(int a,int b){
	return dfn[a]<dfn[b];
}

void addedge(int x,int y){
	if(dep[x]>dep[y]) swap(x,y);
	xs[x].push_back(make_pair(y,dis[y]));
	xs[y].push_back(make_pair(x,dis[y]));
}

void buildxs()
{
	xuf.push_back(1);
	ss.push(1);
	for(int id=1;id<=ki;id++)
	{
		int now=req[id],x=ss.top(),lc=lca(x,now);
		xuf.push_back(now);
		ss.pop();
		if(dep[lc]==dep[x]){
			ss.push(x);
			ss.push(now);
			continue;
		}//x子树未处理完，压进去处理now子树
		while(!ss.empty())//x子树已处理完，问链栈中还有没有已处理完的，如有，则连接前一个元素，更新x
		{
			int y=ss.top();
			if(dep[y]<=dep[lc]) {
				if(dep[lc]!=dep[y]){
					ss.push(lc);
					xuf.push_back(lc);
				}//如没有，则判断如果lca！=x，就压进栈里
				break;
			}
			ss.pop();
			addedge(x,y);
			x=y;
		}
		ss.push(now);
		addedge(x,lc);//结算x
	}
	if(!ss.empty())
	{
		int x=ss.top();
		ss.pop();
		while(!ss.empty())
		{
			int y=ss.top();
			ss.pop();
			addedge(x,y);
			x=y;
		}
	}
}

void Outxs(){
	for(int i=1;i<=n;i++)
	{
		int sz=xs[i].size();
		if(sz)
		cout<<i<<": ";
		for(int j=0;j<sz;j++)
		{
			cout<<xs[i][j].first<<" ";
		}
		if(sz)
		cout<<endl;
	}
}

void Init(){
	int sz=xuf.size();
	for(int i=0;i<sz;i++)
		dp[xuf[i]]=0,xs[xuf[i]].clear();
	xuf.clear();
}

void Dp(int now,int pre)
{
	int sz=xs[now].size();
	if(sz==1 && pre!=-1) return;
	for(int i=0;i<sz;i++)
	{
		int nex=xs[now][i].first;
		ll len=xs[now][i].second;
		if(nex==pre) continue;
		Dp(nex,now);
		if(xu[nex]) dp[now]+=len;
		else dp[now]+=min(len,dp[nex]);
	}
}

int main()
{
	scanf("%d",&n);
	for(int i=1;i<n;i++){
		int ui,vi,wi;
		scanf("%d%d%d",&ui,&vi,&wi);
		gg[ui].push_back(make_pair(vi,wi));
		gg[vi].push_back(make_pair(ui,wi));
	}
	scanf("%d",&m);
	dep[1]=1;
	dis[1]=99999999;
	dfs(1,-1);
	while(m--)
	{
		scanf("%d",&ki);
		for(int i=1;i<=ki;i++)
			scanf("%d",&req[i]);
		sort(req+1,req+1+ki,cmp);
		for(int id=1;id<=ki;id++) xu[req[id]]=1;
		buildxs();
		Dp(1,-1);
		printf("%lld\n",dp[1]);
		Init();
		for(int id=1;id<=ki;id++) xu[req[id]]=0;
	}
	return 0;
}