2020_9_17 每日一题 冗余连接 II

在本问题中，有根树指满足以下条件的有向图。该树只有一个根节点，所有其他节点都是该根节点的后继。每一个节点只有一个父节点，除了根节点没有父节点。

输入一个有向图，该图由一个有着N个节点 (节点值不重复1, 2, …, N)
的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。

结果图是一个以边组成的二维数组。 每一个边 的元素是一对 [u, v]，用以表示有向图中连接顶点 u 和顶点 v 的边，其中 u 是 v
的一个父节点。

返回一条能删除的边，使得剩下的图是有N个节点的有根树。若有多个答案，返回最后出现在给定二维数组的答案。

示例 1:

输入: [[1,2], [1,3], [2,3]] 输出: [2,3]
解释: 给定的有向图如下:

示例 2:

输入: [[1,2], [2,3], [3,4], [4,1], [1,5]] 输出: [4,1] 解释: 给定的有向图如下:

注意:

二维数组大小的在3到1000范围内。 二维数组中的每个整数在1到N之间，其中 N 是二维数组的大小。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/redundant-connection-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

又到了，完全做不出来只能看题解还看不太懂的环节…一开始说找回边就想到dfs，但是从哪个节点开始dfs呢？卡住了，二话不说直接看题解。

可以分成两种情况
1.没有节点有两条入边 这种情况下一定有环
2.有一个节点有两条入边，这种情况下答案一定是这个节点的两条入边之一。

检查环可以用并查集。将所有已经连接的节点放到同一个集合中。在添加一条边时，如果两个节点已经在同一个集合了，说名添加的这条边会成环

两条入边的情况判别。首先有个结论，如果有一个节点有两条入边并且有环，那么这两条入边中肯定至少有一个在环里。否则删一条边肯定不能变成有根树，至少得删两个边。那么可以在发现第二条入边的时候，不参与成环的判别。如果之后没发现环，说明就第二条入边在环里，否则的话就是第一条入边在环里。

需要注意 这里用并查集来找环其实找的是无向的环，不过在这个题里似乎按照上面的方法找到的无向的环也是有向的环。因为如果找到了一个环但不是有向的环，那么环中必然有一个节点有两条入边；而最多只有一个节点有两条入边，并且其中一条入边不会参与成环检查，所以找到的环一定是有向的环

并查集的代码就直接抄算法导论了：

    class union {
        union p;
        int rank;
        public union(){
            rank = 0;
            p = this;
        }

        void link(union y) {
            if(this.rank > y.rank) {
                y.p = this;
            } else if(this.rank < y.rank) {
                this.p = y;
            } else {
                this.p = y;
                ++y.rank;
            }
        }

        union find_set() {
            if(this != this.p) {
                this.p = this.p.find_set();
            }
            return this.p;
        }

        void combine(union y) {
            this.find_set().link(y.find_set());
        }
    }

然后主逻辑：

class Solution {
    public int[] findRedundantDirectedConnection(int[][] edges) {
        int[] parent = new int[edges.length];
        union[] unions = new union[edges.length];

        int[] circleEdge = null, conflictEdge = null;
        
        for(int[] edge : edges) {
            int from = edge[0], to = edge[1];
            
            //一个节点有两个parent
            if(parent[to - 1] != 0) {
            	//找到冲突变 冲突边不参与成环检查
                conflictEdge = edge;
                continue;
            }

            parent[to - 1] = from;

            //成环
            if(unions[from - 1] == null) {
                unions[from - 1] = new union();
            }
            if(unions[to - 1] == null) {
                unions[to - 1] = new union();
            }
            if(unions[from - 1].find_set() == unions[to - 1].find_set()) {
                //如果两个在同一集合 一定存在一条从 to 到 from 的边(因为不存在一个节点两个入边)
                circleEdge = edge;
            }
            unions[from - 1].combine(unions[to - 1]);
        }

        if(conflictEdge == null) {
            return circleEdge;
        } else if(circleEdge == null) {
            return conflictEdge;
        } else {
            int to = conflictEdge[1];
            return new int[] {parent[to - 1], to};
        }
    }
}

题解没有把并查集和集合数组分开其实有一些迷乱，而且没有按rank选择哪一个是爹的过程。这很不学院派啊
啊并查集找环，我怎么想不到这种方法TAT
而且我已将忘了并查集是咋回事rank有啥用了，算了能抄会用就成。