【并查集】冗余连接

冗余连接

删除一条边成为树，不成环就是树了，如果发现合并当前边的两个节点，在同一集合中，则应该删除这条边

class Solution {
public:
    // 从前往后合并节点，如果两个节点不在一个集合中，就合并
    // 如果两个节点已经在一个集合中了，再合并就成环了，此时可以直接返回当前边
    int parent[10001];

    int rfind(int x){
        if(x == parent[x]) return x;
        parent[x] = rfind(parent[x]);
        return parent[x];
    }

    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
        int n = edges.size();
        for(int i = 0; i <= n; i++) parent[i] = i;
        for(vector<int> edge : edges){
            int x = rfind(edge[0]);
            int y = rfind(edge[1]);
            if(x != y) parent[x] = y;  // 连接不同树的根节点
            else return edge;
        }
        return {};
    }
};

冗余连接II

题目中的图原本是是一棵树，在不增加节点的情况下多加了一条边。在树中所有节点的入度都是1，如果有环则存在两种情况

情况1：存在入度为2的节点

我们先找出入度为2的节点，并找到对应的边（一定是两个），遍历所有的边，看不使用这两条边的哪一个可以构成树，就返回哪条边

情况2：不存在入度为2的节点，存在有向环

无入度为2的节点，但是存在有向环，表示删除环中哪条边都可以，从前往后在图中加入边，一旦成环就返回，这样可以返回出现在edges中靠后的边

class Solution {
public:
    int parent[10001];
    int n;

    void init(){
        for(int i = 0; i <= n; i++) parent[i] = i;
    }

    int find(int x){
        while(x != parent[x]) x = parent[x];
        return x;
    }

    // 判断删除当前边后，是否能构成树
    bool isTreeDeleteEdge(vector<vector<int>>& edges, int del){
        for(int i = 0; i < n; i++){
            if(i == del) continue;
            int x = find(edges[i][0]);
            int y = find(edges[i][1]);
            // 不使用待删除的边，依然能成环，表示删除了del这条边，也不能使图变成树
            if(x == y) return false;
            parent[y] = x;
        }
        return true;
    }

    vector<int> getDelEdge(vector<vector<int>>& edges){
        // 成环表示删除环中哪条边都可以，从前往后在图中加入边，一旦成环就返回，这样可以返回出现在edges中靠后的边
        for(int i = 0; i < n; i++){
            int x = find(edges[i][0]);
            int y = find(edges[i][1]);
            if(x == y) return edges[i]; // 成环了，直接返回
            parent[y] = x;
        }
        return {};
    }

    vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
        n = edges.size();
        vector<int> in_degree(n + 1, 0);  // 统计每个节点的入度
        for (auto edge : edges) in_degree[edge[1]]++;
        
        // 统计指向入度为2的节点的两条边
        vector<int> vec;
        for (int i = 0; i < n; i++) {
            if (in_degree[edges[i][1]] == 2) vec.push_back(i);
        }

        init();
        // 情况1：如果存在入度为2的边，那一定是两条边
        if(vec.size() == 2){
        	// 先试探vec[1]，因为题目要求返回靠后的边
            if (isTreeDeleteEdge(edges, vec[1])) return edges[vec[1]];
            else return edges[vec[0]];
        }

        // 情况2：不存在入度为2的边，图中存在有向环
        return getDelEdge(edges);
    }
};