2020牛客多校五 B. Graph (异或最小生成树+01trie)

题意：给你一棵树，每条边都有边权，可以任意加边或删边，但要保证图始终连通且一个环上边的异或和为0。求操作后最小边权和。

题解：异或最小生成树+01trie
同CF 888G，不过这题要将边权转化为点权，这个过程dfs即可。

为什么可以转换成固定的点权呢？我们可以发现，无论加边还是删边，任意两点间的路径异或和始终不变，因为两点若有多条路径，这些路径边权和之间的异或始终为0，也就是相等。所以我们可以固定点权，两点的点权异或就是边权。

接下来就是一样的思路了。

Boruvka算法，求最小生成树的另一种方法，每一次选择连通块之间最小的边，然后连接两个连通块，我们可以用这种思想来求mst。而另外两种求mst的，肯定得n²预处理完全图的边权，必然超时。

对于异或，我们首先想到01trie来维护异或和。

我们先将每一个点按照权值从高位到低位插入01trie， 连接的话就是叶子结点之间通过lca相连了，由于我们要求mst，肯定希望两点的异或值越小越好，也就是高位越深越好，那么就是lca越深越好了，这就是为什么我们一开始选择从高位到低位插入01trie的原因。从低到高插一般都是要修改点权的情况。

接下来我们考虑dfs整个01trie，对于一个lca结点，枚举其左子树的所有叶子结点，在右子树中找到最小的异或边权，进行合并即可（Boruvka思想的体现）。

答案就是这些边的和。当然我们将点权从小到大加入01trie中，这样一个连通块始终在一个连续区间内，方便我们dfs。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<fstream>
#include<set>
#include<map>
#include<sstream>
#include<iomanip>
#define ll long long
using namespace std;
const int maxn = 1e5 + 5;
const int maxm = 2e5 + 5;
int cnt, siz[maxn * 30], nex[maxn * 30][2];
int n, a[maxn], rt;
int head[maxn], k;
struct node {
    int next, v, w;
}edge[maxm];
void add(int u, int v, int w) {
    edge[++k].next = head[u];
    edge[k].v = v;
    edge[k].w = w;
    head[u] = k;
}
void insert(int x) {
    int p = 0;
    for (int i = 30; i >= 0; i--) {
        int c = (x >> i) & 1;
        if (!nex[p][c]) nex[p][c] = ++cnt;  // 如果没有，就添加结点
        p = nex[p][c];
        siz[p]++;
    }
}
ll query(int o, int x, int dp) {
    if (dp < 0) return 0;
    ll ans = 1 << dp;
    for (int i = dp - 1; i >= 0; i--) {
        int c = (x >> i) & 1;
        if (nex[o][c]) o = nex[o][c];
        else o = nex[o][c ^ 1], ans |= 1 << i;
    }
    return ans;
}
ll re;
void dfs(int o, int l, int r, int dp) {
    if (dp < 0) return;
    if (nex[o][0] && nex[o][1]) {
        int mid = l + siz[nex[o][0]] - 1;
        ll ans = 1e18;
        dfs(nex[o][0], l, mid, dp - 1);
        dfs(nex[o][1], mid + 1, r, dp - 1);
        for (int i = l; i <= mid; i++) {
            ans = min(ans, query(nex[o][1], a[i], dp - 1));
        }
        re += ans;
    }
    else if (nex[o][0]) dfs(nex[o][0], l, r, dp - 1);
    else if (nex[o][1]) dfs(nex[o][1], l, r, dp - 1);
}
void dfs0(int u, int pre) {
    for (int i = head[u]; i; i = edge[i].next) {
        int v = edge[i].v;
        int w = edge[i].w;
        if (v == pre) continue;
        a[v] = a[u] ^ w;
        dfs0(v, u);
    }
}
int u, v, w;
int main() {
    scanf("%d", &n);
    for (int i = 1; i < n; i++) {
        scanf("%d%d%d", &u, &v, &w); ++u, ++v;
        add(u, v, w);
        add(v, u, w);
    }
    dfs0(1, -1);
    sort(a + 1, a + n + 1);
    for (int i = 1; i <= n; i++) insert(a[i]);
    dfs(1, 1, n, 30);
    printf("%lld\n", re);
	return 0;
}