feat: add solutions to lc problem: No.0886.Possible Bipartition

Author: yanglbme

index.html

@@ -26,6 +26,7 @@
   <script>
     window.$docsify = {
       name: 'leetcode',
+      repo: 'doocs/leetcode',
       logo: '/images/doocs-leetcode.png',
       search: [
         '/', '/solution/', '/lcof/', '/lcof2/', '/lcci/', '/lcs/', '/lcp/', '/basic/'

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

@@ -54,27 +54,203 @@
 	<li>对于 <code>dislikes[i] == dislikes[j]</code> 不存在 <code>i != j</code></li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+并查集。
+
+模板 1——朴素并查集：
+
+```python
+# 初始化，p存储每个点的父节点
+p = list(range(n))
+
+# 返回x的祖宗节点
+def find(x):
+    if p[x] != x:
+        # 路径压缩
+        p[x] = find(p[x])
+    return p[x]
+
+# 合并a和b所在的两个集合
+p[find(a)] = find(b)
+```
+
+模板 2——维护 size 的并查集：
+
+```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)
+```
+
+模板 3——维护到祖宗节点距离的并查集：
+x
+```python
+# 初始化，p存储每个点的父节点，d[x]存储x到p[x]的距离
+p = list(range(n))
+d = [0] * n
+
+# 返回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
+```
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def possibleBipartition(self, n: int, dislikes: List[List[int]]) -> bool:
+        p = list(range(n))
+
+        def find(x):
+            if p[x] != x:
+                p[x] = find(p[x])
+            return p[x]
+
+        mp = collections.defaultdict(list)
+        for i, j in dislikes:
+            mp[i - 1].append(j - 1)
+            mp[j - 1].append(i - 1)
+        for i in range(n):
+            dis = mp[i]
+            for j in dis:
+                if find(i) == find(j):
+                    return False
+                p[find(j)] = find(dis[0])
+        return True
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+public:
+    vector<int> p;
+
+    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>> mp;
+        for (auto e : dislikes)
+        {
+            mp[e[0] - 1].push_back(e[1] - 1);
+            mp[e[1] - 1].push_back(e[0] - 1);
+        }
+        for (int i = 0; i < n; ++i)
+        {
+            auto dis = mp[i];
+            for (int j : dis)
+            {
+                if (find(i) == find(j)) return false;
+                p[find(j)] = find(dis[0]);
+            }
+        }
+        return true;
+    }
+
+    int find(int x) {
+        if (p[x] != x) p[x] = find(p[x]);
+        return p[x];
+    }
+};
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> p;
+
+    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>> mp;
+        for (auto e : dislikes)
+        {
+            mp[e[0] - 1].push_back(e[1] - 1);
+            mp[e[1] - 1].push_back(e[0] - 1);
+        }
+        for (int i = 0; i < n; ++i)
+        {
+            auto dis = mp[i];
+            for (int j : dis)
+            {
+                if (find(i) == find(j)) return false;
+                p[find(j)] = find(dis[0]);
+            }
+        }
+        return true;
+    }
+
+    int find(int x) {
+        if (p[x] != x) p[x] = find(p[x]);
+        return p[x];
+    }
+};
+```
 
+### **Go**
+
+```go
+var p []int
+
+func possibleBipartition(n int, dislikes [][]int) bool {
+	p = make([]int, n)
+	for i := 0; i < n; i++ {
+		p[i] = i
+	}
+	mp := make(map[int][]int)
+	for _, e := range dislikes {
+		mp[e[0]-1] = append(mp[e[0]-1], e[1]-1)
+		mp[e[1]-1] = append(mp[e[1]-1], e[0]-1)
+	}
+	for i := 0; i < n; i++ {
+		dis := mp[i]
+		for _, j := range dis {
+			if find(i) == find(j) {
+				return false
+			}
+			p[find(j)] = find(dis[0])
+		}
+	}
+	return true
+}
+
+func find(x int) int {
+	if p[x] != x {
+		p[x] = find(p[x])
+	}
+	return p[x]
+}
 ```
 
 ### **...**