2022-11-22-17:07:25

Author: lifeiyang

leetcode/editor/cn/[102]二叉树的层序遍历.py

@@ -23,21 +23,20 @@ def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
         queue = []
         res = []
 
-        queue.append(root)
+        queue.append([root, 0])
 
         while len(queue) > 0:
-            temp_res = []
-            queue_length = len(queue)
-            # 注意这里的双层循环设计，这样可以将同一层结果使用 temp_res 记录
-            for i in range(queue_length):
-                cur = queue.pop(0)
-                if cur.left is not None:
-                    queue.append(cur.left)
-                if cur.right is not None:
-                    queue.append(cur.right)
-                temp_res.append(cur.val)
+            cur, depth = queue.pop(0)
+            if cur.left is not None:
+                queue.append([cur.left, depth + 1])
+            if cur.right is not None:
+                queue.append([cur.right, depth + 1])
 
-            res.append(temp_res)
+            # depth 为 0 的时候，res 需要有 1 个长度了
+            if len(res) == depth:
+                res.append([cur.val])
+            else:
+                res[depth].append(cur.val)
 
         return res
 

leetcode/editor/cn/[1514]概率最大的路径.py

@@ -0,0 +1,78 @@
+from typing import List
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def maxProbability(self, n: int, edges: List[List[int]], succProb: List[float], start: int, end: int) -> float:
+        # 权重
+        weight = {}
+        for edge, prob in zip(edges, succProb):
+            weight[tuple([edge[0], edge[1]])] = prob
+            weight[tuple([edge[1], edge[0]])] = prob
+        
+        graph = self.build_graph(n, edges)
+        
+        # 每个点距离 start 的距离, start 本身为 0
+        distance_to_start = [0] * n
+        distance_to_start[start] = 1
+        
+        # 开始 bfs
+        queue = [[start, 1]]
+        while len(queue) > 0:
+            from_node, from_distance = queue.pop(0)
+            if from_distance < distance_to_start[from_node]:
+                # 已经有概率更大的实现了
+                continue
+            
+            for neighbor_node in graph[from_node]:
+                if tuple([from_node, neighbor_node]) in weight:
+                    neighbor_distance = distance_to_start[from_node] * weight[tuple([from_node, neighbor_node])]
+                    if distance_to_start[neighbor_node] < neighbor_distance:
+                        distance_to_start[neighbor_node] = neighbor_distance
+                        queue.append([neighbor_node, neighbor_distance])
+        
+        return distance_to_start[end]
+    
+    def build_graph(self, n, edges):
+        graph = [[] for _ in range(n)]
+        for edge in edges:
+            from_node, to_node = edge
+            graph[from_node].append(to_node)
+            graph[to_node].append(from_node)
+        return graph
+
+
+# leetcode submit region end(Prohibit modification and deletion)
+
+
+if __name__ == "__main__":
+    solution = Solution()
+    
+    n = 5
+    edges = [[1, 4], [2, 4], [0, 4], [0, 3], [0, 2], [2, 3]]
+    succProb = [0.37, 0.17, 0.93, 0.23, 0.39, 0.04]
+    start = 3
+    end = 4
+    print(solution.maxProbability(n, edges, succProb, start, end), 0.2139)
+    
+    n = 3
+    edges = [[0, 1]]
+    succProb = [0.5]
+    start = 0
+    end = 2
+    print(solution.maxProbability(n, edges, succProb, start, end), 0)
+    
+    n = 3
+    edges = [[0, 1], [1, 2], [0, 2]]
+    succProb = [0.5, 0.5, 0.2]
+    start = 0
+    end = 2
+    
+    print(solution.maxProbability(n, edges, succProb, start, end), 0.25)
+    
+    n = 3
+    edges = [[0, 1], [1, 2], [0, 2]]
+    succProb = [0.5, 0.5, 0.3]
+    start = 0
+    end = 2
+    print(solution.maxProbability(n, edges, succProb, start, end), 0.3)

