2022-11-22-17:07:25

Author: lifeiyang

leetcode/editor/cn/[130]被围绕的区域.py

@@ -0,0 +1,54 @@
+from typing import List
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def solve(self, board: List[List[str]]) -> None:
+        """
+        Do not return anything, modify board in-place instead.
+        """
+        m, n = len(board), len(board[0])
+        self.extra_o = [[False for _ in range(n)] for _ in range(m)]
+        for i in range(m):
+            for j in [0, n - 1]:
+                if board[i][j] == "O" and not self.extra_o[i][j]:
+                    # 为 "O" + 没有访问过 + 不是额外的 O
+                    self.traverse(board, i, j)
+        
+        for j in range(n):
+            for i in [0, m - 1]:
+                if board[i][j] == "O" and not self.extra_o[i][j]:
+                    # 为 "O" + 没有访问过 + 不是额外的 O
+                    self.traverse(board, i, j)
+        
+        # board 中将 self.extra_o 的位置给填上
+        for i in range(m):
+            for j in range(n):
+                if board[i][j] == "O" and not self.extra_o[i][j]:
+                    # board 内是 O，但是 extra_o 内是 False
+                    board[i][j] = "X"
+    
+    def traverse(self, board, i, j):
+        if self.extra_o[i][j]:
+            return
+        self.extra_o[i][j] = True
+        if i - 1 >= 0 and board[i - 1][j] == "O":
+            self.traverse(board, i - 1, j)
+        
+        if i + 1 <= len(board) - 1 and board[i + 1][j] == "O":
+            self.traverse(board, i + 1, j)
+        
+        if j - 1 >= 0 and board[i][j - 1] == "O":
+            self.traverse(board, i, j - 1)
+        
+        if j + 1 <= len(board[0]) - 1 and board[i][j + 1] == "O":
+            self.traverse(board, i, j + 1)
+
+
+# leetcode submit region end(Prohibit modification and deletion)
+
+if __name__ == "__main__":
+    solution = Solution()
+    board = [["O", "O"], ["O", "O"]]
+    solution.solve(board)
+    print(board)

leetcode/editor/cn/[785]判断二分图.py

@@ -0,0 +1,53 @@
+from typing import List
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def isBipartite(self, graph: List[List[int]]) -> bool:
+        # 第一个点在 0 侧，第一个点的邻居应该在 1 侧
+        self.flag = True
+        # 主要是这里，需要考虑
+        for idx in range(len(graph)):
+            self.visited = [False] * len(graph)
+            self.node_side = {idx: 0}
+            self.bfs(graph, idx)
+        return self.flag
+    
+    def traverse(self, graph, node_idx):
+        self.visited[node_idx] = True
+        
+        for neighbor in graph[node_idx]:
+            if not self.visited[neighbor]:
+                # 没有访问过
+                self.node_side[neighbor] = 1 - self.node_side[node_idx]
+                self.traverse(graph, neighbor)
+            elif self.node_side[neighbor] == self.node_side[node_idx]:
+                self.flag = False
+    
+    def bfs(self, graph, node_idx):
+        self.visited[node_idx] = True
+        q = [node_idx]
+        while len(q) > 0:
+            cur = q.pop(0)
+            for neighbor in graph[cur]:
+                if not self.visited[neighbor]:
+                    self.node_side[neighbor] = 1 - self.node_side[cur]
+                    self.visited[neighbor] = True
+                    q.append(neighbor)
+                elif self.node_side[neighbor] == self.node_side[cur]:
+                    self.flag = False
+                    return
+
+
+# leetcode submit region end(Prohibit modification and deletion)
+
+
+if __name__ == "__main__":
+    solution = Solution()
+    print(solution.isBipartite(
+            [[], [2, 4, 6], [1, 4, 8, 9], [7, 8], [1, 2, 8, 9], [6, 9], [1, 5, 7, 8, 9], [3, 6, 9], [2, 3, 4, 6, 9],
+             [2, 4, 5, 6, 7, 8]]), False)
+    print(solution.isBipartite([[], [3], [], [1], []]), True)
+    print(solution.isBipartite([[1, 2, 3], [0, 2], [0, 1, 3], [0, 2]]), False)
+    print(solution.isBipartite([[1, 3], [0, 2], [1, 3], [0, 2]]), True)
+    print(solution.isBipartite([[0]]), False)

