P3233 世界树 虚树+树形DP

//#define LOCAL
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f7f7f7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define PiL pair <ll , ll>
#define PLL pair <ll , ll>
#define Pii pair <int , int>
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)

template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

int n , m;
const int N = 300005;
struct node
{
    int w , t , next;
}edge[N << 1], sx_edge[N << 1];
int head[N] , cnt;
int Head[N] , Cnt;
void Add (int f, int t, int w)
{
    sx_edge[Cnt].t = t;
    sx_edge[Cnt].w = w;
    sx_edge[Cnt].next = Head[f];
    Head[f] = Cnt ++;
}
void add (int f, int t, int w)
{
    edge[cnt].t = t;
    edge[cnt].w = w;
    edge[cnt].next = head[f];
    head[f] = cnt ++;
}
int vis[N], ans[N], qes[N], tem[N];
Pii dp[N];
int dfn[N], siz[N], dis[N], times;
int bz[N][30] , deep[N];
int st[N] , top = 0;
bool cmp (int x, int y) { return dfn[x] < dfn[y];}
void dfs (int u , int fa, int dep)
{
    deep[u] = dep;
    dfn[u] = ++ times;
    siz[u] = 1;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if (v != fa)
        {
            bz[v][0] = u;
            dis[v] = dis[u] + 1;
            dfs (v, u, dep + 1);
            siz[u] += siz[v];
        }
    }
}
void deal()
{
    for (int i = 1 ; i <= 25 ; i ++)
        for (int j = 1 ; j <= n ; j ++)
            bz[j][i] = bz[bz[j][i-1]][i-1];
}
int LCA(int x,int y)
{
    if(deep[x] < deep[y])
        swap(x,y);
    int t = deep[x] - deep[y];
    for(int i = 0; (1<<i) <= t ; i ++)
        if((1<<i)&t)x=bz[x][i];
    for(int i=19 ; i >= 0 ; i--)
        if(bz[x][i] ^ bz[y][i])
            x=bz[x][i], y=bz[y][i];
    if(x==y) return x;
    return bz[x][0];
}
int Dis(int u , int v)
{
    int lca = LCA(u , v);
    return dis[u] + dis[v] - 2 * dis[lca];
}
void calc(int x, int y)
{
    int son = y , mid = y;
    for(int i = 20 ; i >= 0 ; i --)
        if(deep[bz[son][i]] > deep[x])
            son = bz[son][i];
    ans[dp[x].se] -= siz[son];
    //两端的覆盖点相同
    if(dp[x].se == dp[y].se)
    {
        ans[dp[x].se] += siz[son] - siz[y];
        return;
    }
    //两端覆盖点不同
    for (int i = 20 ; i >= 0 ; i --){
        int nxt = bz[mid][i];
        if (deep[nxt] <= deep[x]) continue;
        //d1 d2 是覆盖点到mid的距离
        int d1=Dis(dp[y].se,nxt) , d2=Dis(dp[x].se,nxt);
        //如果d1 == d2,由于代码默认将mid节点给y，所以当相等时被y覆盖的编号需要小于x
        if (d1 < d2||(d1  == d2 && dp[y].se < dp[x].se)) {
            mid=nxt;
        }
    }
    ans[dp[x].se] += siz[son]-siz[mid];
    ans[dp[y].se] += siz[mid]-siz[y];
}
void dfs1 (int u , int fa)
{
    dp[u].fi = INF , dp[u].se = u;
    if (vis[u]) dp[u].fi = 0;
    for (int i = Head[u] ; i != -1 ; i = sx_edge[i].next)
    {
        int v = sx_edge[i].t;
        int w = Dis(u , v);
        if (v != fa)
        {
            dfs1 (v, u);
            if (dp[u].fi > dp[v].fi + w)
            {
                dp[u].fi = dp[v].fi + w;
                dp[u].se = dp[v].se;
            }
            else if (dp[u].fi == dp[v].fi + w)
                dp[u].se = min (dp[v].se , dp[u].se);
        }
    }
}
void dfs2 (int u , int fa)
{
    for (int i = Head[u] ; i != -1 ; i = sx_edge[i].next)
    {
        int v = sx_edge[i].t;
        int w = Dis(u , v);
        if (v != fa)
        {
            if (dp[u].fi + w < dp[v].fi)
                dp[v].fi = dp[u].fi + w, dp[v].se = dp[u].se;
            else if (dp[u].fi + w == dp[v].fi)
                dp[v].se = min (dp[v].se , dp[u].se);
            calc (u ,v);
            dfs2 (v, u);
        }
    }
    //不在虚树中的部分
    ans[dp[u].se] += siz[u];
    Head[u] = -1;
}
void insert(int x)
{
    if(top == 1) {st[++top] = x; return ;}
    int lca = LCA(x, st[top]);
    if(lca == st[top]) {st[++top] = x; return ;}
    while(top > 1 && dfn[st[top - 1]] >= dfn[lca]) {
        // cout << st[top-1] <<" "<< st[top]<<endl;
        Add(st[top - 1], st[top], 1), top--;
    }
    if(lca != st[top]) {
        // cout << lca <<" "<< st[top]<<endl;
        Add(lca, st[top], 1), st[top] = lca;
    }
    st[++top] = x;
}
int main()
{
    read (n);
    mem (head, -1);
    mem (Head, -1);
    for (int i = 1 ; i < n ; i ++)
    {
        int u , v;
        read (u , v);
        add (u , v , 1);
        add (v , u , 1);
    }
    dfs (1, 1, 1);
    deal();
    int Q, k;
    read (Q);
    while (Q --)
    {
        int flag = 0;
        Cnt = top = 0;
        read (k);
        for (int i = 1 ; i <= k ; i ++)
        {
            read (qes[i]) ;
            vis[qes[i]] = 1;
            tem[i] = qes[i];
            if(qes[i] == 1)
                flag = 1;
        }
        //因为有可能根节点不是关键节点，所以特判
        if (!flag)
            st[++ top] = 1;
        //建立虚树
        sort(qes+1 , qes+1+k, cmp);
        for(int i = 1 ; i <= k ; i ++)
            insert(qes[i]);
        while(-- top)
            Add(st[top], st[top + 1], 1);
        //虚树上换根DP
        dfs1 (1, 1);
        dfs2 (1, 1);
        for (int i = 1 ; i <= k ; i ++)
            write(ans[tem[i]]), SP , ans[tem[i]] = 0, vis[tem[i]] = 0;
        LF;
    }

}
/*
7
1 2
2 3
2 4
4 5
5 6
6 7
5
2
3 7

8
1 2
2 3
2 4
4 5
5 6
6 7
7 8
5
2
3 7
 */