feat: add solutions to lc problem: No.0886

No.0886.Possible Bipartition

Author: yanglbme

solution/0800-0899/0886.Possible Bipartition/README.md

@@ -56,65 +56,59 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-并查集。
+**方法一：染色法**
 
-模板 1——朴素并查集：
+我们用两种颜色对图进行染色，如果可以完成染色，那么就说明可以将所有人分进两组。
 
-```python
-# 初始化，p存储每个点的父节点
-p = list(range(n))
+具体的染色方法如下：
 
-# 返回x的祖宗节点
-def find(x):
-    if p[x] != x:
-        # 路径压缩
-        p[x] = find(p[x])
-    return p[x]
+-   初始化所有人的颜色为 $0$，表示还没有染色。
+-   遍历所有人，如果当前人没有染色，那么就用颜色 $1$ 对其进行染色，然后将其所有不喜欢的人用颜色 $2$ 进行染色。如果染色过程中出现了冲突，那么就说明无法将所有人分进两组，返回 `false`。
+-   如果所有人都染色成功，那么就说明可以将所有人分进两组，返回 `true`。
 
+时间复杂度 $O(n + m)$，其中 $n$, $m$ 分别是人数和不喜欢的关系数。
 
-# 合并a和b所在的两个集合
-p[find(a)] = find(b)
-```
+**方法二：并查集**
+
+并查集是一种树形的数据结构，顾名思义，它用于处理一些不交集的**合并**及**查询**问题。 它支持两种操作：
+
+1. 查找（Find）：确定某个元素处于哪个子集，单次操作时间复杂度 $O(\alpha(n))$
+1. 合并（Union）：将两个子集合并成一个集合，单次操作时间复杂度 $O(\alpha(n))$
+
+其中 $\alpha$ 为阿克曼函数的反函数，其增长极其缓慢，也就是说其单次操作的平均运行时间可以认为是一个很小的常数。
+
+以下是并查集的常用模板，需要熟练掌握。其中：
 
-模板 2——维护 size 的并查集：
+-   `n` 表示节点数
+-   `p` 存储每个点的父节点，初始时每个点的父节点都是自己
+-   `size` 只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
+-   `find(x)` 函数用于查找 $x$ 所在集合的祖宗节点
+-   `union(a, b)` 函数用于合并 $a$ 和 $b$ 所在的集合
 
 ```python
-# 初始化，p存储每个点的父节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
 p = list(range(n))
 size = [1] * n
 
-# 返回x的祖宗节点
 def find(x):
     if p[x] != x:
         # 路径压缩
         p[x] = find(p[x])
     return p[x]
 
-# 合并a和b所在的两个集合
-if find(a) != find(b):
-    size[find(b)] += size[find(a)]
-    p[find(a)] = find(b)
+
+def union(a, b):
+    pa, pb = find(a), find(b)
+    if pa == pb:
+        return
+    p[pa] = pb
+    size[pb] += size[pa]
 ```
 
-模板 3——维护到祖宗节点距离的并查集：
+对于本题，我们遍历每一个人，他与他不喜欢的人不应该在同一个集合中，如果在同一个集合中，就产生了冲突，直接返回 `false`。如果没有冲突，那么就将他所有不喜欢的人合并到同一个集合中。
 
-```python
-# 初始化，p存储每个点的父节点，d[x]存储x到p[x]的距离
-p = list(range(n))
-d = [0] * n
+遍历结束，说明没有冲突，返回 `true`。
 
-# 返回x的祖宗节点
-def find(x):
-    if p[x] != x:
-        t = find(p[x])
-        d[x] += d[p[x]]
-        p[x] = t
-    return p[x]
-
-# 合并a和b所在的两个集合
-p[find(a)] = find(b)
-d[find(a)] = distance
-```
+时间复杂度 $O(n + m\times \alpha(n))$。
 
 <!-- tabs:start -->
 
