CF613D Kingdom and its Cities

题意：

一个王国有n座城市，城市之间由n-1条道路相连，形成一个树结构，国王决定将一些城市设为重要城市。

这个国家有的时候会遭受外敌入侵，重要城市由于加强了防护，一定不会被占领。而非重要城市一旦被占领，这座城市就不能通行。

国王定了若干选择重要城市的计划，他想知道，对于每个计划，外敌至少要占领多少个非重要城市，才会导致重要城市之间两两不连通。如果外敌无论如何都不可能导致这种局面，输出-1。

题解：

考虑树形dp，首先考虑不行的情况，那么就是俩个相邻的点都是被标记的点，特判掉。然后fx表示以x为根的子树的答案，g[x]表示自己是否变为标记点。若x是标记点，则要让自己的儿子中有标记都选上。若x带有标记，若子节点带标记的大于等于2，则答案++。若只有一个儿子标记，那么标记保留。然后如果每次都dp的话，复杂度nq，肯定不行。考虑k的和很小，就把要用到的点，拿出来之后树形dp，这就用到了虚树的思想。

#include <bits/stdc++.h>
using namespace std;

const int N = 2e5 + 10;

inline int read()
{
    char ch = getchar();int x = 0, f = 1;
    while(ch < '0' || ch > '9') {if(ch == '-') f = -1; ch = getchar();}
    while(ch >= '0' && ch <= '9') {x = (x << 1) + (x << 3) - '0' + ch; ch = getchar();}
    return x * f;
}

int n, m, k;
int h[N], e[N], ne[N], idx, a[N];
int size[N], son[N], top[N], d[N], f[N], dfn[N], num;
int stac[N], sz, vs[N];
int dp[N];
vector<int>g[N];
void add(int a, int b)
{
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx ++;
}

void dfs1(int u, int fa)
{
    d[u] = d[fa] + 1;
    f[u] = fa;
    size[u] = 1;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if(j == fa) continue;
        dfs1(j, u);
        size[u] += size[j];
        if(size[son[u]] < size[j])
            son[u] = j;
    }
}

void dfs2(int u, int tp)
{
    top[u] = tp;
    dfn[u] = ++ num;
    if(son[u]) dfs2(son[u], tp);
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if(j == son[u] || j == f[u]) continue;
        dfs2(j, j);
    }
}

int lca(int x, int y)
{
    while(top[x] != top[y])
    {
        if(d[top[x]] < d[top[y]]) swap(x, y);
        x = f[top[x]];
    }
    return d[x] < d[y] ? x : y;
}

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

int dfs(int u)
{
    int res = 0, mn = 0;
    for (auto &j : g[u])
    {
        res += dfs(j);
        mn += dp[j];
    }
    if(vs[u]) res += mn, dp[u] = 1;
    else if(mn > 1) res ++, dp[u] = 0;
    else dp[u] = mn;
    g[u].clear(); vs[u] = 0;
    return res;
}

int main()
{
    n = read();
    for (int i = 1; i <= n; i ++) h[i] = -1;
    for (int i = 1; i <= n - 1; i ++)
    {
        int a = read(), b = read();
        add(a, b); add(b, a);
    }
    dfs1(1, 0);dfs2(1, 1);
    m = read();
    while(m --)
    {
        int flag = 1;
        k = read();
        for (int i = 1; i <= k; i ++) a[i] = read(), vs[a[i]] = 1;
        for (int i = 1; i <= k; i ++)
            if(vs[a[i]] && vs[f[a[i]]])
            {
                flag = 0;
                break;
            }
        if(!flag)
        {
            for (int i = 1; i <= k; i ++)
                vs[a[i]] = 0;
            puts("-1");
            continue;
        }
        sort(a + 1, a + k + 1, cmp);
        sz = 0;
        stac[++ sz] = a[1];
        for (int i = 2; i <= k; i ++)
        {
            int z = lca(stac[sz], a[i]);
            while(d[z] < d[stac[sz - 1]])
            {
                g[stac[sz - 1]].push_back(stac[sz]);
                sz --;
            }
            if(z != stac[sz])
            {
                g[z].push_back(stac[sz]);
                if(z == stac[sz - 1]) sz --;
                else stac[sz] = z;
            }
            stac[++ sz] = a[i];
        }
        while(-- sz) g[stac[sz]].push_back(stac[sz + 1]);
        printf("%d
", dfs(stac[1]));
    }
}