leetcode/editor/cn/[1631]最小体力消耗路径.py

@@ -0,0 +1,43 @@
+import math
+from typing import List
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def minimumEffortPath(self, heights: List[List[int]]) -> int:
+        m, n = len(heights), len(heights[0])
+        
+        # 出发点
+        queue = [[[0, 0], 0]]
+        distance_from_index = [[math.inf for _ in range(n)] for _ in range(m)]
+        distance_from_index[0][0] = 0
+        
+        while len(queue) > 0:
+            from_node, from_distance = queue.pop(0)
+            for move in [[-1, 0], [1, 0], [0, -1], [0, 1]]:
+                neighbor = [from_node[0] + move[0], from_node[1] + move[1]]
+                if 0 <= neighbor[0] < m and 0 <= neighbor[1] < n:
+                    # 判断是否越界
+                    neighbor_distance = max(
+                            distance_from_index[from_node[0]][from_node[1]],
+                            abs(
+                                    heights[from_node[0]][from_node[1]] -
+                                    heights[neighbor[0]][neighbor[1]]
+                            )
+                    )
+                    if neighbor_distance < distance_from_index[neighbor[0]][neighbor[1]]:
+                        distance_from_index[neighbor[0]][neighbor[1]] = neighbor_distance
+                        queue.append([neighbor, neighbor_distance])
+        
+        return distance_from_index[m - 1][n - 1]
+
+
+# leetcode submit region end(Prohibit modification and deletion)
+
+if __name__ == "__main__":
+    solution = Solution()
+    print(solution.minimumEffortPath([[1, 10, 6, 7, 9, 10, 4, 9]]), 9)
+    print(solution.minimumEffortPath([[1, 2, 2], [3, 8, 2], [5, 3, 5]]), 2)
+    print(solution.minimumEffortPath(
+            [[1, 2, 1, 1, 1], [1, 2, 1, 2, 1], [1, 2, 1, 2, 1], [1, 2, 1, 2, 1], [1, 1, 1, 2, 1]]), 0)
+    print(solution.minimumEffortPath([[1, 2, 3], [3, 8, 4], [5, 3, 5]]), 1)

leetcode/editor/cn/[28]找出字符串中第一个匹配项的下标.py

@@ -0,0 +1,4 @@
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def strStr(self, haystack: str, needle: str) -> int:
+# leetcode submit region end(Prohibit modification and deletion)

leetcode/editor/cn/[743]网络延迟时间.py

@@ -0,0 +1,44 @@
+import math
+from typing import List
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
+        # 构造 graph 和 边的权重，所有都 - 1
+        graph = [[] for _ in range(n)]
+        weight = [[0 for _ in range(n)] for _ in range(n)]
+        for source_node, target_node, value in times:
+            graph[source_node - 1].append(target_node - 1)
+            weight[source_node - 1][target_node - 1] = value
+        
+        # 一开始距离是无穷远
+        distance_from_k = [math.inf] * n
+        
+        # 初始节点
+        distance_from_k[k - 1] = 0
+        queue = [[k - 1, 0]]
+        while len(queue) > 0:
+            from_node, from_distance = queue.pop(0)
+            if from_distance > distance_from_k[from_node]:
+                continue
+            
+            for neighbor in graph[from_node]:
+                neighbor_distance = distance_from_k[from_node] + weight[from_node][neighbor]
+                if neighbor_distance < distance_from_k[neighbor]:
+                    distance_from_k[neighbor] = neighbor_distance
+                    queue.append([neighbor, neighbor_distance])
+        
+        if math.inf in distance_from_k:
+            return -1
+        else:
+            return max(distance_from_k)
+
+
+# leetcode submit region end(Prohibit modification and deletion)
+
+if __name__ == "__main__":
+    solution = Solution()
+    print(solution.networkDelayTime([[2, 1, 1], [2, 3, 1], [3, 4, 1]], 4, 2), 2)
+    print(solution.networkDelayTime([[1, 2, 1]], 2, 1), 1)
+    print(solution.networkDelayTime([[1, 2, 1]], 2, 2), -1)

