[HNOI2014]世界树

· 题解

　　参考hzwer

　　首先看到M_i的条件想到构造虚树。

　　虚树中的一条边已经覆盖了整个出现在这条边上的点的子树的情况。

　　那么只需倍增查找所属议事处有变化的边界节点，同时计算这两段节点的贡献即可。

· 代码

 

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

using namespace std;

const int MAXN = 3e05 + 10;
const int MAXM = 3e05 + 10;

struct LinkedForwardStar {
    int to;
    
    int next;
} ;

LinkedForwardStar Link[MAXM << 1];
int Head[MAXN]= {0};
int size = 0;

void Insert (int u, int v) {
    Link[++ size].to = v;
    Link[size].next = Head[u];
    
    Head[u] = size;
}

const int Root = 1;

int Deep[MAXN];

int Size[MAXN];

int Dfn[MAXN];
int dfsord = 0;

int Father[MAXN][23];

void DFS (int root, int father) {
    Dfn[root] = ++ dfsord;
    Size[root] = 1;
    Father[root][0] = father;
    for (int j = 1; j <= 20; j ++) {
        if (! Father[root][j - 1])
            continue;
        
        Father[root][j] = Father[Father[root][j - 1]][j - 1];
    }
    
    for (int i = Head[root]; i; i = Link[i].next) {
        int v = Link[i].to;
        
        if (v == father)
            continue;
        
        Deep[v] = Deep[root] + 1;
        
        DFS (v, root);
        
        Size[root] += Size[v];
    }
}

int LCA (int x, int y) {
    if (Deep[x] < Deep[y])
        swap (x, y);
    
    int fx = x, fy = y;
    for (int j = 20; j >= 0; j --)
        if (Deep[Father[fx][j]] >= Deep[fy])
            fx = Father[fx][j];
    
    if (fx == fy)
        return fy;
    
    for (int j = 20; j >= 0; j --)
        if (Father[fx][j] != Father[fy][j]) {
            fx = Father[fx][j];
            fy = Father[fy][j];
        }
    
    return Father[fx][0];
}

int Dist (int x, int y) {
    int lca = LCA (x, y);
    return Deep[x] + Deep[y] - 2 * Deep[lca];
}

int N, Q;

int A[MAXN];

vector<int> Graph[MAXN];

int Stack[MAXN];
int top = 0;

int Belong[MAXN]= {0};

bool comp (const int& a, const int& b) {
    return Dfn[a] < Dfn[b];
}

void Insert_IvTree (int p) {
    if (! top) {
        Stack[++ top] = p;
        
        return ;
    }
    
    int lca = 0;
    while (top > 0) {
        lca = LCA (Stack[top], p);
        if (top > 1 && Deep[lca] < Deep[Stack[top - 1]])
            Graph[Stack[top - 1]].push_back(Stack[top]), top --;
        else if (Deep[lca] < Deep[Stack[top]]) {
            Graph[lca].push_back(Stack[top]), top --;
            break;
        }
        else
            break;
    }
    
    if (Stack[top] != lca)
        Stack[++ top] = lca;
    Stack[++ top] = p;
}

int M;

void Construct () {
    top = 0;
    if (Belong[Root] != Root)
        Stack[++ top] = Root;
    
    sort (A + 1, A + M + 1, comp);
    
    for (int i = 1; i <= M; i ++)
        Insert_IvTree (A[i]);
    while (top > 1)
        Graph[Stack[top - 1]].push_back(Stack[top]), top --;
}

int Rank[MAXN]= {0};

int Rest[MAXN]= {0};

void Get_BelSon (int root) {
    Rank[++ dfsord] = root;
    Rest[root] = Size[root];
    
    for (int i = 0; i < Graph[root].size(); i ++) {
        int v = Graph[root][i];
        
        Get_BelSon (v);
        
        if (! Belong[v])
            continue;
        
        int dist1 = Dist (Belong[root], root), dist2 = Dist (Belong[v], root);
        if (! Belong[root] || dist1 > dist2 || (dist1 == dist2 && Belong[root] > Belong[v]))
            Belong[root] = Belong[v];
    }
}

void Get_BelFat (int root) {
    for (int i = 0; i < Graph[root].size(); i ++) {
        int v = Graph[root][i];
        
        int dist1 = Dist (Belong[root], v), dist2 = Dist (Belong[v], v);
        if (! Belong[v] || dist1 < dist2 || (dist1 == dist2 && Belong[root] < Belong[v]))
            Belong[v] = Belong[root];
        
        Get_BelFat (v);
    }
}

int Count[MAXN]= {0};

void Calc (int u, int v) {
    int p = v;
    for (int j = 20; j >= 0; j --)
        if (Deep[Father[p][j]] > Deep[u])
            p = Father[p][j];
    
    Rest[u] -= Size[p];
    
    if (Belong[u] == Belong[v]) {
        Count[Belong[u]] += Size[p] - Size[v];
        return ;
    }
    
    int mid = v;
    for (int j = 20; j >= 0; j --) {
        if (Deep[Father[mid][j]] <= Deep[u])
            continue;
        
        int nextpos = Father[mid][j];
        int dist1 = Dist (Belong[v], nextpos), dist2 = Dist (Belong[u], nextpos);
        if (dist1 < dist2 || (dist1 == dist2 && Belong[v] < Belong[u]))
            mid = nextpos;
    }
    
    Count[Belong[u]] += Size[p] - Size[mid];
    Count[Belong[v]] += Size[mid] - Size[v];
}

int getnum () {
    int num = 0;
    char ch = getchar ();
    
    while (! isdigit (ch))
        ch = getchar ();
    while (isdigit (ch))
        num = num * 10 + ch - '0', ch = getchar ();
    
    return num;
}

int Orig[MAXN];

void Solve () {
    M = getnum ();
    
    for (int i = 1; i <= M; i ++)
        A[i] = Orig[i] = getnum ();
    
    for (int i = 1; i <= M; i ++)
        Belong[A[i]] = A[i];
    
    Construct ();
    
    dfsord = 0;
    Get_BelSon (Root), Get_BelFat (Root);
    
    for (int i = 1; i <= dfsord; i ++) {
        int u = Rank[i];
        for (int j = 0; j < Graph[u].size(); j ++) {
            int v = Graph[u][j];
            Calc (u, v);
        }
    }
    
    for (int i = 1; i <= dfsord; i ++)
        Count[Belong[Rank[i]]] += Rest[Rank[i]];
    
    for (int i = 1; i <= M; i ++) {
        if (i > 1)
            putchar (' ');
        printf ("%d", Count[Orig[i]]);
    }
    puts ("");
    
    for (int i = 1; i <= dfsord; i ++) {
        Graph[Rank[i]].clear();
        Count[Rank[i]] = Belong[Rank[i]] = Rest[Rank[i]] = 0;
    }
}

int main () {
    N = getnum ();
    
    for (int i = 1; i < N; i ++) {
        int u, v;
        u = getnum (), v = getnum ();
        
        Insert (u, v), Insert (v, u);
    }
    
    Deep[Root] = 1;
    DFS (Root, 0);
    
    Q = getnum ();
    
    for (int Case = 1; Case <= Q; Case ++)
        Solve ();
    
    return 0;
}

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