【题解】SDOI2011消耗战

虚树模板题~洛谷P2495

第一次写虚树，感觉好厉害呀~首先，这道题目的树形dp是非常显然的，要控制一个点&其子树所有点，要么在子树内部割边，要么直接切点该点与父亲的连边。所以dp[u]表示控制u点所需的最小代价。只是，注意到这样dp的复杂度是O(nm)的，十分不可接受，妥妥的TLE。不过，题目给出的条件中还有一条：Σk_i<=500000;说明虽然总共的点很多，但实际上每一次对答案可能有影响的点很少。

再一次想到之前dp的时候就应该发现的性质：一条链上，只需要在意链首的点（控制了链首也就控制了整棵子树），这样我们就可以想到：要是这一棵树很小，能够把对答案没有贡献的点尽量都去掉就可以以很小的复杂度完成每一轮询问的dp了。

怎样构建一棵虚树呢？首先，将整颗树dfs一遍，保存每一个点的dfs序号（记为dfn[i]）。对于一次询问中的点：a[i]而言，将其按照dfs序从小到大排序，之后两两求出lca，排除那些在同一条链上的点（只保留链首）。之后，我们将1号点放入栈中。这个栈是一个单调栈，保证在任何时候栈中的元素都是一条链，且栈顶元素深度最大。我们记栈顶元素与当前点（之前保留下来的点）的lca为lca，之后的操作就十分显然了，我们要不断的将栈顶元素退栈（在退栈的同时连边构造虚树），直到退回lca与当前元素的那一条链上。注意如果lca不是最后的栈顶元素，lca也要进栈（在虚树上必须保留的一个点，记录了分叉的情况）。最后不要忘记将剩下的元素也用边连起来。

在虚树上面跑dp，一共也没几个点，自然就跑得很快啦。

#include <bits/stdc++.h>
using namespace std;
#define INF 99999999999LL
#define maxn 280000
#define ll long long
int timer, cnp = , n, m, head[maxn], dfn[maxn], dep[maxn], gra[maxn][];
int a[maxn], s[maxn], top, tot;
ll val[maxn], dp[maxn];
struct edge
{
    int to, last;
    ll co;
}E[maxn * ];

int read()
{
    int x = , k = ;
    char c;
    c = getchar();
    while(c < '' || c > '') { if(c == '-') k = -; c = getchar(); }
    while(c >= '' && c <= '') x = x *  + c - '', c = getchar();
    return x * k;
}

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

void add(int x, int y, int co = )
{
    if(x == y) return;
    E[cnp].to = y, E[cnp].co = co;
    E[cnp].last = head[x], head[x] = cnp ++;
}

int LCA(int x, int y)
{
    if(dep[x] < dep[y]) swap(x, y);
    for(int i = ; ~i; i --)
        if(dep[gra[x][i]] >= dep[y]) x = gra[x][i];
    for(int i = ; ~i; i --)
        if(gra[x][i] != gra[y][i]) x = gra[x][i], y = gra[y][i];
    return (x == y) ? x : gra[x][];
}

void dfs(int u, int fa)
{
    gra[u][] = fa, dfn[u] = ++ timer, dep[u] = dep[fa] + ;
    for(int i = ; i <= ; i ++) gra[u][i] = gra[gra[u][i - ]][i - ];
    for(int i = head[u]; i; i = E[i].last)
    {
        int v = E[i].to;
        if(v == fa) continue;
        val[v] = min(E[i].co, val[u]);
        dfs(v, u);
    }
}

void DP(int u, int fa)
{
    ll c = ; dp[u] = val[u];
    for(int i = head[u]; i; i = E[i].last)
    {
        int v = E[i].to;
        if(v == fa) continue;
        DP(v, u);
        c += dp[v];
    }
    head[u] = ;
    if(c && c < val[u]) dp[u] = c;
}

void solve()
{
    int k = read();
    for(int i = ; i <= k; i ++) a[i] = read();
    sort(a + , a +  + k, cmp);
    cnp = , s[] = ; top = , tot = ;
    for(int i = ; i <= k; i ++) if(LCA(a[i], a[tot]) != a[tot]) a[++ tot] = a[i];
    for(int i = ; i <= tot; i ++)
    {
        int lca = LCA(s[top], a[i]);
        while()
        {
            if(dep[lca] >= dep[s[top - ]])
            {
                add(lca, s[top]);
                top --;
                if(lca != s[top]) s[++ top] = lca;
                break;
            }
            add(s[top - ], s[top]), top --;
        }
        s[++ top] = a[i];
    }
    while(top > ) add(s[top - ], s[top]), top --;
    DP(, );
    printf("%lld\n", dp[]);
} 

int main()
{
    n = read();
    val[] = INF;
    for(int i = ; i <= n - ; i ++)
    {
        int x = read(), y = read(), z = read();
        add(x, y, z), add(y, x, z);
    }
    dfs(, );
    memset(head, , sizeof(head));
    m = read();
    for(int i = ; i <= m; i ++) solve();
    return ;
}