【LeetCode】并查集 union-find（共16题）

链接：https://leetcode.com/tag/union-find/

【128】Longest Consecutive Sequence  （2018年11月22日，开始解决hard题）

给了一个无序的数组，问这个数组里面的元素（可以重新排序）能组成的最长的连续子序列是多长。本题的时间复杂度要求是 O(N).

本题 array 专题里面有， 链接：https://www.cnblogs.com/zhangwanying/p/9610923.html ，用个 hashmap 可以做到 O(N).

本题用 union-find 怎么解，不知道 orz。

【130】Surrounded Regions （2019年1月31日，UF专题）

给了个二维 grid，把里面 O 全部变成 X，但是 边界和边界联通区域内的 O 保留。

题解：我以前是用dfs解的。今天看了discuss高票使用UF，学习了一下。我们把边界上的 O 和边界联通区域内的 O 的坐标与一个 dummy node 联通就好了。然后遍历 grid，如果坐标与 dummy node 坐标联通，就保留成 O，不然改成 X

 class UF {
 public:
     UF(int size) {
         father.resize(size);
         rank.resize(size, );
         for (int i = ; i < size; ++i) {
             father[i] = i;
         }
     }
     int find(int x) {
         return x == father[x] ? x : father[x] = find(father[x]);
     }
     void connect(int x, int y) {
         int xx = find(x), yy = find(y);
         if (xx == yy) { return; }
         if (yy > xx) {
             father[xx] = yy;
         } else {
             father[yy] = x;
         }
     }
     vector<int> father;
     vector<int> rank;
 };
 class Solution {
 public:
     void solve(vector<vector<char>>& board) {
         if (board.empty() || board[].empty()) { return; }
         const int n = board.size(), m = board[].size();
         UF uf(n * m + );
         for (int i = ; i < n; ++i) {
             for (int j = ; j < m; ++j) {
                 if (board[i][j] == 'O') {
                     if ((i ==  || i == n- || j ==  || j == m-)) {
                         uf.connect(i * m + j, n * m);
                     } else {
                         if (board[i-][j] == 'O') {
                             uf.connect(i * m + j, (i-) * m + j);
                         }
                         if (board[i+][j] == 'O') {
                             uf.connect(i * m + j, (i+) * m + j);
                         }
                         if (board[i][j-] == 'O') {
                             uf.connect(i * m + j, i * m + j - );
                         }
                         if (board[i][j+] == 'O') {
                             uf.connect(i * m + j, i * m + j  + );
                         }
                     }
                 }
             }
         }
         for (int i = ; i < n; ++i) {
             for (int j = ; j < m; ++j) {
                 if (uf.find(i * m +j) != n * m) {
                     board[i][j] = 'X';
                 }
             }
         }
         return;
     }
 };

【200】Number of Islands  （2019年1月31日，UF专题）

给了一个二维的grid，0 代表海， 1 的联通块代表岛屿，问有多少岛屿。

题解：和130题一样的想法。判断当前结点和上下左右四个结点是不是都是1，如果是的话，就联通这两个点。

 class UF {
 public:
     UF(int size) {
         father.resize(size);
         rank.resize(size, );
         for (int i = ; i < size; ++i) {
             father[i] = i;
         }
     }
     int find(int x) {
         return x == father[x] ? x : father[x] = find(father[x]);
     }
     void connect(int x, int y) {
         int xx = find(x), yy = find(y);
         if (xx == yy) { return; }
         if (yy < xx) {
             father[xx] = yy;
         } else {
             father[yy] = xx;
         }
     }
     vector<int> father;
     vector<int> rank;
 };
 class Solution {
 public:
     int numIslands(vector<vector<char>>& grid) {
         if (grid.size() ==  || grid[].size() == ) {
             return ;
         }
         const int n = grid.size(), m = grid[].size();
         UF uf(n * m);
         for (int i = ; i < n; ++i) {
             for (int j = ; j < m; ++j) {
                 int index = i * m + j;
                 if (grid[i][j] == '') {
                     if (i -  >=  && grid[i-][j] == '') {
                         uf.connect(index, (i-) * m + j);
                     }
                     if (i +  < n && grid[i+][j] == '') {
                         uf.connect(index, (i+) * m + j);
                     }
                     if (j -  >=  && grid[i][j-] == '') {
                         uf.connect(index, i * m + j - );
                     }
                     if (j +  < m && grid[i][j+] == '') {
                         uf.connect(index, i * m + j + );
                     }
                 }
             }
         }
         int ret = ;
         for (int i = ; i < n; ++i) {
             for (int j = ; j < m; ++j) {
                 int index = i * m + j;
                 if (grid[i][j] == '' && uf.find(index) == index) {
                     ret++;
                 }
             }
         }
         return ret;
     }
 };

