LeetCode 85. 冗余连接 II

题目:　

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

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

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

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

示例:

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

　　　　　　输入: [[1,2], [2,3], [3,4], [4,1], [1,5]]
　　　　　　输出: [4,1]
　　　　　　解释: 给定的有向图如下:
　　　　　　5 <- 1 -> 2
　　　　　　     ^    |
　　　　　　     |    v
　　　　　　     4 <- 3

题解:
　　在以上题目中有一句比较关键的句子 : 该图由一个有着N个节点 (节点值不重复1, 2, ..., N) 的树及一条附加的边构成。附加的边
的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。
　　这句话其实是引导我们思路的,我们可以知道题目所说的有根树具有三个性质。第一,有根树存在入度为0的节点(根节点),第二有根树除了
根节点其他节点的入度都为1。第三有根树所有节点都是连通的。

　　　　如若一颗有根树加上一条边的话,那么加上的边存在以下三种情况:
　　　　1)边的两端是同一节点 
　　　　　　判定方式 : 直接看两遍是否相等
　　　　　　处理 : 直接可以知道这条边肯定不是原有的,返回当前边
　　　　2)两端不是同一节点,并且被指向的是根节点。
　　　　　　判定方式 : 如若被指向的那端统计之后出现了所有节点或者不存在入度为2的节点
　　　　　　处理 : 因为根被指向了后一定会形成环,故而处理的可能性很多(除去环内任意边),但是需要注意是否存在示例2中的情况,如若除去边[1,5],就会导致该有根树不连通,并且依然有环。 因为是否连通使用并查集很容易检测是否连通
,故而这里我选择了直接使用并查集。
　　　　3）两端不是同一节点,并且被指向的是非根节点。
　　　　　　判定方式 : 剩下的情况都是3)//存在入度为2的节点
　　　　　　处理 : 因为存在入度为2的节点,所以在这就是在两条指向入度为2节点内直接二选一,但是这里不能随便选,必须保证如若因为这条边成环(例如示例一加上一个节点4并且4指向2),也就是 : [[4, 2],[1,2], [1,3], [2,3]]
,这时指向2的一共有两个节点 4 和 1,这时候如若选择删除[1,2]则会导致整张图不连通,故而需要检查连通性来选择删除两个节点的哪个,依然使用并查集。
代码:

 int n;
     public int[] findRedundantDirectedConnection(int[][] edges) {
         this.n = edges.length;
         int[] table = new int[n];
         Arrays.fill(table, -1);
         int other = -1;
         for (int i = 0; i < n; i++) {
             if (edges[i][0] == edges[i][1]) {
                 return edges[i];
             }
             int index = edges[i][1] - 1;
             if (table[index] != -1) {
                 other = i;
             } else {
                 table[index] = i;
             }
         }
         // 如若指向非根
         if (other != -1) {
             // 且 如若删除了后面那个节点 仍然是 连通的。
             if (this.isConnected(edges, other))
                 return edges[other];
             else
                 return edges[table[edges[other][1] - 1]];
         }
         for (int i = n - 1; i >= 0; i--) {
             //如若除去i还是连通的
             if (this.isConnected(edges, i)) {
                 return edges[i];
             }
         }
         return new int[] {};
     }

     /**
      * 若除去第i条边
      *
      * @param edges
      * @param i
      * @return
      */
     int[] table;

     public boolean isConnected(int[][] edges, int i) {
         this.table = new int[n];
         for (int j = 0; j < n; j++) {
             table[j] = j;
         }
         for (int j = 0; j < n; j++) {
             if (j != i)
                 union(edges[j][0] - 1, edges[j][1] - 1);
         }
         boolean flag = true;
         for (int k = 0; k < n; k++) {
             if (table[k] == k) {
                 if (flag) {
                     flag = false;
                 } else {
                     return false;
                 }
             }
         }
         return true;
     }

     public boolean union(int i, int j) {
         int iIndex = this.find(i);
         int jIndex = this.find(j);
         if (iIndex == jIndex) {
             return false;
         }
         table[iIndex] = jIndex;
         return true;
     }

     public int find(int i) {
         while (table[i] != i) {
             i = table[i];
         }
         return i;
     }