原题链接

分析

题可以拆成两部分考虑

第一部分，我们考虑。

如何处理，两个点之间的异或值。

因为异或具有传递性，因此当给定两个点时。

我们维护，一个d数组，去维护该点到父节点之间的异或值。

同时我们需要重写一下，我们的find函数，这个重写过程与更新距离的相似。

int find(int x)
{
    if(p[x]!=x)
    {
        int pre = p[x];
        p[x]=find(p[x]);
        d[x]=d[x]^d[pre];
    }
    return p[x];
}

我们首先判断两个点是否在同一个集合中。

在同一个集合中

假设两点为u,v，则u,v之间的异或值即为d[u]^d[v]

只需判断该点是否等于w即可

不等即产生矛盾

不在同一个集合中

设两节点u，v的父节点分别为pa，pb

则我们只需要，更新d[pa]到d[pb]的值即可

O pa    O pb
|	w   |
O a ——  O b
    

此时

d[pa]=w^d[a]^d[b]

考虑一个集合中，怎样得到最小的点权和

这个说实话，真的大概率想不到。

具体操作为

我们统计每个并查集中，按位拆开，统计每一位的1的个数

最后在枚举一遍，用一个ans记录答案

那如何根据每一位的1与0的个数，来最小化答案呢。

如果1的数量更少，那就让根节点在该位上取0

反之，则在该位上取1

这个取的过程不用真的实现，直接计算即可

LL ans = 0;
    for (int i = 1; i <= n; i++)
    {
        int pa = find(i);
        sum[pa] ++;
        for (int j = 0; j < 30; j++)
            if (d[i] & (1 << j)) 
            	num[pa][j] ++;
    }
    for (int i = 1; i <= n; i++)
        if (sum[i])
            for (int j = 0 ; j < 30; j++)
                ans += (1ll * min(num[i][j], sum[i] - num[i][j]) * (1ll << j));

Ac_code

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e5 + 10;
int p[N],d[N];
int num[N][35],sum[N];
int n,m;

int find(int x)
{
    if(p[x]!=x)
    {
        int pre = p[x];
        p[x]=find(p[x]);
        d[x]=d[x]^d[pre];
    }
    return p[x];
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++) p[i]=i;
    bool flag = 1;
    while(m--)
    {
        int u,v,w;
        cin>>u>>v>>w;
        int pa = find(u),pb = find(v);
        if(pa!=pb)
        {
            p[pa]=pb;
            d[pa]=w^d[v]^d[u];
        }
        else if((d[u]^d[v])!=w)
        {
            flag=0;
            break;
        }
    }
    if(!flag)
    {
        puts("-1");
        return 0;
    }
    LL ans = 0;
    for (int i = 1; i <= n; i++)
    {
        int pa = find(i);
        sum[pa] ++;
        for (int j = 0; j < 30; j++)
        {
            if (d[i] & (1 << j)) num[pa][j] ++;
        }
    }
    for (int i = 1; i <= n; i++)
        if (sum[i])
            for (int j = 0 ; j < 30; j++)
                ans += (1ll * min(num[i][j], sum[i] - num[i][j]) * (1ll << j));
                //对该集合来说，对应j位上的1的个数，还是0的个数，哪个少取那个
    printf("%lld\n", ans);
    return 0;
}