【261】Graph Valid Tree （2019年1月31日，UF专题）

给了 N 个结点 和 一个边的集合，问这个边的集合能不能构成一棵树。

题解：先检查 边集合大小是否等于 N-1， 然后用并查集检查是否有环，没有的话，就是树。

 class UF {
 public:
     UF(int size) {
         father.resize(size);
         for (int i = ; i < size; ++i) {
             father[i] = i;
         }
     }
     int find (int x) {
         return x == father[x] ? x : father[x] = find(father[x]);
     }
     void connect (int x, int y) {
         int xx = find(x), yy = find(y);
         if (xx == yy) { return; }
         if (xx < yy) {
             father[yy] = xx;
         } else {
             father[xx] = yy;
         }
     }
     vector<int> father;
 };
 class Solution {
 public:
     bool validTree(int n, vector<pair<int, int>>& edges) {
         const int edgeSize = edges.size();
         if (edgeSize != n-) { return false; } // n 个结点的树有 n-1 条边
         UF uf(n);
         for (auto& e: edges) {
             int u = uf.find(e.first), v = uf.find(e.second);
             if (u == v) {
                 return false;
             }
             uf.connect(e.first, e.second);
         }
         return true;
     }
 };

【305】Number of Islands II （2019年1月31日，UF专题）

【323】Number of Connected Components in an Undirected Graph （2019年2月2日，UF tag专题）

给了 n 个结点，编号从 0 到 n-1，以及一个边的集合。问这个无向图里面有多少个联通块。

题解：直接 uf 数联通块。

 class UF {
 public:
     UF(int size) {
         father.resize(size);
         for (int i = ; i < size; ++i) {
             father[i] = i;
         }
     }
     int find(int x) {
         return x == father[x] ? x : father[x] = find(father[x]);
     }
     void connect(int x, int y) {
         int xx = find(x), yy = find(y);
         if (xx == yy) { return; }
         if (yy < xx) {
             father[xx] = yy;
         } else {
             father[yy] = xx;
         }
     }
     int getCount() {
         int count = ;
         for (int i = ; i < father.size(); ++i) {
             if (father[i] == i) {
                 count++;
             }
         }
         return count;
     }
     vector<int> father;
 };
 class Solution {
 public:
     int countComponents(int n, vector<pair<int, int>>& edges) {
         UF uf(n);
         for (auto& e : edges) {
             int u = e.first, v = e.second;
             uf.connect(u, v);
         }
         return uf.getCount();
     }
 };

【547】Friend Circles （2019年2月2日，UF tag专题）

给了一个邻接矩阵, M[i][j]  = 1代表 i，j 是朋友关系，我们算上间接朋友关系，问这个矩阵里面一共有几个朋友圈子？

题解：直接用 uf 数这个图里面有多少联通块。

 class UF {
 public:
     UF(int size) {
         father.resize(size);
         for (int i = ; i < size; ++i) {
             father[i] = i;
         }
     }
     int find(int x) {
         return x == father[x] ? x : father[x] = find(father[x]);
     }
     void connect(int x, int y) {
         int xx = find(x), yy = find(y);
         if (xx == yy) { return; }
         if (yy < xx) {
             father[xx] = yy;
         } else {
             father[yy] = xx;
         }
     }
     vector<int> father;
 };
 class Solution {
 public:
     int findCircleNum(vector<vector<int>>& M) {
         const int n = M.size();
         UF uf(n);
         for (int i = ; i < n; ++i) {
             for (int j = ; j < n; ++j) {
                 if (M[i][j] == ) {
                     uf.connect(i, j);
                 }
             }
         }
         int ret = ;
         for (int i = ; i < uf.father.size(); ++i) {
             if (i == uf.father[i]) {
                 ret++;
             }
         }
         return ret;
     }
 };

