洛谷P3233 世界树

题意：给定树上k个关键点，每个点属于离他最近，然后编号最小的关键点。求每个关键点管辖多少点。

解：虚树 + DP。

虚树不解释。主要是DP。用二元组存虚树上每个点的归属和距离。这一部分是二次扫描与换根法。

然后把关键点改为虚树节点，统计每个虚树节点管辖多少个节点，用SIZ表示，初始时SIZ = siz，SIZ[RT] = n。

如果一条虚树边两端点的归属相同。那么SIZ[fa] -= siz[son]

否则树上倍增找到y是最靠上属于的son的，然后SIZ[fa] -= siz[y] SIZ[son] = siz[y]

#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>

typedef long long LL;
const int N = 300010, INF = 0x3f3f3f3f;

struct Edge {
    int nex, v, len;
}edge[N * 2], EDGE[N * 2]; int tp, TP;

struct Node {
    int x, d;
    Node(int X = 0, int D = 0) {
        x = X;
        d = D;
    }
}small[N];

int e[N], E[N], RT, siz[N], d[N], num, pos[N], pw[N], Time, imp[N], stk[N], top, now[N], imp2[N];
int ans[N], fr[N], SIZ[N], n, fa[N][20], use[N];

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

inline void ADD(int x, int y) {
//    printf("ADD %d %d \n", x, y);
    TP++;
    EDGE[TP].v = y;
    EDGE[TP].len = d[y] - d[x];
    EDGE[TP].nex = E[x];
    E[x] = TP;
    return;
}

inline bool cmp(const int &a, const int &b) {
    return pos[a] < pos[b];
}

void DFS_1(int x, int father) {
    fa[x][0] = father;
    d[x] = d[father] + 1;
    siz[x] = 1;
    pos[x] = ++num;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == father) {
            continue;
        }
        DFS_1(y, x);
        siz[x] += siz[y];
    }
    return;
}

inline int lca(int x, int y) {
    if(d[x] > d[y]) {
        std::swap(x, y);
    }
    int t = pw[n];
    while(t >= 0 && d[x] < d[y]) {
        if(d[fa[y][t]] >= d[x]) {
            y = fa[y][t];
        }
        t--;
    }
    if(x == y) {
        return x;
    }
    t = pw[n];
    while(t >= 0 && fa[x][0] != fa[y][0]) {
        if(fa[x][t] != fa[y][t]) {
            x = fa[x][t];
            y = fa[y][t];
        }
        t--;
    }
    return fa[x][0];
}

inline void clear(int x) {
    if(use[x] != Time) {
        use[x] = Time;
        E[x] = 0;
    }
    return;
}

inline void build_t(int k) {
    std::sort(imp + 1, imp + k + 1, cmp);
    TP = top = 0;
    clear(imp[1]);
    stk[++top] = imp[1];
    for(int i = 2; i <= k; i++) {
        int x = imp[i], y = lca(stk[top], x);
        clear(x); clear(y);
        while(top > 1 && pos[y] <= pos[stk[top - 1]]) {
            ADD(stk[top - 1], stk[top]);
            top--;
        }
        if(y != stk[top]) {
            ADD(y, stk[top]);
            stk[top] = y;
        }
        stk[++top] = x;
    }
    while(top > 1) {
        ADD(stk[top - 1], stk[top]);
        top--;
    }
    RT = stk[top];
    return;
}

void out_t(int x) {
    printf("out x = %d \n", x);
    for(int i = E[x]; i; i = EDGE[i].nex) {
        int y = EDGE[i].v;
//        printf("EDGE %d y %d \n", i, y);
        out_t(y);
    }
    return;
}

void getSmall(int x) {
    (now[x] == Time) ? small[x] = Node(x, 0) : small[x] = Node(n + 1, INF);
//    printf("getSmall x = %d small = %d \n", x, small[x].x);
    SIZ[x] = siz[x];
    for(int i = E[x]; i; i = EDGE[i].nex) {
        int y = EDGE[i].v;
        getSmall(y);
        if(small[x].d > small[y].d + EDGE[i].len) {
            small[x] = small[y];
            small[x].d += EDGE[i].len;
        }
        else if(small[x].d == small[y].d + EDGE[i].len) {
            small[x].x = std::min(small[x].x, small[y].x);
        }
    }
    return;
}

void getEXsmall(int x, Node t) {
//    printf("EX x = %d small = %d \n", x, small[x].x);
    if(small[x].d > t.d || (small[x].d == t.d && small[x].x > t.x)) {
        small[x] = t;
    }
//    printf("x = %d small = %d \n", x, small[x].x);
    for(int i = E[x]; i; i = EDGE[i].nex) {
        int y = EDGE[i].v;
        getEXsmall(y, Node(small[x].x, small[x].d + EDGE[i].len));
    }
    return;
}

inline int getPos(int x, int f) {
    int t = pw[d[x] - d[f]], y = x;
    while(t >= 0) {
        int mid = fa[y][t];
        if(d[x] - d[mid] + small[x].d < d[mid] - d[f] + small[f].d) {
            y = mid;
        }
        else if(d[x] - d[mid] + small[x].d == d[mid] - d[f] + small[f].d && small[f].x > small[x].x) {
            y = mid;
        }
        t--;
    }
    return y;
}

void del(int x, int f) {
//    printf("del x = %d small = %d %d \n", x, small[x].x, small[x].d);
    if(f) {
        if(small[x].x == small[f].x) {
            SIZ[f] -= siz[x];
//            printf("SIZ %d -= %d = %d \n", f, siz[x], SIZ[f]);
        }
        else {
            int y = getPos(x, f);
            SIZ[f] -= siz[y];
//            printf("SIZ %d -= %d = %d \n", f, siz[y], SIZ[f]);
            SIZ[x] = siz[y];
//            printf("SIZ %d = siz %d  %d \n", x, y, siz[y]);
        }
    }
    for(int i = E[x]; i; i = EDGE[i].nex) {
        int y = EDGE[i].v;
        del(y, x);
    }
    ans[small[x].x] += SIZ[x];
    return;
}

inline void solve() {
    int k;
    scanf("%d", &k);
    Time++;
    for(int i = 1; i <= k; i++) {
        scanf("%d", &imp[i]);
        now[imp[i]] = Time;
        ans[imp[i]] = 0;
    }
    memcpy(imp2 + 1, imp + 1, k * sizeof(int));
    build_t(k);

//    out_t(RT);
    // get Small
    getSmall(RT); // get Size
    getEXsmall(RT, Node(n + 1, INF));
    //
    SIZ[RT] = n;
    del(RT, 0);
    for(int i = 1; i <= k; i++) {
        printf("%d ", ans[imp2[i]]);
    }
    printf("\n");
    return;
}

int main() {

//    freopen("in.in", "r", stdin);
//    freopen("a.out", "w", stdout);

    scanf("%d", &n);
    for(int i = 1, x, y; i < n; i++) {
        scanf("%d%d", &x, &y);
        add(x, y);
        add(y, x);
    }
    DFS_1(1, 0);
    for(int i = 2; i <= n; i++) {
        pw[i] = pw[i >> 1] + 1;
    }
    for(int j = 1; j <= pw[n]; j++) {
        for(int i = 1; i <= n; i++) {
            fa[i][j] = fa[fa[i][j - 1]][j - 1];
        }
    }
    int q;
    scanf("%d", &q);
    while(q--) {
        solve();
    }
    return 0;
}