先看一道题目：洛谷P2495 [SDOI2011]消耗战
题目大意：
给定一颗以$1$为根的带有边权的树，一共$m$个询问，每次给出一些点的编号，求使得这些点不能到达的$1$的最小短边代价。
暴力：
如果只有一组询问，我们发现这好像是个树形$DP$。
设$dp[x]$表示使$x$及其子树到不了$1$的最小代价，$val[x]$表示断掉$fa[x]->x$这条路的代价。
于是状态转移方程长这个样：
$$dp[x]=minleft{egin{array}{}val[x]\sum_{yin son_x}dp[y]end{array}
ight.$$
一共有$m$个询问，那就跑$m$次。
然鹅这个方法复杂度$O(nm)$，铁定$TLE$。。。
于是开始想优化。
优化的暴力：
我们发现在$DP$过程中有许多不需要搜索到的节点。
也就是说，某些节点的子树中没有资源丰富的节点。
那我们为什么还要搜索它呢？因为爱情。。。
所以我们开两个$bool$数组：$rich[x],have\_rich[x]$，分别表示$x$是否是资源丰富的节点，$x$的子树中是否含有资源丰富的节点。
每次判断一下就好。
代码的话。。。大概是这个样子：
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#define MAXN 250010
using namespace std;
int n,m,c=1;
int head[MAXN],deep[MAXN],fa[MAXN];
long long val[MAXN],dp[MAXN];
bool rich[MAXN],have_rich[MAXN];
struct Tree{
int next,to,w;
}a[MAXN<<1];
inline int read(){
int date=0;char c=0;
while(c<'0'||c>'9')c=getchar();
while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
return date;
}
inline long long min(const long long &x,const long long &y){return x<y?x:y;}
inline void add(int u,int v,int w){
a[c].to=v;a[c].w=w;a[c].next=head[u];head[u]=c++;
a[c].to=u;a[c].w=w;a[c].next=head[v];head[v]=c++;
}
void buildtree(int rt){
int will;
for(int i=head[rt];i;i=a[i].next){
will=a[i].to;
if(!deep[will]){
deep[will]=deep[rt]+1;
val[will]=a[i].w;
fa[will]=rt;
buildtree(will);
}
}
}
void dfs(int rt){
if(rich[rt]){
dp[rt]=val[rt];
return;
}
int will;
dp[rt]=0;
for(int i=head[rt];i;i=a[i].next){
will=a[i].to;
if(deep[will]>deep[rt]&&have_rich[will]){
dfs(will);
dp[rt]+=dp[will];
}
}
dp[rt]=min(dp[rt],val[rt]);
}
void work(){
int k,h;
while(m--){
memset(rich,false,sizeof(bool)*(n+1));
memset(have_rich,false,sizeof(bool)*(n+1));
k=read();
for(int i=1;i<=k;i++){
h=read();
rich[h]=have_rich[h]=true;
for(int j=fa[h];j!=0&&!have_rich[j];j=fa[j])have_rich[j]=true;
}
dfs(1);
printf("%lld
",dp[1]);
}
}
void init(){
int u,v,w;
n=read();
for(int i=1;i<n;i++){
u=read();v=read();w=read();
add(u,v,w);
}
deep[1]=1;val[1]=(1LL<<60);
buildtree(1);
m=read();
}
int main(){
init();
work();
return 0;
}
然鹅还是有一个点$TLE$。。。
怎么办呢？
我们拿出高级武器——虚树。
虚树：
其实和我的思路一样，都是保留有用的节点。但是虚树更厉害，直接保存了询问节点以及它们的$LCA$。
比我的方法少了好多节点。。。
于是这个题就每次在叙述上跑$DP$就好。
但是，虚树怎么建呢？
首先我们要先对整棵树$dfs$一遍，求出他们的$dfs$序$id[]$。
顺便树链剖分一下，方便以后求出$LCA$。
然后对每个节点以$dfs$序为关键字从小到大排序。
同时维护一个栈$stack[]$，表示从根到栈顶元素这条链。
假设我们要插入的点是$x$，栈顶为$stack[top]$，$lca=LCA(x,stack[top])$。
由于我们是以$dfs$序为关键字从小到大排序，所以$lca!=x$。
于是有两种情况：
- $lca==stack[top]$：此时只要把$x$直接压入栈中就好。
- $lca!=stack[top]$：此时$stack[top],x$分别位于$lca$的两颗子树中。这就意味着而$stack[top]$的子树已经遍历完了，我们需要建树。
设$p=stack[top],q=stack[top-1]$。
然后又是分类讨论：
- $id[q]>id[lca]$：连边$q->p$，将$p$弹出。
- $id[q]=id[lca]$：此时$q==lca$，连边$q->p$，子树建立完毕，跳出建立过程。
- $id[q]<id[lca]$：此时$lca$在$p,q$之间，连边$lca->p$，将$p$弹出，再将$lca$压入栈中，子树建立完毕，跳出建立过程。
然后不断重复这个过程即可。
最后不要忘了将栈中剩余元素加入到新建立的树中。
这样，我们的虚树就建立完了。
复杂度：
我们知道，每两个点会有一个$lca$。
于是建完的虚树最多会有$2k$个节点。
这样，我们的复杂度就是$O(2sum k)$。
跑得飞快。
代码：
详见：
BZOJ2286: [Sdoi2011]消耗战
推荐一道不错的练手题：