684. Redundant Connection

Description:

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 directedgraph follow up please see Redundant Connection II). We apologize for any inconvenience caused.

  
  

  简要题解：

  使用并查集这个数据结构。用一个树结构来存储一个原图中的连通分量中包含的所有结点。树中的每个结点包含两个信息，一个是父指针parent（根结点的父指针指向自己），另一个是其子树的高度rank。合并两个树时，用rank值较小的那个根的父指针指向另一个根，使得树的高度尽量底。rank值都一样时就随意。

  初始时，原图中的每一个结点代表一个连通分量，并以此来构造树（每个树仅包含一个结点）。然后，通过按前后顺序遍历各个边，对一条边的两个端点所在的两个连通分量进行合并。一旦发现某条边的两个端点都在同一个连通分量中，就合并失败，并返回这个边。（注意： 所得的边就是后出现的那个，因为较早出现的边已经成功并入连通分量中才会导致后出现的那个边加入后会出现一个环）

代码：

class Solution {
private:
    int* parent;
    int* rank;
public:
    int find(int x) {
        while (x != parent[x])
            x = parent[x];
        return x;
    }

    bool union(int x, int y) {
        int xr = find(x);
        int yr = find(y);

        if (xr == yr) {
            return false;
        } else if (rank[xr] < rank[yr]) {
            parent[xr] = yr;
        } else if (rank[xr] > rank[yr]) {
            parent[yr] = xr;
        } else {
            parent[yr] = xr;
            rank[xr]++;
        }

        return true;
    }

    vector<int> findRedundantConnection(vector<vector<int> >& edges) {
        parent = new int[1024];
        for (int i = 0; i < 1024; i++)
            parent[i] = i;
        rank = new int[1024];

        for (int i = 0; i < edges.size(); i++)
            if (!union(edges[i][0], edges[i][1]))
                return edges[i];
    }  
};