leetcode/editor/cn/[886]可能的二分法.py

@@ -0,0 +1,44 @@
+from typing import List
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def possibleBipartition(self, n: int, dislikes: List[List[int]]) -> bool:
+        graph = self.build_graph(dislikes)
+        self.visited = [False] * n
+        self.flag = True
+        
+        for node_idx in range(n):
+            if not self.visited[node_idx]:
+                self.node_side = {node_idx: 0}
+                self.traverse(graph, node_idx)
+        
+        return self.flag
+    
+    def traverse(self, graph, node_idx):
+        self.visited[node_idx] = True
+        for neighbor in graph[node_idx]:
+            if not self.visited[neighbor]:
+                # 没有访问过
+                self.node_side[neighbor] = 1 - self.node_side[node_idx]
+                self.traverse(graph, neighbor)
+            elif self.node_side[neighbor] != 1 - self.node_side[node_idx]:
+                # 访问过，但是节点关系不正确
+                self.flag = False
+    
+    def build_graph(self, dislikes):
+        from collections import defaultdict
+        graph = defaultdict(list)
+        for pair in dislikes:
+            graph[pair[0] - 1].append(pair[1] - 1)
+            graph[pair[1] - 1].append(pair[0] - 1)
+        return graph
+
+
+# leetcode submit region end(Prohibit modification and deletion)
+
+if __name__ == "__main__":
+    solution = Solution()
+    print(solution.possibleBipartition(4, [[1, 2], [1, 3], [2, 4]]), True)
+    print(solution.possibleBipartition(3, [[1, 2], [1, 3], [2, 3]]), False)
+    print(solution.possibleBipartition(5, [[1, 2], [2, 3], [3, 4], [4, 5], [1, 5]]), False)

leetcode/editor/cn/[990]等式方程的可满足性.py

@@ -0,0 +1,65 @@
+from typing import List
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class UnionFind:
+    def __init__(self, char_list):
+        self.parent = {}
+        for char in char_list:
+            self.parent[char] = char
+    
+    def connect(self, char1, char2):
+        char1_root = self.find_parent(char1)
+        char2_root = self.find_parent(char2)
+        
+        self.parent[char1_root] = char2_root
+    
+    def find_parent(self, char):
+        if self.parent[char] != char:
+            self.parent[char] = self.find_parent(self.parent[char])
+        return self.parent[char]
+    
+    def is_connect(self, char1, char2):
+        char1_parent = self.find_parent(char1)
+        char2_parent = self.find_parent(char2)
+        return char1_parent == char2_parent
+
+
+class Solution:
+    def equationsPossible(self, equations: List[str]) -> bool:
+        char_set = set()
+        
+        for pair in equations:
+            char_set.add(pair[0])
+            char_set.add(pair[-1])
+        uf = UnionFind(list(char_set))
+        
+        # 构造关系
+        for pair in equations:
+            if "==" in pair:
+                uf.connect(pair[0], pair[-1])
+        
+        # 开始验证
+        flag = True
+        for pair in equations:
+            if "!=" in pair:
+                if uf.is_connect(pair[0], pair[-1]):
+                    flag = False
+        return flag
+
+
+# leetcode submit region end(Prohibit modification and deletion)
+
+if __name__ == "__main__":
+    solution = Solution()
+    print(solution.equationsPossible(["a==b", "b!=c", "c==a"]), False)
+    print(solution.equationsPossible(["e==e", "d!=e", "c==d", "d!=e"]), True)
+    print(solution.equationsPossible(["e!=c", "b!=b", "b!=a", "e==d"]), False)
+    print(solution.equationsPossible(["a!=a"]), False)
+    print(solution.equationsPossible(["a==a"]), True)
+    print(solution.equationsPossible(["a==b"]), True)
+    print(solution.equationsPossible(["a!=b"]), True)
+    print(solution.equationsPossible(["a==b", "b!=a"]), False)
+    print(solution.equationsPossible(["b==a", "a==b"]), True)
+    print(solution.equationsPossible(["a==b", "b==c", "a==c"]), True)
+    print(solution.equationsPossible(["c==c", "b==d", "x!=z"]), True)

