CF 1527D MEX Tree

题目意思大致是：给出一棵 $n$ 个点的树，点从 $0$ 到 $n-1$ 编号。定义一条路径的权值是路径上所有点编号的 $MEX$。对于每个 $0\le i\le n-1$求出 $MEX$ 为 $i$ 的路径有几条 ?

我们可以得到一个性质：当我们求出$AN{S}_i$ 和 $AN{S}_{i+1}$时,考虑最简单的容斥思想，$ME{X}_{i+1}=AN{S}_i-AN{S}_{i+1}$，$AN{S}_i$ 代表包含 $0-i$ 节点的所有路径。（PS ：路径是一条直线， 我们每次操作就是维护一条最小的路径包含所需的点，然后通过子树的大小计算路径数）

考虑维护一个左右端点，当且仅当 $i$ 点位于左端点或者右端点的子树上时，才有贡献，否则就是一种非法状态，直接跳出即可。

维护子树和一系列的父子节点的操作要用到$LCA$ 。

AC代码：

#include <bits/stdc++.h>

using namespace std;

vector <int> e[(int) 2e5 + 5];

struct LCA_MUL
{
    vector<int> dep;
    vector <long long> siz;
    vector<vector <int>> FA;
    LCA_MUL(int N) : dep(N + 5), siz(N + 5), FA(N + 5, vector <int> (25)) {}
    void DFS(int u, int fa)
    {
        dep[u] = dep[fa] + 1;
        FA[u][0] = fa;
        for (int i = 1; (1 << i) <= dep[u]; ++i)
        {
            FA[u][i] = FA[FA[u][i - 1]][i - 1];
        }
        siz[u] = 1;
        for(auto v : e[u])
        {
            if(v == fa)
                continue;
            DFS(v, u);
            siz[u] += siz[v];
        }
    }
    int LCA(int x, int y)
    {
        if (dep[x] < dep[y])
            swap(x, y);
        for (int i = 20; i >= 0; --i)
        {
            if (dep[FA[x][i]] >= dep[y])
                x = FA[x][i];
            if (x == y)
                return x;
        }
        for (int i = 20; i >= 0; --i)
        {
            if (FA[x][i] != FA[y][i])
                x = FA[x][i], y = FA[y][i];
        }
        return FA[x][0];
    }
};



signed main()
{
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);
    int t;
    cin >> t;
    while(t --)
    {
        long long n;
        cin >> n;
        for(int i = 1; i < n; ++i)
        {
            int u, v;
            cin >> u >> v;
            ++ u, ++ v;
            e[u].emplace_back(v);
            e[v].emplace_back(u);
        }
        int root = 1;
        LCA_MUL T(n + 5);
        T.DFS(root, 0);
        vector <long long> path_num(n + 5, 0);
        long long sum = 1;
        for(auto v : e[root])
        {
            path_num[root] += sum * T.siz[v];
            sum += T.siz[v];
        }
        int lst_left_node = root, lst_right_node = root;
        long long left_val = 0, right_val = 0;
        for(int i = 2; i <= n; ++i)
        {
            int new_left_node = T.LCA(i, lst_left_node);
            int new_right_node = T.LCA(i, lst_right_node);
            if(new_left_node == lst_left_node && new_right_node == root) // left_son_tree
            {
                if(lst_left_node == 1)
                {
                    left_val = T.siz[i];
                    int pos = i;
                    while(T.FA[pos][0] > 1)
                    {
                        pos = T.FA[pos][0];
                        left_val = T.siz[pos];
                    }
                }
                lst_left_node = i;
            }
            else if(new_left_node == root && new_right_node == lst_right_node) // right_son_tree
            {
                if(lst_right_node == 1)
                {
                    right_val = T.siz[i];
                    int pos = i;
                    while(T.FA[pos][0] > 1)
                    {
                        pos = T.FA[pos][0];
                        right_val = T.siz[pos];
                    }
                }
                lst_right_node = i;
            }
            else if(new_left_node != i && new_right_node != i)
            {
                break;
            }
            if(lst_left_node == 1)
            {
                path_num[i] = (n - right_val) * T.siz[lst_right_node];
            }
            else if(lst_right_node == 1)
            {
                path_num[i] = (n - left_val) * T.siz[lst_left_node];
            }
            else
                path_num[i] = T.siz[lst_left_node] * T.siz[lst_right_node];
        }
        for(int i = 1; i <= n + 1; ++i)
        {
            if(i == 1)
            {
                cout << 1ll * n * (n - 1) / 2 - path_num[root] << ' ';
            }
            else
            {
                cout << path_num[i - 1] - path_num[i] << ' ';
            }
        }
        cout << '\n';
        for(int i = 1; i <= n; ++i)
        {
            e[i].clear();
        }
    }
}