Redundant Connection

In this problem, a tree is an undirected graph that is connected and has no cycles.

The given input is a graph that started as a tree with N nodes (with distinct values 1, 2, ..., N), with one additional edge added. The added edge has two different vertices chosen from 1 to N, and was not an edge that already existed.

The resulting graph is given as a 2D-array of edges. Each element of edges is a pair [u, v] with u < v, that represents an undirected edge connecting nodes u and v.

Return an edge that can be removed so that the resulting graph is a tree of N nodes. If there are multiple answers, return the answer that occurs last in the given 2D-array. The answer edge [u, v] should be in the same format, with u < v.

Example 1:

Input: [[1,2], [1,3], [2,3]]
Output: [2,3]
Explanation: The given undirected graph will be like this:
  1
 / 
2 - 3

Example 2:

Input: [[1,2], [2,3], [3,4], [1,4], [1,5]]
Output: [1,4]
Explanation: The given undirected graph will be like this:
5 - 1 - 2
    |   |
    4 - 3

Note:

• The size of the input 2D-array will be between 3 and 1000.
• Every integer represented in the 2D-array will be between 1 and N, where N is the size of the input array.

Update (2017-09-26):
We have overhauled the problem description + test cases and specified clearly the graph is an undirected graph. For the directed graph follow up please see Redundant Connection II). We apologize for any inconvenience caused.

题解：

这题用到了并查集的算法

reference：https://blog.csdn.net/dm_vincent/article/details/7655764

从例子来看，是从给出的起点终点的数组edges中，找出第一个形成环的元素。

思路：

题目中，每个数字代表一个点，定义一个起点与终点的数组begin，begin有2001个元素，begin的下标代表终点，begin的元素代表原始起点（最开始的起点），题目可以化简为找出第一个edge，这个edge的起点和终点都有同样的一个原始起点，即形成环。

初始化为每个起点的终点都指向自身为原始起点。然后遍历edges数组，更新新遍历的点，更新原始起点，直至找到环为止。

以example 1为例，

begin 的下标为 0 1 2 3 ... ...

初始化后元素为 0 1 2 3

[1 2] 进入后的为 0 1 1 3，2的原始起点更新为1

[1 3] 进入后的为 0 1 1 1，3的原始起点更新为1

[2 3] 进入后，发现2与3的原始起点一致，均为1，发现环。

reference:

https://blog.csdn.net/dong_beijing/article/details/78094443

class Solution {
    int[] roots;
    public int[] findRedundantConnection(int[][] edges) {
        roots = new int[edges.length + 1];
        for(int i = 0; i < roots.length; i++) {
            roots[i] = i;
        }
        for(int[] edge : edges) {
            int root1 = find(edge[0]);
            int root2 = find(edge[1]);
            if(root1 == root2)
                return edge;
            roots[root2] = root1;
        }
        int[] ans = new int[2];
        return ans;
    }
    
    public int find(int i) {
        while(i != roots[i]) {
            i = roots[i];
        }
        return i;
    }
}