LeetCode 685 冗余连接II 并查集的应用

理解题意

树为N个节点N-1条边且只有一个入度为0的节点的有向图结构
输入:在一颗树上加了一条边的有向图
输出:一条边（输入的有向图去除这条边后会变成树）
若有多个答案则输出最后的一个。

思路分析

1. 附加的边指向根节点

这种情况下每个节点都有且仅有一个父节点，且必有环
则输出的附加的边为构成这个环的边中最后输入的。

2. 附加的边不指向根节点

这种情况下必有一个节点有两个父节点，可能有环也可能无环。
加入一条边使一个节点出现两个父节点的情况，则称这种情况为出现矛盾。
1）若无环则输出附加的边就为出现矛盾的边
2）若有环则输出附加的边为有两个父节点的节点关联的两条边中不是产生矛盾的那条边。
有一种情况使一条边即产生矛盾又产生环，则优先记为矛盾。

代码

根据思路来
用int[] pre记录每个节点的父节点，初始化时每个节点的父节点都为自己。
遍历每一条边，修改pre[]数组，如果产生矛盾，则用conflict=i记录这条边
当不产生矛盾时，用并查集来判断是否有环（两个节点的ancestor相同则有环），若有环则用circle=i记录这条边，若无环则在并查集中将两个连通分量合并。
遍历完所有边后按思路里的3种情况判断输出。

class Solution {
    int[] pre;
    public int[] findRedundantDirectedConnection(int[][] edges) {
        //初始化
        UnionFind unionFind = new UnionFind(edges.length+1);
        pre = new int[edges.length+1];
        for(int i=0;i<pre.length;i++){
            pre[i]=i;
        }
        //遍历每条边
        int[] edge;
        int node1;
        int node2;
        int circle = -1;
        int conflict = -1;
        for(int i=0;i<edges.length;i++){
            edge=edges[i];
            node1=edge[0];
            node2=edge[1];
            if(pre[node2]==node2){
                //如果
                pre[node2]=node1;
                if(unionFind.find(node1)==unionFind.find(node2)){
                    circle = i;
                }else{
                    unionFind.union(node1,node2);
                }
            }else{
                conflict=i;
            }
        }
        if(conflict<0){
            return edges[circle];
        }else{
            if(circle<0){
                return edges[conflict];
            }else{
                return new int[]{pre[edges[conflict][1]],edges[conflict][1]};
            }
        }
    }
}
//并查集
class UnionFind {
    int[] ancestor;
    public UnionFind(int n){
        ancestor = new int[n];
        for(int i=0;i<n;i++){
            ancestor[i]=i;
        }
    }
    public void union(int node1,int node2){
        ancestor[find(node1)] =find(node2);
    }
    public int find(int node){
        if(ancestor[node]!=node){
            return find(ancestor[node]);
        }
        return node;
    }
}