【LeetCode】684. Redundant Connection

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/KID_LWC/article/details/81263662

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.

并查集或DSF解决，这里用并查集

• class Solution {
  public:
      vector<int> findRedundantConnection(vector<vector<int>>& edges) {
          int node[1010];
          for(int i=0;i<1010;i++) node[i]=i;
          for(int i=0;i<edges.size();i++){
              int x=edges[i][0],y=edges[i][1];
              if(findFather(x,node)!=findFather(y,node)) Union(x,y,node);
              else return edges[i];
              
          }
          
      }
      int findFather(int x,int* node){
          int a=x;
          while(x!=node[x]) x=node[x];
          while(a!=node[a]){
              int z=a;
              a=node[a];
              node[z]=x;
          }
          return x;
      }
      void Union(int a,int b,int* node)
      {
          int fa=findFather(a,node);
          int fb=findFather(b,node);
          if(fa!=fb)node[fa]=fb;
      }
  };

  class UnionFind {
  private:
      vector<int> components;
  public:
      UnionFind(int n): components(n+1) {
          iota(components.begin(), components.end(), 0);
      }
      
      void merge(int x, int y) {
          if (find(x) == find(y)) return;
          components[find(x)] = find(y);
      }
      
      int find(int x) const {
          for (; components[x] != x; x = components[x]) {}
          return x;
      }
  };
  
  class Solution {
  public:
      vector<int> findRedundantConnection(vector<vector<int>>& edges) {
          UnionFind unionFind(edges.size());
          for (const auto& edge : edges) {
              int x = edge[0]; int y = edge[1];
              if (unionFind.find(x) == unionFind.find(y)) return edge;
              unionFind.merge(x, y);
          }
          return {};
      }
  };