leetcode/editor/cn/doc/content/[130]被围绕的区域.md

@@ -0,0 +1,35 @@
+给你一个 <code>m x n</code> 的矩阵 <code>board</code> ，由若干字符 <code>'X'</code> 和 <code>'O'</code> ，找到所有被 <code>'X'</code> 围绕的区域，并将这些区域里所有的 <code>'O'</code> 用 <code>'X'</code> 填充。
+
+<div class="original__bRMd"> 
+ <div> 
+  <p>&nbsp;</p> 
+ </div>
+</div>
+
+<p><strong>示例 1：</strong></p> 
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/xogrid.jpg" style="width: 550px; height: 237px;" /> 
+<pre>
+<strong>输入：</strong>board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
+<strong>输出：</strong>[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
+<strong>解释：</strong>被围绕的区间不会存在于边界上，换句话说，任何边界上的&nbsp;<span><code>'O'</code></span>&nbsp;都不会被填充为&nbsp;<span><code>'X'</code></span>。 任何不在边界上，或不与边界上的&nbsp;<span><code>'O'</code></span>&nbsp;相连的&nbsp;<span><code>'O'</code></span>&nbsp;最终都会被填充为&nbsp;<span><code>'X'</code></span>。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>board = [["X"]]
+<strong>输出：</strong>[["X"]]
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul> 
+ <li><code>m == board.length</code></li> 
+ <li><code>n == board[i].length</code></li> 
+ <li><code>1 &lt;= m, n &lt;= 200</code></li> 
+ <li><code>board[i][j]</code> 为 <code>'X'</code> 或 <code>'O'</code></li> 
+</ul>
+
+<div><div>Related Topics</div><div><li>深度优先搜索</li><li>广度优先搜索</li><li>并查集</li><li>数组</li><li>矩阵</li></div></div><br><div><li>👍 893</li><li>👎 0</li></div>

leetcode/editor/cn/doc/content/[785]判断二分图.md

@@ -0,0 +1,44 @@
+存在一个 <strong>无向图</strong> ，图中有 <code>n</code> 个节点。其中每个节点都有一个介于 <code>0</code> 到 <code>n - 1</code> 之间的唯一编号。给你一个二维数组 <code>graph</code> ，其中 <code>graph[u]</code> 是一个节点数组，由节点 <code>u</code> 的邻接节点组成。形式上，对于 <code>graph[u]</code> 中的每个 <code>v</code> ，都存在一条位于节点 <code>u</code> 和节点 <code>v</code> 之间的无向边。该无向图同时具有以下属性：
+
+<ul> 
+ <li>不存在自环（<code>graph[u]</code> 不包含 <code>u</code>）。</li> 
+ <li>不存在平行边（<code>graph[u]</code> 不包含重复值）。</li> 
+ <li>如果 <code>v</code> 在 <code>graph[u]</code> 内，那么 <code>u</code> 也应该在 <code>graph[v]</code> 内（该图是无向图）</li> 
+ <li>这个图可能不是连通图，也就是说两个节点 <code>u</code> 和 <code>v</code> 之间可能不存在一条连通彼此的路径。</li> 
+</ul>
+
+<p><strong>二分图</strong> 定义：如果能将一个图的节点集合分割成两个独立的子集 <code>A</code> 和 <code>B</code> ，并使图中的每一条边的两个节点一个来自 <code>A</code> 集合，一个来自 <code>B</code> 集合，就将这个图称为 <strong>二分图</strong> 。</p>
+
+<p>如果图是二分图，返回 <code>true</code><em> </em>；否则，返回 <code>false</code> 。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p> 
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/21/bi2.jpg" style="width: 222px; height: 222px;" /> 
+<pre>
+<strong>输入：</strong>graph = [[1,2,3],[0,2],[0,1,3],[0,2]]
+<strong>输出：</strong>false
+<strong>解释：</strong><span><code>不能将节点分割成两个独立的子集，</code></span>以使每条边都连通一个子集中的一个节点与另一个子集中的一个节点。</pre>
+
+<p><strong>示例 2：</strong></p> 
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/21/bi1.jpg" style="width: 222px; height: 222px;" /> 
+<pre>
+<strong>输入：</strong>graph = [[1,3],[0,2],[1,3],[0,2]]
+<strong>输出：</strong>true
+<strong>解释：</strong><span><code>可以将节点分成两组: {0, 2} 和 {1, 3} 。</code></span></pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul> 
+ <li><code>graph.length == n</code></li> 
+ <li><code>1 &lt;= n &lt;= 100</code></li> 
+ <li><code>0 &lt;= graph[u].length &lt; n</code></li> 
+ <li><code>0 &lt;= graph[u][i] &lt;= n - 1</code></li> 
+ <li><code>graph[u]</code> 不会包含 <code>u</code></li> 
+ <li><code>graph[u]</code> 的所有值 <strong>互不相同</strong></li> 
+ <li>如果 <code>graph[u]</code> 包含 <code>v</code>，那么 <code>graph[v]</code> 也会包含 <code>u</code></li> 
+</ul>
+
+<div><div>Related Topics</div><div><li>深度优先搜索</li><li>广度优先搜索</li><li>并查集</li><li>图</li></div></div><br><div><li>👍 424</li><li>👎 0</li></div>

leetcode/editor/cn/doc/content/[886]可能的二分法.md

@@ -0,0 +1,47 @@
+<p>给定一组&nbsp;<code>n</code>&nbsp;人（编号为&nbsp;<code>1, 2, ..., n</code>），&nbsp;我们想把每个人分进<strong>任意</strong>大小的两组。每个人都可能不喜欢其他人，那么他们不应该属于同一组。</p>
+
+<p>给定整数 <code>n</code>&nbsp;和数组 <code>dislikes</code>&nbsp;，其中&nbsp;<code>dislikes[i] = [a<sub>i</sub>, b<sub>i</sub>]</code>&nbsp;，表示不允许将编号为 <code>a<sub>i</sub></code>&nbsp;和&nbsp;&nbsp;<code>b<sub>i</sub></code>的人归入同一组。当可以用这种方法将所有人分进两组时，返回 <code>true</code>；否则返回 <code>false</code>。</p>
+
+<p>&nbsp;</p>
+
+<ol> 
+</ol>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 4, dislikes = [[1,2],[1,3],[2,4]]
+<strong>输出：</strong>true
+<strong>解释：</strong>group1 [1,4], group2 [2,3]
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 3, dislikes = [[1,2],[1,3],[2,3]]
+<strong>输出：</strong>false
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 5, dislikes = [[1,2],[2,3],[3,4],[4,5],[1,5]]
+<strong>输出：</strong>false
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul> 
+ <li><code>1 &lt;= n &lt;= 2000</code></li> 
+ <li><code>0 &lt;= dislikes.length &lt;= 10<sup>4</sup></code></li> 
+ <li><code>dislikes[i].length == 2</code></li> 
+ <li><code>1 &lt;= dislikes[i][j] &lt;= n</code></li> 
+ <li><code>a<sub>i</sub>&nbsp;&lt; b<sub>i</sub></code></li> 
+ <li><code>dislikes</code>&nbsp;中每一组都 <strong>不同</strong></li> 
+</ul>
+
+<p>&nbsp;</p>
+
+<div><div>Related Topics</div><div><li>深度优先搜索</li><li>广度优先搜索</li><li>并查集</li><li>图</li></div></div><br><div><li>👍 349</li><li>👎 0</li></div>