feat: $785 $886

lucifer · lucifer · commit f78749d23df1 · 2020-07-16T14:21:54.000+08:00
diff --git a/README.md b/README.md
@@ -250,21 +250,23 @@ leetcode 题解，记录自己的 leetcode 解题之路。
 - [0343.integer-break](./problems/343.integer-break.md)🆕
 - [0365.water-and-jug-problem](./problems/365.water-and-jug-problem.md)
 - [0378.kth-smallest-element-in-a-sorted-matrix](./problems/378.kth-smallest-element-in-a-sorted-matrix.md)
-- [0380.insert-delete-getrandom-o1](./problems/380.insert-delete-getrandom-o1.md)🆕
+- [0380.insert-delete-getrandom-o1](./problems/380.insert-delete-getrandom-o1.md)
 - [0416.partition-equal-subset-sum](./problems/416.partition-equal-subset-sum.md)🖊
 - [0445.add-two-numbers-ii](./problems/445.add-two-numbers-ii.md)
 - [0454.4-sum-ii](./problems/454.4-sum-ii.md)
 - [0474.ones-and-zeros](./problems/474.ones-and-zeros-en.md)
 - [0494.target-sum](./problems/494.target-sum.md)
 - [0516.longest-palindromic-subsequence](./problems/516.longest-palindromic-subsequence.md)
 - [0518.coin-change-2](./problems/518.coin-change-2.md)
-- [0547.friend-circles](./problems/547.friend-circles-en.md) 🆕
+- [0547.friend-circles](./problems/547.friend-circles-en.md)
 - [0560.subarray-sum-equals-k](./problems/560.subarray-sum-equals-k.md)
 - [0609.find-duplicate-file-in-system](./problems/609.find-duplicate-file-in-system.md)
 - [0718.maximum-length-of-repeated-subarray](./problems/718.maximum-length-of-repeated-subarray.md)
+- [0785.is-graph-bipartite](./problems/785.is-graph-bipartite.md) 🆕
 - [0820.short-encoding-of-words](./problems/820.short-encoding-of-words.md) 🖊
 - [0875.koko-eating-bananas](./problems/875.koko-eating-bananas.md)
 - [0877.stone-game](./problems/877.stone-game.md)
+- [0886.possible-bipartition](./problems/886.possible-bipartition.md) 🆕
 - [0900.rle-iterator](./problems/900.rle-iterator.md)
 - [0912.sort-an-array](./problems/912.sort-an-array.md)
 - [0935.knight-dialer](./problems/935.knight-dialer.md) 🆕
