BZOJ 2286: [Sdoi2011]消耗战

Description

在一场战争中，战场由n个岛屿和n-1个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为1的岛屿，而且他们已经没有足够多的能源维系战斗，我军胜利在望。已知在其他k个岛屿上有丰富能源，为了防止敌军获取能源，我军的任务是炸毁一些桥梁，使得敌军不能到达任何能源丰富的岛屿。由于不同桥梁的材质和结构不同，所以炸毁不同的桥梁有不同的代价，我军希望在满足目标的同时使得总代价最小。
侦查部门还发现，敌军有一台神秘机器。即使我军切断所有能源之后，他们也可以用那台机器。机器产生的效果不仅仅会修复所有我军炸毁的桥梁，而且会重新随机资源分布（但可以保证的是，资源不会分布到1号岛屿上）。不过侦查部门还发现了这台机器只能够使用m次，所以我们只需要把每次任务完成即可。

Solution

虚树入门题。。
虚树是什么就不用我说了。
来简要说说虚树的建法
虚树里只有两种点：询问的点以及这些点的lca
其实简要推一下都是可以推出来的，但把它公式化可以更方便地敲。
我们维护一个栈，里面存一条dfs链(其实这么说了等于没说，后面会具体讲解)
一开始预处理dfs序以及lca需要的东西。
然后我们找到一个不可能作为询问的点，作为虚树的根(比如这题里的点1)
把这玩意塞到栈里。
然后按照询问点dfn的顺序加点。
加点规则：
设当前预加入元素为x，p是栈顶元素，q是栈里第二个元素，lca是p和x的lca
1)如果p=lca，那么直接把x压入栈。
2)如果p!=lca，分类讨论：
（1）dfn[lca] < <script type="math/tex" id="MathJax-Element-13"><</script>dfn[q] 先由q向p连一条边，然后弹掉p
（2）dfn[lca]$=$dfn[q] 说明lca=q，由q向p连边，然后弹掉p，结束
（3）dfn[lca]$>$dfn[q] 说明lca在q和p的中间，由lca向p连边，弹掉p，压入lca
重复以上操作直至（2）

模拟一下过程，可以发现以上操作是正确的。
关于连的边里面是什么，要结合题面分析，如这题，为路径最小值。

总的来说就是上面的东西，熟练即可咯

Code

#include<iostream>
#include<string.h>
#include<algorithm>
#include<stdio.h>
#include<vector>
using namespace std;
typedef long long ll;
const int M=25e4+5;
const int INF=1LL<<30;
struct node{int to,v;};
int f[M][20],d[M],dfn[M],dfs_clock,A[M],stk[M],m,n,dep[M][18];
ll dp[M];
bool mark[M];
#define vecn vector<node>
#define pb push_back
inline void Min(int &a,int b){if(a>b)a=b;}
vecn G[M],edge[M];
inline void rd(int &a){
    a=0;char c;
    while(c=getchar(),!isdigit(c));
    do a=a*10+(c^48);
        while(c=getchar(),isdigit(c));
}
inline void predfs(int v,int fa){
    f[v][0]=fa,dfn[v]=++dfs_clock;
    d[v]=d[fa]+1;
    for(int i=0;i<edge[v].size();++i){
        node nxt=edge[v][i];
        if(nxt.to^fa)
            dep[nxt.to][0]=nxt.v,predfs(nxt.to,v);
    }
}
inline void up(int &u,int x){
    for(int i=0;i<18;++i)
        if(x&1<<i)u=f[u][i];
}
inline int lca(int u,int v){
    if(d[u]<d[v])swap(u,v);
    up(u,d[u]-d[v]);
    if(u==v)return u;
    for(int i=17;~i;--i)
        if(f[u][i]!=f[v][i])u=f[u][i],v=f[v][i];
    return f[v][0];
}
inline int query(int u,int x){
    int res=INF;
    for(int i=17;~i;--i)
        if(x&1<<i)Min(res,dep[u][i]),u=f[u][i];
    return res;
}
inline void pret(){
    for(int j=1;j<18;++j)
        for(int i=1;i<=n;++i){
            f[i][j]=f[f[i][j-1]][j-1];
            dep[i][j]=min(dep[i][j-1],dep[f[i][j-1]][j-1]);
        }
}
inline void work(ll x){
    if(!x)return;
    work(x/10);
    putchar(48+x%10);
}
inline void print(ll x){
    if(!x)putchar('0');
    else work(x);
    putchar('\n');
}
inline bool cmp(const int &a,const int &b){
    return dfn[a]<dfn[b];
}
ll dfs(int v){
    ll &res=dp[v];
    if(res)return res;
    for(int i=0;i<G[v].size();++i){
        node nxt=G[v][i];
        if(mark[nxt.to])res+=nxt.v;
        else res+=min(dfs(nxt.to),(ll)nxt.v);
    }
    return res;
}
void visit(int v){
    dp[v]=mark[v]=0;
    for(int i=0;i<G[v].size();++i)
        visit(G[v][i].to);
    G[v].clear();
}
int main(){
    cin>>n;
    for(int i=1,a,b,c;i<n;++i){
        rd(a),rd(b),rd(c);
        edge[a].pb((node){b,c});
        edge[b].pb((node){a,c});
    }
    predfs(1,0);
    for(cin>>m,pret();m--;){
        int k,top=0;rd(k);
        for(int i=1;i<=k;++i)rd(A[i]),mark[A[i]]=1;
        sort(A+1,A+k+1,cmp);
        stk[++top]=1;
        for(int i=1;i<=k;++i){
            int Lca=lca(stk[top],A[i]);
            if(Lca!=stk[top]){
                for(;top>1&&dfn[Lca]<dfn[stk[top-1]];)
                    G[stk[top-1]].pb((node){stk[top],query(stk[top],d[stk[top]]-d[stk[top-1]])}),top--;
                if(top>1&&dfn[stk[top-1]]<=dfn[Lca]){
                    G[Lca].pb((node){stk[top],query(stk[top],d[stk[top]]-d[Lca])});
                    if(stk[top-1]!=Lca)stk[top]=Lca;
                    else top--;
                }
            }
            stk[++top]=A[i];
        }
        for(;top>1;)
            G[stk[top-1]].pb((node){stk[top],query(stk[top],d[stk[top]]-d[stk[top-1]])}),top--;
        print(dfs(1));
        visit(1);
    }
    return 0;
}