图论&动态规划：虚树

虚树可以看做是对树形动态规划的一种求解优化

对于需要求答案的点p，只保留对答案有影响的节点，从而减少时间

BZOJ2286

dp[i]=min(val[i],Σdp[j](j为i的儿子))，val[i]表示将i和根节点分离的代价

方程为什么这么写呢？val也就是从当前i到根节点的边权的最小值

为了让代价最小，最后的dp[root]就是答案了，树形dp是先递归调用到根然后回溯的过程中求值，回溯到根节点的时候答案就显然了

我们可以只用询问点及他们的LCA来建一颗新树，我们暂且称其为虚树，然后在虚树上跑dp，效率就会高很多

维护虚树的过程我没有看懂，只能参考程序了，用栈维护的

每次按照关键点的dfs序排序，维护栈构建一棵新的树，在新的树上dp

 #include<iostream>
 #include<set>
 #include<map>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<ctime>
 #include<vector>
 #include<queue>
 #include<algorithm>
 #include<cmath>
 #include<bitset>
 #include<stack>
 #define inf 1e60
 #define pa pair<int,int>
 #define ll long long
 using namespace std;
 int read()
 {
     int x=,f=;char ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
     return x*f;
 }
 int bin[];
 int n,m,cnt,ind,top;
 int last[],last2[],fa[][];
 ll mn[],f[];
 int h[],mark[],deep[];
 int st[];
 struct edge{
     int to,next,v;
 }e[],ed[];
 void insert(int u,int v,int w)
 {
     e[++cnt].to=v;e[cnt].next=last[u];last[u]=cnt;e[cnt].v=w;
     e[++cnt].to=u;e[cnt].next=last[v];last[v]=cnt;e[cnt].v=w;
 }
 void insert2(int u,int v)
 {
     if(u==v)return;
     ed[++cnt].to=v;ed[cnt].next=last2[u];last2[u]=cnt;
 }
 bool cmp(int a,int b)
 {
     return mark[a]<mark[b];
 }
 void pre(int x)
 {
     mark[x]=++ind;
     for(int i=;bin[i]<=deep[x];i++)
         fa[x][i]=fa[fa[x][i-]][i-];
     for(int i=last[x];i;i=e[i].next)
         if(e[i].to!=fa[x][])
         {
             mn[e[i].to]=min(mn[x],(ll)e[i].v);
             deep[e[i].to]=deep[x]+;
             fa[e[i].to][]=x;
             pre(e[i].to);
         }
 }
 int lca(int x,int y)
 {
     if(deep[x]<deep[y])swap(x,y);
     int t=deep[x]-deep[y];
     for(int i=;bin[i]<=t;i++)
         if(t&bin[i])x=fa[x][i];
     for(int i=;i>=;i--)
         if(fa[x][i]!=fa[y][i])
             x=fa[x][i],y=fa[y][i];
     if(x==y)return x;
     return fa[x][];
 }
 void dp(int x)
 {
     f[x]=mn[x];
     ll tmp=;
     for(int i=last2[x];i;i=ed[i].next)
     {
         dp(ed[i].to);
         tmp+=f[ed[i].to];
     }
     last2[x]=;
     if(tmp==)f[x]=mn[x];
     else if(tmp<=f[x])f[x]=tmp;
 }
 void solve()
 {
     cnt=;
     int K=read();
     for(int i=;i<=K;i++)
         h[i]=read();
     sort(h+,h+K+,cmp);
     int tot=;
     h[++tot]=h[];
     for(int i=;i<=K;i++)
         if(lca(h[tot],h[i])!=h[tot])h[++tot]=h[i];
     st[++top]=;
     for(int i=;i<=tot;i++)
     {
         int now=h[i],f=lca(now,st[top]);
         while()
         {
             if(deep[f]>=deep[st[top-]])
             {
                 insert2(f,st[top--]);
                 if(st[top]!=f)st[++top]=f;
                 break;
             }
             insert2(st[top-],st[top]);top--;
         }
         if(st[top]!=now)st[++top]=now;
     }
     while(--top)insert2(st[top],st[top+]);
     dp();
     printf("%lld\n",f[]);
 }
 int main()
 {
     bin[]=;for(int i=;i<;i++)bin[i]=bin[i-]<<;
     n=read();
     for(int i=;i<n;i++)
     {
         int u=read(),v=read(),w=read();
         insert(u,v,w);
     }
     mn[]=inf;pre();
     m=read();
     for(int i=;i<=m;i++)
         solve();
     return ;
 }