[题解] CF1882D - Tree XOR

合集 - 题解(13)

1.[题解] CF1328E Tree Queries2023-09-072.[题解] AtCoder Beginner Contest 308 A~G2023-09-073.[题解] CF1526C2 Potions2023-09-084.[题解] CF29D Ant on the Tree2023-09-095.[题解] Codeforces Round 895 (Div. 3) F~G2023-09-096.[题解} CF1217D Coloring Edges2023-09-107.[题解] CF1873H - Mad City2023-09-228.[题解] Codeforces Round 900（Div.3） E~F2023-09-27

9.[题解] CF1882D - Tree XOR2023-09-27

10.[题解] CF1003E - Tree Constructing2023-09-2911.[题解] CF632F - Swimmers in the Pool2023-10-0312.[题解] CF1245D - Shichikuji and Power Grid2023-10-0613.[题解] CF1790E - XOR Tree2023-10-17

收起

CF1882D - Tree XOR

知识点：换根 DP 。

主要难点是要思考如何操作使得代价最小，这个过程是一个贪心的过程。想到怎么操作，计算答案的过程就是一个板子换根了。

题意

给定一颗 $n$ 个节点的树，点 $i$ 具有权值 $a_i$ 。现在需要你不断执行以下操作，使得树上所有点的权值相等。

• 记当前根节点为 $root$ ，一次操作中，可以选择一个点 $v$ 和任意整数 $c$ ，将 $v$ 子树内所有节点的权值异或 $c$ ，代价为一次异或的节点数量。

问当根节点为 $root=1,2,\cdots ,n$ 时，使得树上所有节点权值相等的最小代价为多少。

思路

假设我们现在选择一个点 $v$ ，我们要对其进行操作。如果其子树内存在节点，权值不等于 $a_v$ ，那么意味着我们无论怎么操作，都不可能使得树上所有点相等。

因此，如果如此递归考虑，那么我们每次执行操作，必然是从叶子节点到根节点，每次操作都是让当前节点 $u$ 子树的所有节点权值改为 $a_u$ ，直到最后的根节点，这样代价才能达到最小。

设 $v$ 是 $u$ 的儿子节点，那么按照我们上述所说的思路，这次操作的代价应该为 $cos{t}_v+siz{e}_v\times (a_u\oplus a_v)$ ，其中 $cos{t}_v$ 是将 $v$ 的所有子树节点权值更改为 $a_v$ 的代价。

但是，我们现在考虑的代价只是以一个根节点进行考虑的，并不是 $n$ 个根节点轮流的情况，此时我们可以考虑，在计算了一个根节点的情况上，计算这个节点是根节点的代价，也就是换根 dp 。

设 $f(x)=cos{t}_x$ ，表示在根节点为 $root$ 的情况下（不妨设 $root=1$ ），将 $x$ 的所有子树节点权值改为 $a_x$ 的代价； $g(x)$ 为把除了 $x$ 的子树以外的节点权值改为 $a_x$ 的代价。那么，$f(x)$ 的状态方程即为：

$$f(u)=f(v)+siz{e}_v\times (a_u\oplus a_v)$$

对于 $g(x)$ ，我们使用换根 dp 经典的计算方式即可。

$$g(v)=f(u)-f(v)-siz{e}_v\times (a_u\oplus a_v)+g(u)+(n-siz{e}_v)\times (a_u\oplus a_v)$$

最后计算结果，$ans(x)=f(x)+g(x)$ 。

实现

auto Main() -> void {
    int n;
    std::cin >> n;
    
    std::vector<i64> vw(n);
    for (auto &x : vw) {
        std::cin >> x;
    }
    std::vector adj(n, std::vector<int>{});
    for (int i = 0; i < n - 1; i ++) {
        int u, v;
        std::cin >> u >> v;
        u --; v --;
        adj[u].emplace_back(v);
        adj[v].emplace_back(u);
    }
 
    std::vector<int> siz(n);
    std::vector<i64> dp1(n), dp2(n);
    auto dfs1 = [&](auto &self, int from, int come) -> void {
        siz[from] = 1;
        for (auto to : adj[from]) {
            if (to == come) {
                continue;
            }
            self(self, to, from);
            siz[from] += siz[to];
            dp1[from] += dp1[to] + (i64(vw[from] ^ vw[to]) * siz[to]);
        }
    };
    dfs1(dfs1, 0, -1);
 
    auto dfs2 = [&](auto &self, int from, int come) -> void {
        if (come != -1) {
            dp2[from] = dp1[come] - dp1[from] - (i64(vw[come] ^ vw[from]) * siz[from]) + dp2[come] + (i64(vw[from] ^ vw[come]) * (n - siz[from]));
        }
        for (auto to : adj[from]) {
            if (to != come) {
                self(self, to, from);
            }
        }
    };
    dfs2(dfs2, 0, -1);
 
    for (int i = 0; i < n; i ++) {
        std::cout << dp1[i] + dp2[i] << " \n"[i + 1 == n];
    }
}