leetcode 685冗余连接2

https://leetcode-cn.com/problems/redundant-connection-ii/
与上一题的区别就是有向和无向。
无向的判断条件就是看有没有环。
有向的判断条件是：
1.没有环
2.一个节点只能有一个父节点（也就是入度为1）
所以首先判断有没有入度为2的节点，如果有的话，那么两条边一定要删除其中一条，肯定是删除位置靠后的一条。
如果入度都为1，那么就从前到后遍历数组，看添加哪一条边导致出现环，那么那条边就是最终答案。
po一个能跑通的代码，54个用例只跑通42个
不想调了，日后慢慢再说

class Solution {
    public int[] findRedundantDirectedConnection(int[][] edges) {
        int n = edges.length;

        int[] degree = new int[n+1];
        for(int[] tmp : edges){
            degree[tmp[1]]++;
        }

        for(int i=edges.length-1;i>=0;i--){
            if(degree[edges[i][1]]==2 && wrongEdge(edges,new int[]{edges[i][0],edges[i][1]}).length==0){
                return new int[]{edges[i][0],edges[i][1]};
            }
        }

        return wrongEdge(edges,new int[]{});
    }

    public int[] wrongEdge(int[][] edges, int[] tmp){
        int n = edges.length;
        int[] fa = new int[n+1];
        for(int i=1; i<=n; i++){
            fa[i] = i;
        }

        for(int[] temp : edges){
            if(temp == tmp){
                continue;
            }
            if(find(temp[0],fa) == find(temp[1],fa)){
                return temp;
            }
            merge(temp[0],temp[1],fa);
        }
        return new int[]{};
    }

    public int find(int x, int[] fa){
        if(x == fa[x]){
            return x;
        }else{
            fa[x] = find(fa[x],fa);
            return fa[x];
        }
    }

    public void merge(int i, int j,int[] fa){
        int pi = find(i,fa);
        fa[j] = pi;
    }
}