leetcode/editor/cn/[76]最小覆盖子串.py

@@ -1,4 +1,60 @@
 # leetcode submit region begin(Prohibit modification and deletion)
+import math
+
+
 class Solution:
+    
     def minWindow(self, s: str, t: str) -> str:
+        need_char_2_count = {}
+        for char in t:
+            if char not in need_char_2_count:
+                need_char_2_count[char] = 1
+            else:
+                need_char_2_count[char] += 1
+        
+        left, right = 0, 0
+        window_char_2_count = {}
+        valid = 0
+        
+        window_left, window_len = 0, math.inf
+        while right < len(s):
+            
+            # 更新窗口内的数据分布
+            if s[right] in window_char_2_count:
+                window_char_2_count[s[right]] += 1
+            else:
+                window_char_2_count[s[right]] = 1
+            
+            if s[right] in need_char_2_count and \
+                    window_char_2_count[s[right]] == need_char_2_count[s[right]]:
+                valid += 1
+            
+            right += 1
+            while valid == len(need_char_2_count):
+                if right - left < window_len:
+                    window_len = right - left
+                    window_left = left
+                
+                # 更新窗口内的数据分布
+                if s[left] in need_char_2_count and \
+                        window_char_2_count[s[left]] == need_char_2_count[s[left]]:
+                    valid -= 1
+                
+                window_char_2_count[s[left]] -= 1
+                left += 1
+        
+        if window_len == math.inf:
+            return ""
+        else:
+            return s[window_left:window_left + window_len]
+
+
 # leetcode submit region end(Prohibit modification and deletion)
+
+
+if __name__ == "__main__":
+    solution = Solution()
+    print(solution.minWindow("ADOBECODEBANC", "ABC"), "BANC")
+    print(solution.minWindow("aa", "aa"), "aa")
+    print(solution.minWindow("a", "a"), "a")
+    print(solution.minWindow("a", "aa"), "")

leetcode/editor/cn/doc/content/[1514]概率最大的路径.md

@@ -0,0 +1,50 @@
+<p>给你一个由 <code>n</code> 个节点（下标从 0 开始）组成的无向加权图，该图由一个描述边的列表组成，其中 <code>edges[i] = [a, b]</code> 表示连接节点 a 和 b 的一条无向边，且该边遍历成功的概率为 <code>succProb[i]</code> 。</p>
+
+<p>指定两个节点分别作为起点 <code>start</code> 和终点 <code>end</code> ，请你找出从起点到终点成功概率最大的路径，并返回其成功概率。</p>
+
+<p>如果不存在从 <code>start</code> 到 <code>end</code> 的路径，请 <strong>返回 0</strong> 。只要答案与标准答案的误差不超过 <strong>1e-5 </strong>，就会被视作正确答案。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/1558_ex1.png" style="height: 186px; width: 187px;" /></strong></p>
+
+<pre><strong>输入：</strong>n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.2], start = 0, end = 2
+<strong>输出：</strong>0.25000
+<strong>解释：</strong>从起点到终点有两条路径，其中一条的成功概率为 0.2 ，而另一条为 0.5 * 0.5 = 0.25
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/1558_ex2.png" style="height: 186px; width: 189px;" /></strong></p>
+
+<pre><strong>输入：</strong>n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.3], start = 0, end = 2
+<strong>输出：</strong>0.30000
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/1558_ex3.png" style="height: 191px; width: 215px;" /></strong></p>
+
+<pre><strong>输入：</strong>n = 3, edges = [[0,1]], succProb = [0.5], start = 0, end = 2
+<strong>输出：</strong>0.00000
+<strong>解释：</strong>节点 0 和 节点 2 之间不存在路径
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul> 
+ <li><code>2 &lt;= n &lt;= 10^4</code></li> 
+ <li><code>0 &lt;= start, end &lt; n</code></li> 
+ <li><code>start != end</code></li> 
+ <li><code>0 &lt;= a, b &lt; n</code></li> 
+ <li><code>a != b</code></li> 
+ <li><code>0 &lt;= succProb.length == edges.length &lt;= 2*10^4</code></li> 
+ <li><code>0 &lt;= succProb[i] &lt;= 1</code></li> 
+ <li>每两个节点之间最多有一条边</li> 
+</ul>
+
+<div><div>Related Topics</div><div><li>图</li><li>数组</li><li>最短路</li><li>堆（优先队列）</li></div></div><br><div><li>👍 113</li><li>👎 0</li></div>