【684】Redundant Connection （2018年11月22日，contest 51 模拟赛做到了）

在本题中，树是一个无环的无向图。输入一个N个结点（编号是1～N）的图，有一条边是多余的，把这条边找出来。

Example :
Input: [[,], [,], [,]]
Output: [,]
Explanation: The given undirected graph will be like this:
 / \
- 

Example :
Input: [[,], [,], [,], [,], [,]]
Output: [,]
Explanation: The given undirected graph will be like this:
-  -
    |   |
- 

Note:
The size of the input 2D-array will be between  and .
Every integer represented in the 2D-array will be between  and N, where N is the size of the input array.

题解：我是用并查集解的。对于每一条边的两个结点，如果他们的爸爸不是同一个爸爸，那么就 unoin 这两个结点，如果他们两个的爸爸是同一个爸爸，就说明这条边多余了，直接返回这条边就行了。

 class Solution {
 public:
     int findfather(int x) {
         return x == father[x] ? x : findfather(father[x]);
     }
     void unionNode(int x, int y) {
         x = findfather(x);
         y = findfather(y);
         if (x == y) { return; }
         father[y] = x;
     }

     vector<int> findRedundantConnection(vector<vector<int>>& edges) {
         n = edges.size();
         father.resize(n+);  //redundant 0
         for (int i = ; i < n+; ++i) {
             father[i] = i;
         }
         vector<int> ret;
         for (auto e : edges) {
             int u = min(e[], e[]), v = max(e[], e[]);
             if (findfather(v) == findfather(u)) {
                 ret = e;
                 break;
             } else {
                 unionNode(u, v);
             }
         }
         return ret;
     }
     int n = ;
     vector<int> father;

 };

【685】Redundant Connection II (2019年2月2日，UF专题)（Hard）

给了 1～N，N个结点，N条边的有向图，删除一条边之后能形成一棵树，返回需要删除的那条边，如果有多个candidate，返回数组中最后那条需要删除的边。

题解：本题和上一题的不同之处在于，上一个题只是检测是否有环，这个题多了一些业务逻辑的判断，主要是一个树的一个结点不可能有两个爸爸。

如有它有两个爸爸，那么这两条边的其中之一一定是答案。

那么我们先找出来看看是否存在这种情况（一个结点有两个爸爸），parent[i] 代表 i 结点的爸爸。如果不存在这种情况，直接检测是否有环就好了。

如果存在这种情况的话，我们先删除这个结点和它第二个爸爸这条边，看剩下的边是否有环，如果有环的话，就应该返回这个结点和它第一个爸爸这条边。

 class UF {
 public:
     UF(int size) {
         father.resize(size);
         for (int i = ; i < size; ++i) {
             father[i] = i;
         }
     }
     int find(int x) {
         return x == father[x] ? x : father[x] = find(father[x]);
     }
     void connect(int x, int y) {
         int xx = find(x), yy = find(y);
         if (xx == yy) { return; }
         if (yy < xx) {
             father[xx] = yy;
         } else {
             father[yy] = xx;
         }
     }
     vector<int> father;
 };
 class Solution {
 public:
     vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
         const int n = edges.size();
         UF uf(n+);
         vector<int> parent(n+, );
         vector<int> ans1, ans2;
         for (auto& e : edges) {
             int p = e[], s = e[];
             if (parent[s] != ) {
                 ans1 = {parent[s], s};
                 ans2 = e;
                 e[] = e[] = -; //先把第二条边删除，然后下面用uf检测是否有环
                 break;
             } else {
                 parent[s] = p;
             }
         }
         for (auto e : edges) {
             if (e[] <  && e[] < ) { continue; }
             int u = uf.find(e[]), v = uf.find(e[]);
             if (u == v) { //如果说在删除第二条边的情况下，有环，如果有第一条边，就返回第一条边，不然返回第二条边
                 if (!ans1.empty()) {return ans1;}
                 return e;
             }
             uf.connect(e[], e[]);
         }
         return ans2;
     }
 };

【721】Accounts Merge

【737】Sentence Similarity II

【765】Couples Holding Hands

【778】Swim in Rising Water

【803】Bricks Falling When Hit

【839】Similar String Groups

【928】Minimize Malware Spread II