684. 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.
采用并查集的方法来解决问题，对无向图所有的边一次加入不同的分组，查看是否存在环路，如果加入一条边形成环路即
加入的这条边的两个点已经在同一个分组中了，返回该边即可。

关于并查集的优化以及讲解请查看：http://blog.youkuaiyun.com/dm_vincent/article/details/7655764
博主讲的十分清楚。

动态连通性的几种操作：
    查询节点属于的组
        数组对应位置的值即为组号
    判断两个节点是否属于同一个组
        分别得到两个节点的组号，然后判断组号是否相等
    连接两个节点，使之属于同一个组
        分别得到两个节点的组号，组号相同时操作结束，不同时，将其中的一个节点的组号换成另一个节点的组号
    获取组的数目
        对构造树进行优化，来避免树的深度过大

*/


class Solution {
public:
    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
        vector<int> parent(2001);
        for(int i=0;i<2001;i++) parent[i]=i;//分组，每组的根节点为i
        for(auto edge : edges){
            int l=findRoot(edge[0],parent),r=findRoot(edge[1],parent);
            if(l == r) //新加入的边形成的环路 是否在同一个分组中
                return edge;
            parent[l] = r; //l组加入到r组中，成为r组根节点的一个分支 此处可以采用树的深度来优化
        }
        return vector<int> (0, 0);//不存在
    }
    int findRoot(int p,vector<int>& parent){ //寻找p节点对应分组的根节点
        while(p != parent[p])
            p = parent[p];
        return p;
    }
};