diff --git a/problems/785.is-graph-bipartite.md b/problems/785.is-graph-bipartite.md
@@ -0,0 +1,110 @@
+## 题目地址（785. 判断二分图）
+
+https://leetcode-cn.com/problems/is-graph-bipartite/
+
+## 题目描述
+
+```
+给定一个无向图 graph，当这个图为二分图时返回 true。
+
+如果我们能将一个图的节点集合分割成两个独立的子集 A 和 B，并使图中的每一条边的两个节点一个来自 A 集合，一个来自 B 集合，我们就将这个图称为二分图。
+
+graph 将会以邻接表方式给出，graph[i]表示图中与节点 i 相连的所有节点。每个节点都是一个在 0 到 graph.length-1 之间的整数。这图中没有自环和平行边： graph[i]  中不存在 i，并且 graph[i]中没有重复的值。
+
+示例 1:
+输入: [[1,3], [0,2], [1,3], [0,2]]
+输出: true
+解释:
+无向图如下:
+0----1
+| |
+| |
+3----2
+我们可以将节点分成两组: {0, 2} 和 {1, 3}。
+
+示例 2:
+输入: [[1,2,3], [0,2], [0,1,3], [0,2]]
+输出: false
+解释:
+无向图如下:
+0----1
+| \ |
+| \ |
+3----2
+我们不能将节点分割成两个独立的子集。
+注意:
+
+graph 的长度范围为 [1, 100]。
+graph[i] 中的元素的范围为 [0, graph.length - 1]。
+graph[i] 不会包含 i 或者有重复的值。
+图是无向的: 如果 j 在 graph[i]里边, 那么 i 也会在 graph[j]里边。
+```
+
+## 前置知识
+
+- 图的遍历
+- DFS
+
+## 思路
+
+和 886 思路一样。 我甚至**直接拿过来 dfs 函数一行代码没改就 AC 了**。
+
+唯一需要调整的地方是 graph 。 我将其转换了一下，具体可以看代码，非常简单易懂。
+
+具体算法：
+
+- 设置一个长度为 N 的数组 colors，colors[i] 表示 节点 i 的颜色，0 表示无颜色， 1 表示一种颜色， - 1 表示另一种颜色。
+- 初始化 colors 全部为 0
+- 构图（这里有邻接矩阵） 使得 grid[i][j] 表示 i 和 j 是否有连接（这里用 0 表示无， 1 表示有）
+- 遍历图。
+  - 如果当前节点未染色，则染色，不妨染为颜色 1
+  - 递归遍历其邻居
+    - 如果邻居没有染色， 则染为另一种颜色。即 color \* - 1，其中 color 为当前节点的颜色
+    - 否则，判断当前节点和邻居的颜色是否一致，不一致则返回 False，否则返回 True
+
+强烈建议两道题一起练习一下。
+
+## 关键点
+
+- 图的建立和遍历
+- colors 数组
+
+## 代码
+
+```py
+class Solution:
+    def dfs(self, grid, colors, i, color, N):
+        colors[i] = color
+        for j in range(N):
+            if grid[i][j] == 1:
+                if colors[j] == color:
+                    return False
+                if colors[j] == 0 and not self.dfs(grid, colors, j, -1 * color, N):
+                    return False
+        return True
+
+    def isBipartite(self, graph: List[List[int]]) -> bool:
+        N = len(graph)
+        grid = [[0] * N for _ in range(N)]
+        colors = [0] * N
+        for i in range(N):
+            for j in graph[i]:
+                grid[i][j] = 1
+        for i in range(N):
+            if colors[i] == 0 and not self.dfs(grid, colors, i, 1, N):
+                return False
+        return True
+```
+
+**复杂度分析**
+
+- 时间复杂度：$O(N^2)$
+- 空间复杂度：$O(N)$
+
+## 相关问题
+
+- [886. 可能的二分法](./886.possible-bipartition.md)
+
+更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 30K star 啦。
+
+关注公众号力扣加加，努力用清晰直白的语言还原解题思路，并且有大量图解，手把手教你识别套路，高效刷题。
diff --git a/problems/886.possible-bipartition.md b/problems/886.possible-bipartition.md
@@ -0,0 +1,147 @@
+## 题目地址（886. 可能的二分法）
+
+https://leetcode-cn.com/problems/is-graph-bipartite/
+
+## 题目描述
+
+```
+给定一组 N 人（编号为 1, 2, ..., N）， 我们想把每个人分进任意大小的两组。
+
+每个人都可能不喜欢其他人，那么他们不应该属于同一组。
+
+形式上，如果 dislikes[i] = [a, b]，表示不允许将编号为 a 和 b 的人归入同一组。
+
+当可以用这种方法将每个人分进两组时，返回 true；否则返回 false。
+
+ 
+
+示例 1：
+
+输入：N = 4, dislikes = [[1,2],[1,3],[2,4]]
+输出：true
+解释：group1 [1,4], group2 [2,3]
+示例 2：
+
+输入：N = 3, dislikes = [[1,2],[1,3],[2,3]]
+输出：false
+示例 3：
+
+输入：N = 5, dislikes = [[1,2],[2,3],[3,4],[4,5],[1,5]]
+输出：false
+ 
+
+提示：
+
+1 <= N <= 2000
+0 <= dislikes.length <= 10000
+dislikes[i].length == 2
+1 <= dislikes[i][j] <= N
+dislikes[i][0] < dislikes[i][1]
+对于dislikes[i] == dislikes[j] 不存在 i != j
+
+```
+
+## 前置知识
+
+- 图的遍历
+- DFS
+
+## 思路
+
+这是一个图的问题。解决这种问题一般是要遍历图才行的，这也是图的套路。 那么遍历的话，你要有一个合适的数据结构。 比较常见的图存储方式是邻接矩阵和邻接表。
+
+而我们这里为了操作方便（代码量），直接使用邻接矩阵。由于是互相不喜欢，不存在一个喜欢另一个，另一个不喜欢一个的情况，因此这是无向图。而无向图邻接矩阵实际上是会浪费空间，具体看我下方画的图。
+
+而题目给我们的二维矩阵并不是现成的邻接矩阵形式，因此我们需要自己生成。
+
+我们用 1 表示互相不喜欢（dislike each other）。
+
+```py
+        graph = [[0] * N for i in range(N)]
+        for a, b in dislikes:
+            graph[a - 1][b - 1] = 1
+            graph[b - 1][a - 1] = 1
+```
+
+![image.png](https://pic.leetcode-cn.com/21985e69144ba1fef518085d5bdc8e0f6d363a33ddef3938523603871466eace-image.png)
+
+同时可以用 hashmap 或者数组存储 N 个人的分组情况， 业界关于这种算法一般叫染色法，因此我们命名为 colors，其实对应的本题叫 groups 更合适。
+
+![image.png](https://pic.leetcode-cn.com/ebd70e4bdeb3fbcc7fe3cdd70f5679db0cec60c4f18ab077a6c9844d58c79776-image.png)
+
+我们用：
+
+- 0 表示没有分组
+- 1 表示分组 1
+- -1 表示分组 2
+
+之所以用 0，1，-1，而不是 0，1，2 是因为我们会在不能分配某一组的时候尝试分另外一组，这个时候有其中一组转变为另外一组就可以直接乘以-1，而 0，1，2 这种就稍微麻烦一点而已。
+
+具体算法：
+
+- 遍历每一个人，尝试给他们进行分组，比如默认分配组 1.
+
+![image.png](https://pic.leetcode-cn.com/a6a691a28d74245501ebd543d382fa277a7825b8ceb82d4c7adb2ecdc5834793-image.png)
+
+- 然后遍历这个人讨厌的人，尝试给他们分另外一组，如果不可以分配另外一组，则返回 False
+
+那问题的关键在于如何判断“不可以分配另外一组”呢？
+
+![image.png](https://pic.leetcode-cn.com/fe52fe6cd9cb3a8e3c6702b121be858c182d5bba64de89a94eb17352eff6bbea-image.png)
+
+实际上，我们已经用 colors 记录了分组信息，对于每一个人如果分组确定了，我们就更新 colors，那么对于一个人如果分配了一个组，并且他讨厌的人也被分组之后，**分配的组和它只能是一组**，那么“就是不可以分配另外一组”。
+
+代码表示就是：
+
+```py
+# 其中j 表示当前是第几个人，N表示总人数。 dfs的功能就是根据colors和graph分配组，true表示可以分，false表示不可以，具体代码见代码区。
+if colors[j] == 0 and not self.dfs(graph, colors, j, -1 * color, N)
+```
+
+## 关键点
+
+- 二分图
+- 染色法
+- 图的建立和遍历
+- colors 数组
+
+## 代码
+
+```py
+class Solution:
+    def dfs(self, graph, colors, i, color, N):
+        colors[i] = color
+        for j in range(N):
+            # dislike eachother
+            if graph[i][j] == 1:
+                if colors[j] == color:
+                    return False
+                if colors[j] == 0 and not self.dfs(graph, colors, j, -1 * color, N):
+                    return False
+        return True
+
+    def possibleBipartition(self, N: int, dislikes: List[List[int]]) -> bool:
+        graph = [[0] * N for i in range(N)]
+        colors = [0] * N
+        for a, b in dislikes:
+            graph[a - 1][b - 1] = 1
+            graph[b - 1][a - 1] = 1
+        for i in range(N):
+            if colors[i] == 0 and not self.dfs(graph, colors, i, 1, N):
+                return False
+        return True
+
+```
+
+**复杂度分析**
+
+- 时间复杂度：$O(N^2)$
+- 空间复杂度：$O(N)$
+
+## 相关问题
+
+- [785. 判断二分图](785.is-graph-bipartite.md)
+
+更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 30K star 啦。
+
+关注公众号力扣加加，努力用清晰直白的语言还原解题思路，并且有大量图解，手把手教你识别套路，高效刷题。