@@ -125,53 +119,113 @@ d[find(a)] = distance
 ```python
 class Solution:
     def possibleBipartition(self, n: int, dislikes: List[List[int]]) -> bool:
-        p = list(range(n))
+        def dfs(i, c):
+            color[i] = c
+            for j in g[i]:
+                if color[j] == c:
+                    return False
+                if color[j] == 0 and not dfs(j, 3 - c):
+                    return False
+            return True
 
+        g = defaultdict(list)
+        color = [0] * n
+        for a, b in dislikes:
+            a, b = a - 1, b - 1
+            g[a].append(b)
+            g[b].append(a)
+        return all(c or dfs(i, 1) for i, c in enumerate(color))
+```
+
+```python
+class Solution:
+    def possibleBipartition(self, n: int, dislikes: List[List[int]]) -> bool:
         def find(x):
             if p[x] != x:
                 p[x] = find(p[x])
             return p[x]
 
-        dis = defaultdict(list)
+        g = defaultdict(list)
         for a, b in dislikes:
             a, b = a - 1, b - 1
-            dis[a].append(b)
-            dis[b].append(a)
-
+            g[a].append(b)
+            g[b].append(a)
+        p = list(range(n))
         for i in range(n):
-            for j in dis[i]:
+            for j in g[i]:
                 if find(i) == find(j):
                     return False
-                p[find(j)] = find(dis[i][0])
+                p[find(j)] = find(g[i][0])
         return True
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```java
+class Solution {
+    private List<Integer>[] g;
+    private int[] color;
+
+    public boolean possibleBipartition(int n, int[][] dislikes) {
+        g = new List[n];
+        color = new int[n];
+        for (int i = 0; i < n; ++i) {
+            g[i] = new ArrayList<>();
+        }
+        for (var e : dislikes) {
+            int a = e[0] - 1, b = e[1] - 1;
+            g[a].add(b);
+            g[b].add(a);
+        }
+        for (int i = 0; i < n; ++i) {
+            if (color[i] == 0) {
+                if (!dfs(i, 1)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    private boolean dfs(int i, int c) {
+        color[i] = c;
+        for (int j : g[i]) {
+            if (color[j] == c) {
+                return false;
+            }
+            if (color[j] == 0 && !dfs(j, 3 - c)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
 ```java
 class Solution {
     private int[] p;
 
     public boolean possibleBipartition(int n, int[][] dislikes) {
         p = new int[n];
-        List<Integer>[] dis = new List[n];
+        List<Integer>[] g = new List[n];
         for (int i = 0; i < n; ++i) {
             p[i] = i;
-            dis[i] = new ArrayList<>();
+            g[i] = new ArrayList<>();
         }
-        for (int[] d : dislikes) {
-            int a = d[0] - 1, b = d[1] - 1;
-            dis[a].add(b);
-            dis[b].add(a);
+        for (var e : dislikes) {
+            int a = e[0] - 1, b = e[1] - 1;
+            g[a].add(b);
+            g[b].add(a);
         }
         for (int i = 0; i < n; ++i) {
-            for (int j : dis[i]) {
+            for (int j : g[i]) {
                 if (find(i) == find(j)) {
                     return false;
                 }
-                p[find(j)] = find(dis[i].get(0));
+                p[find(j)] = find(g[i].get(0));
             }
         }
         return true;
@@ -191,60 +245,115 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    vector<int> p;
+    bool possibleBipartition(int n, vector<vector<int>>& dislikes) {
+        unordered_map<int, vector<int>> g;
+        for (auto& e : dislikes) {
+            int a = e[0] - 1, b = e[1] - 1;
+            g[a].push_back(b);
+            g[b].push_back(a);
+        }
+        vector<int> color(n);
+        function<bool(int, int)> dfs = [&](int i, int c) -> bool {
+            color[i] = c;
+            for (int j : g[i]) {
+                if (!color[j] && !dfs(j, 3 - c)) return false;
+                if (color[j] == c) return false;
+            }
+            return true;
+        };
+        for (int i = 0; i < n; ++i) {
+            if (!color[i] && !dfs(i, 1)) return false;
+        }
+        return true;
+    }
+};
+```
 
+```cpp
+class Solution {
+public:
     bool possibleBipartition(int n, vector<vector<int>>& dislikes) {
-        p.resize(n);
-        for (int i = 0; i < n; ++i) p[i] = i;
-        unordered_map<int, vector<int>> dis;
-        for (auto& d : dislikes) {
-            int a = d[0] - 1, b = d[1] - 1;
-            dis[a].push_back(b);
-            dis[b].push_back(a);
+        vector<int> p(n);
+        iota(p.begin(), p.end(), 0);
+        unordered_map<int, vector<int>> g;
+        for (auto& e : dislikes) {
+            int a = e[0] - 1, b = e[1] - 1;
+            g[a].push_back(b);
+            g[b].push_back(a);
         }
+        function<int(int)> find = [&](int x) -> int {
+            if (p[x] != x) p[x] = find(p[x]);
+            return p[x];
+        };
         for (int i = 0; i < n; ++i) {
-            for (int j : dis[i]) {
+            for (int j : g[i]) {
                 if (find(i) == find(j)) return false;
-                p[find(j)] = find(dis[i][0]);
+                p[find(j)] = find(g[i][0]);
             }
         }
         return true;
     }
-
-    int find(int x) {
-        if (p[x] != x) p[x] = find(p[x]);
-        return p[x];
-    }
 };
 ```
 
 ### **Go**
 
+```go
+func possibleBipartition(n int, dislikes [][]int) bool {
+	g := make([][]int, n)
+	for _, e := range dislikes {
+		a, b := e[0]-1, e[1]-1
+		g[a] = append(g[a], b)
+		g[b] = append(g[b], a)
+	}
+	color := make([]int, n)
+	var dfs func(int, int) bool
+	dfs = func(i, c int) bool {
+		color[i] = c
+		for _, j := range g[i] {
+			if color[j] == c {
+				return false
+			}
+			if color[j] == 0 && !dfs(j, 3-c) {
+				return false
+			}
+		}
+		return true
+	}
+	for i, c := range color {
+		if c == 0 && !dfs(i, 1) {
+			return false
+		}
+	}
+	return true
+}
+```
+
 ```go
 func possibleBipartition(n int, dislikes [][]int) bool {
 	p := make([]int, n)
-	dis := make([][]int, n)
+	g := make([][]int, n)
 	for i := range p {
 		p[i] = i
 	}
-	var find func(x int) int
+	for _, e := range dislikes {
+		a, b := e[0]-1, e[1]-1
+		g[a] = append(g[a], b)
+		g[b] = append(g[b], a)
+	}
+	var find func(int) int
 	find = func(x int) int {
 		if p[x] != x {
 			p[x] = find(p[x])
 		}
 		return p[x]
 	}
-	for _, d := range dislikes {
-		a, b := d[0]-1, d[1]-1
-		dis[a] = append(dis[a], b)
-		dis[b] = append(dis[b], a)
-	}
 	for i := 0; i < n; i++ {
-		for _, j := range dis[i] {
+		for _, j := range g[i] {
 			if find(i) == find(j) {
 				return false
 			}
-			p[find(j)] = find(dis[i][0])
+			p[find(j)] = find(g[i][0])
 		}
 	}
 	return true