leetcode/editor/cn/doc/content/[1631]最小体力消耗路径.md

@@ -0,0 +1,49 @@
+<p>你准备参加一场远足活动。给你一个二维&nbsp;<code>rows x columns</code>&nbsp;的地图&nbsp;<code>heights</code>&nbsp;，其中&nbsp;<code>heights[row][col]</code>&nbsp;表示格子&nbsp;<code>(row, col)</code>&nbsp;的高度。一开始你在最左上角的格子&nbsp;<code>(0, 0)</code>&nbsp;，且你希望去最右下角的格子&nbsp;<code>(rows-1, columns-1)</code>&nbsp;（注意下标从 <strong>0</strong> 开始编号）。你每次可以往 <strong>上</strong>，<strong>下</strong>，<strong>左</strong>，<strong>右</strong>&nbsp;四个方向之一移动，你想要找到耗费 <strong>体力</strong> 最小的一条路径。</p>
+
+<p>一条路径耗费的 <strong>体力值</strong>&nbsp;是路径上相邻格子之间 <strong>高度差绝对值</strong>&nbsp;的 <strong>最大值</strong>&nbsp;决定的。</p>
+
+<p>请你返回从左上角走到右下角的最小<strong>&nbsp;体力消耗值</strong>&nbsp;。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/10/25/ex1.png" style="width: 300px; height: 300px;" /></p>
+
+<pre>
+<b>输入：</b>heights = [[1,2,2],[3,8,2],[5,3,5]]
+<b>输出：</b>2
+<b>解释：</b>路径 [1,3,5,3,5] 连续格子的差值绝对值最大为 2 。
+这条路径比路径 [1,2,2,2,5] 更优，因为另一条路径差值最大值为 3 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/10/25/ex2.png" style="width: 300px; height: 300px;" /></p>
+
+<pre>
+<b>输入：</b>heights = [[1,2,3],[3,8,4],[5,3,5]]
+<b>输出：</b>1
+<b>解释：</b>路径 [1,2,3,4,5] 的相邻格子差值绝对值最大为 1 ，比路径 [1,3,5,3,5] 更优。
+</pre>
+
+<p><strong>示例 3：</strong></p> 
+<img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/10/25/ex3.png" style="width: 300px; height: 300px;" /> 
+<pre>
+<b>输入：</b>heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]
+<b>输出：</b>0
+<b>解释：</b>上图所示路径不需要消耗任何体力。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul> 
+ <li><code>rows == heights.length</code></li> 
+ <li><code>columns == heights[i].length</code></li> 
+ <li><code>1 &lt;= rows, columns &lt;= 100</code></li> 
+ <li><code>1 &lt;= heights[i][j] &lt;= 10<sup>6</sup></code></li> 
+</ul>
+
+<div><div>Related Topics</div><div><li>深度优先搜索</li><li>广度优先搜索</li><li>并查集</li><li>数组</li><li>二分查找</li><li>矩阵</li><li>堆（优先队列）</li></div></div><br><div><li>👍 325</li><li>👎 0</li></div>