Luogu2495&bzoj2286 消耗战 虚树

虚树模板题
题目大意：给出一棵有n个结点的有根树，根结点为1，每条边又有一个权值，给出若干个询问，每次询问给出若干个结点，删除一些边以后使得这些结点不能到达根结点，问最小花费是多少。
n<250000,$\sum 每次询问的结点数$<500000
虚树，顾名思义就是一棵假的树，用来解决一类多询问树上dp问题。

以这个题为例，就是每次给出一些关键结点，如果我们对每次询问dp整棵树的话那肯定T飞了，那我们就得对询问进行相应对简化，把他简化成一棵结点数大致和关键结点数相当的树。

以case为例
原树是这样

那我们对关键结点6 10进行处理的话就可以把树简化成这样

其他结点都是不必要的。这就是我们要构造的虚树。

这个树大致包括3类结点

• 根结点
• 关键结点
• 关键结点的lca

那么我们要考虑如何把这棵树构造出来。

这时我们可以维护一个单调栈，在栈里元素的含义是一条包括关键结点的树链，我们每次将关键结点加入这个单调栈，并进行相应的弹栈处理：

1. 首先我们要将根结点加入这个单调栈。
2. 如果栈中元素小于等于1，那么直接入栈。stk[++hd]=x
3. 如果栈顶元素和当前结点的lca就是栈顶元素，那么说明我们在处理的还是同一条链，那么也直接入栈，stk[++hd]=x;
4. 如果栈顶元素和当前结点的lca不是栈顶元素，那么说明我们在处理的元素以及不是一条链了，那么需要把之前那些同属于一条链的元素弹出来，并构建把他们实际构建出来。注意此时若lca不在栈中则应该把lca加入栈中。

为了保证同一棵子树的元素都在一起，我们需要先维护一个dfs序，然后对关键结点用dfs序排序。

此时我们的虚树就构建完成了。

之后进行树上dp。

我们用mn[x]表示从x到根结点的路径上的最小值，dp[x]表示切断x以及之后的子树所需要的最小花费，那么：

• 若当前结点是关键结点，dp[x]=mn[x];
• 若当前结点不是关键结点，那么$dp[x]+=min(dp[y],mn[y])$

实现代码(bzoj不支持c++11)：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=250005;
const int inf=0x3f3f3f3f;
struct node{
    int v,d,nxt;
}p[N<<1];
int head[N],anc[20][N],dep[N],tot;
int dfn[N],idx,mn[N];
void init(){
    tot=0;
    mn[1]=inf;
    memset(dep,0,sizeof(dep));
    memset(head,-1,sizeof(head));
}
void add(int x,int y,int d){
    p[tot].v=y;
    p[tot].d=d;
    p[tot].nxt=head[x];
    head[x]=tot++;
}
void dfs(int x,int fa){
    dfn[x]=++idx;
    dep[x]=dep[fa]+1;
    anc[0][x]=fa;
    for(int i=1;i<20;i++){
        anc[i][x]=anc[i-1][anc[i-1][x]];
    }
    for(int i=head[x];~i;i=p[i].nxt){
        int y=p[i].v;
        if(y==fa)
            continue;
        mn[y]=min(mn[x],p[i].d);
        dfs(y,x);
    }
}
int lca(int x,int y){
    if(dep[y]<dep[x])
        swap(x,y);
    for(int i=19;i>=0;i--)
        if(dep[anc[i][y]]>=dep[x])
            y=anc[i][y];
    if(x==y)
        return x;
    for(int i=19;i>=0;i--){
        if(anc[i][x]!=anc[i][y]){
            x=anc[i][x];
            y=anc[i][y];
        }
    }
    return anc[0][x];
}
vector<int>vp[N],key;
int stk[N],hd,flag[N];
bool cmp(int x,int y){
    return dfn[x]<dfn[y];
}
void vp_clear(){
    hd=0;
    for(int i:key){
        flag[i]=0;
    }
    if(!key.empty())
        key.clear();
}
ll dp(int x){
    ll res=0;
    for(int i:vp[x]){
        res+=min(dp(i),1ll*mn[i]);
    }
    vp[x].clear();
    if(flag[x])
        return mn[x];
    else
        return res;
}
void insert(int x){
    if(hd<=1){
        stk[++hd]=x;
        return;
    }
    int lc=lca(x,stk[hd]);
    if(lc==stk[hd]){
        stk[++hd]=x;
    }
    else{
        while(hd>1&&dfn[lc]<=dfn[stk[hd-1]]){
            vp[stk[hd-1]].push_back(stk[hd]);
            hd--;
        }
        if(lc!=stk[hd]){            //如果lca不在栈中，那么加入栈，否则会有问题
            vp[lc].push_back(stk[hd]);
            stk[hd]=lc;
        }
        stk[++hd]=x;
    }
}
int main(){
    init();
    int n,m,x,y,d;
    scanf("%d",&n);
    for(int i=0;i<n-1;i++){
        scanf("%d%d%d",&x,&y,&d);
        add(x,y,d);
        add(y,x,d);
    }
    dfs(1,0);
    scanf("%d",&m);
    while(m--){
        scanf("%d",&x);
        for(int i=0;i<x;i++){
            scanf("%d",&y);
            key.push_back(y);
            flag[y]=1;
        }
        sort(key.begin(),key.end(),cmp);
        stk[++hd]=1;
        for(int i:key){
            insert(i);
        }
        while(hd>1){
            vp[stk[hd-1]].push_back(stk[hd]);
            hd--;
        }
        printf("%lld\n",dp(1));
        vp_clear();
    }
    return 0;
}