洛谷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 = , INF = 0x3f3f3f3f;

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

 struct Node {
     int x, d;
     Node(int X = , int D = ) {
         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][], 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][] = father;
     d[x] = d[father] + ;
     siz[x] = ;
     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 >=  && 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 >=  && fa[x][] != fa[y][]) {
         if(fa[x][t] != fa[y][t]) {
             x = fa[x][t];
             y = fa[y][t];
         }
         t--;
     }
     return fa[x][];
 }

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

 inline void build_t(int k) {
     std::sort(imp + , imp + k + , cmp);
     TP = top = ;
     clear(imp[]);
     stk[++top] = imp[];
     for(int i = ; i <= k; i++) {
         int x = imp[i], y = lca(stk[top], x);
         clear(x); clear(y);
         while(top >  && pos[y] <= pos[stk[top - ]]) {
             ADD(stk[top - ], stk[top]);
             top--;
         }
         if(y != stk[top]) {
             ADD(y, stk[top]);
             stk[top] = y;
         }
         stk[++top] = x;
     }
     while(top > ) {
         ADD(stk[top - ], 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, ) : small[x] = Node(n + , 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 >= ) {
         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 = ; i <= k; i++) {
         scanf("%d", &imp[i]);
         now[imp[i]] = Time;
         ans[imp[i]] = ;
     }
     memcpy(imp2 + , imp + , k * sizeof(int));
     build_t(k);

 //    out_t(RT);
     // get Small
     getSmall(RT); // get Size
     getEXsmall(RT, Node(n + , INF));
     //
     SIZ[RT] = n;
     del(RT, );
     for(int i = ; 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 = , x, y; i < n; i++) {
         scanf("%d%d", &x, &y);
         add(x, y);
         add(y, x);
     }
     DFS_1(, );
     for(int i = ; i <= n; i++) {
         pw[i] = pw[i >> ] + ;
     }
     for(int j = ; j <= pw[n]; j++) {
         for(int i = ; i <= n; i++) {
             fa[i][j] = fa[fa[i][j - ]][j - ];
         }
     }
     int q;
     scanf("%d", &q);
     while(q--) {
         solve();
     }
     return ;
 }

AC代码