Leet Code Daily 2024-06-30 - Remove Max Number of Edges to Keep Graph Fully Traversable

class Solution {
public:
    int find(vector<int>& parent, int x) {
        if (parent[x] != x) {
            parent[x] = find(parent, parent[x]);
        }
        return parent[x];
    }

    int maxNumEdgesToRemove(int n, vector<vector<int>>& edges) {

        vector<vector<int>> parent(2, vector<int>(n));
        for (int x = 0; x < 2; x++) {
            iota(parent[x].begin(), parent[x].end(), 0);
        }

        vector<bool> used(edges.size(), false);
        for (int i = 2; i > 0; i--) {
            for (int j = 0; j < edges.size(); j++) {

                auto persons = [&]() {
                    return edges[j][0] == 3 ? vector<int>{0, 1}
                                            : vector<int>{edges[j][0] - 1};
                };

                auto u = [&]() -> int { return edges[j][1] - 1; };
                auto v = [&]() -> int { return edges[j][2] - 1; };

                int benefit = 0;

                for (const auto& x : persons()) {
                    if (find(parent[x], u()) != find(parent[x], v())) {
                        benefit++;
                    }
                }

                if (benefit != i) {
                    continue;
                }

                for (const auto& x : persons()) {
                    if (find(parent[x], u()) != find(parent[x], v())) {
                        parent[x][find(parent[x], u())] = find(parent[x], v());
                        used[j] = true;
                    }
                }
            }
        }

        for (int x = 0; x < 2; x++) {
            for (int i = 1; i < n; i++) {
                if (find(parent[x], i) != find(parent[x], 0)) {
                    return -1;
                }
            }
        }

        return edges.size() - count(used.begin(), used.end(), true);
    }
};