Min of Restricted Sum

#include <bits/stdc++.h>
using namespace std;
 
vector<pair<int, int>> adj[202020];
 
bool visited[202020];
 
int root[202020], sz[202020];
 
void preprocessGraph(int cur) {
    visited[cur] = true;
 
    int r = root[cur];
    sz[r]++;
 
    for (auto [child, _] : adj[cur]) {
        if (visited[child]) continue;
        root[child] = r;
        preprocessGraph(child);
    }
}
 
bool impossible = false;
bool isSet[202020];
int setCnt[202020];
 
void calcSetCnt(int b, int cur) {
    visited[cur] = true;
 
    setCnt[root[cur]] += isSet[cur];
 
    for (auto [child, z] : adj[cur]) {
        if (visited[child]) {
            if ((isSet[cur] ^ isSet[child]) != ((z >> b) & 1))
                impossible = true;
            continue;
        }
 
        isSet[child] = isSet[cur] ^ ((z >> b) & 1);
        calcSetCnt(b, child);
    }
}
 
int A[202020];
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int N, M;
    cin >> N >> M;
 
    for (int i = 1; i <= M; i++) {
        int X, Y, Z;
        cin >> X >> Y >> Z;
 
        adj[X].emplace_back(Y, Z);
        adj[Y].emplace_back(X, Z);
    }
 
    for (int v = 1; v <= N; v++) {
        if (visited[v]) continue;
        root[v] = v;
        preprocessGraph(v);
    }
 
    for (int b = 0; b < 31; b++) {
        fill(visited + 1, visited + N + 1, false);
        fill(isSet + 1, isSet + N + 1, false);
        fill(setCnt + 1, setCnt + N + 1, 0);
 
        for (int v = 1; v <= N; v++) {
            if (not visited[v]) {
                calcSetCnt(b, v);
 
                if (impossible) {
                    cout << -1;
                    return 0;
                }
            }
 
            int r = root[v];
            bool invert = setCnt[r] > sz[r] - setCnt[r];
 
            A[v] |= (isSet[v] ^ invert) << b;
        }
    }
 
    for (int i = 1; i <= N; i++) cout << A[i] << ' ';
 
    return 0;
}