original commit

Ziming M · Ziming M · commit da3fd25a82d5 · 2020-01-26T16:59:58.000+08:00
diff --git a/README.md b/README.md
@@ -1,4 +1,7 @@
 # 「LeetCode-Python3习题集」使用说明
+
+[![HitCount](http://hits.dwyl.io/ML-ZimingMeng/LeetCode-Python3.svg)](http://hits.dwyl.io/ML-ZimingMeng/LeetCode-Python3) [![GitHub license](https://img.shields.io/travis/ML-ZimingMeng/LeetCode-Python3.svg)](https://github.com/ML-ZimingMeng/LeetCode-Python3/blob/master/LICENSE)
+
 ## 简介
 「LeetCode-Python3习题集」是本人在LeetCode上的刷题题解，采用Python3书写，供个人参考和学习交流使用。
 ## 如何刷题
diff --git a/source/All_Solutions/305.岛屿数量.py b/source/All_Solutions/305.岛屿数量.py
@@ -0,0 +1,68 @@
+# 假设你设计一个游戏，用一个 m 行 n 列的 2D 网格来存储你的游戏地图。
+#
+# 起始的时候，每个格子的地形都被默认标记为「水」。我们可以通过使用 addLand 进行操作，将位置 (row, col) 的「水」变成「陆地」。
+#
+# 你将会被给定一个列表，来记录所有需要被操作的位置，然后你需要返回计算出来 每次 addLand 操作后岛屿的数量。
+#
+# 注意：一个岛的定义是被「水」包围的「陆地」，通过水平方向或者垂直方向上相邻的陆地连接而成。你可以假设地图网格的四边均被无边无际的「水」所包围。
+#
+# 请仔细阅读下方示例与解析，更加深入了解岛屿的判定。
+#
+# 示例:
+#
+# 输入: m = 3, n = 3, positions = [[0,0], [0,1], [1,2], [2,1]]
+# 输出: [1,1,2,3]
+# 解析:
+#
+# 起初，二维网格 grid 被全部注入「水」。（0 代表「水」，1 代表「陆地」）
+#
+# 0 0 0
+# 0 0 0
+# 0 0 0
+
+
+class Solution:
+    def numIslands2(self, m: int, n: int, positions: List[List[int]]) -> List[int]:
+
+        grid = [[0] * n for _ in range(m)]  # 构建保存岛屿的表格
+        island = collections.defaultdict(set)  # 保存岛屿编号和坐标的哈希表
+
+        directions = [(1, 0), (-1, 0), (0, -1), (0, 1)]  # 上下左右四个方向
+
+        index = 1  # 初始化岛屿编号
+
+        res = []
+
+        for x, y in positions:  # 对每个位置进行遍历
+            if grid[x][y]:  # 如果该位置已经有岛屿编号
+                res.append(len(island))  # 直接在结果中添加当前哈希表的长度
+                continue  # 跳过
+
+            mark = []  # 记录上下左右四个岛屿的编号
+            for dx, dy in directions:  # 对上下左右进行遍历
+                # 当坐标合法，且该坐标为岛屿时，加入mark
+                # 为防止有重复值出现，需要判断该值是否在mark中
+                if 0 <= x + dx < m and 0 <= y + dy < n and grid[x + dx][y + dy] and grid[x + dx][y + dy] not in mark:
+                    mark.append(grid[x + dx][y + dy])
+
+            if len(mark) == 0:  # mark为空，即上下左右都为海洋
+                grid[x][y] = index  # 更新该点在grid中的值
+                island[index].add((x, y))  # 更新哈希表island
+                index += 1  # index + 1
+
+            else:
+                temp = mark[0]  # 如果mark不为空，将mark中所有的岛屿编号统一
+                grid[x][y] = temp  # 设定mark[0]，即temp为统一值
+                island[temp].add((x, y))  # 更新grid[x][y]和哈希表island
+
+                for num in mark[1:]:  # 对于mark中的其他岛屿编号
+                    for i, j in island[num]:  # 从哈希表中取出其所有点的坐标i,j
+                        grid[i][j] = temp  # 更新grid[i][j]
+                    island[temp] |= island[num]  # 更新temp所对应的哈希表，将num对应的坐标加入其中
+                    del island[num]  # 删除哈希表中num的条目
+
+            res.append(len(island))  # 在结果中添加当前哈希表island的长度
+
+        return res
+
+
diff --git a/source/All_Solutions/323.无向图中连通分量的数目.py b/source/All_Solutions/323.无向图中连通分量的数目.py
@@ -0,0 +1,28 @@
+# 给定编号从 0 到 n-1 的 n 个节点和一个无向边列表（每条边都是一对节点），请编写一个函数来计算无向图中连通分量的数目。
+#
+# 示例 1:
+#
+# 输入: n = 5 和 edges = [[0, 1], [1, 2], [3, 4]]
+#
+#      0          3
+#      |          |
+#      1 --- 2    4
+#
+# 输出: 2
+
+class Solution:
+    def countComponents(self, n: int, edges: List[List[int]]) -> int:
+        f = {}
+
+        def find(x):
+            f.setdefault(x, x)
+            if x != f[x]:
+                f[x] = find(f[x])
+            return f[x]
+
+        def union(x, y):
+            f[find(x)] = find(y)
+
+        for x, y in edges:
+            union(x, y)
+        return len(set(find(x) for x in range(n)))
diff --git a/source/Clarification/Union_Find/305.岛屿数量.py b/source/Clarification/Union_Find/305.岛屿数量.py
@@ -0,0 +1,68 @@
+# 假设你设计一个游戏，用一个 m 行 n 列的 2D 网格来存储你的游戏地图。
+#
+# 起始的时候，每个格子的地形都被默认标记为「水」。我们可以通过使用 addLand 进行操作，将位置 (row, col) 的「水」变成「陆地」。
+#
+# 你将会被给定一个列表，来记录所有需要被操作的位置，然后你需要返回计算出来 每次 addLand 操作后岛屿的数量。
+#
+# 注意：一个岛的定义是被「水」包围的「陆地」，通过水平方向或者垂直方向上相邻的陆地连接而成。你可以假设地图网格的四边均被无边无际的「水」所包围。
+#
+# 请仔细阅读下方示例与解析，更加深入了解岛屿的判定。
+#
+# 示例:
+#
+# 输入: m = 3, n = 3, positions = [[0,0], [0,1], [1,2], [2,1]]
+# 输出: [1,1,2,3]
+# 解析:
+#
+# 起初，二维网格 grid 被全部注入「水」。（0 代表「水」，1 代表「陆地」）
+#
+# 0 0 0
+# 0 0 0
+# 0 0 0
+
+
+class Solution:
+    def numIslands2(self, m: int, n: int, positions: List[List[int]]) -> List[int]:
+
+        grid = [[0] * n for _ in range(m)]  # 构建保存岛屿的表格
+        island = collections.defaultdict(set)  # 保存岛屿编号和坐标的哈希表
+
+        directions = [(1, 0), (-1, 0), (0, -1), (0, 1)]  # 上下左右四个方向
+
+        index = 1  # 初始化岛屿编号
+
+        res = []
+
+        for x, y in positions:  # 对每个位置进行遍历
+            if grid[x][y]:  # 如果该位置已经有岛屿编号
+                res.append(len(island))  # 直接在结果中添加当前哈希表的长度
+                continue  # 跳过
+
+            mark = []  # 记录上下左右四个岛屿的编号
+            for dx, dy in directions:  # 对上下左右进行遍历
+                # 当坐标合法，且该坐标为岛屿时，加入mark
+                # 为防止有重复值出现，需要判断该值是否在mark中
+                if 0 <= x + dx < m and 0 <= y + dy < n and grid[x + dx][y + dy] and grid[x + dx][y + dy] not in mark:
+                    mark.append(grid[x + dx][y + dy])
+
+            if len(mark) == 0:  # mark为空，即上下左右都为海洋
+                grid[x][y] = index  # 更新该点在grid中的值
+                island[index].add((x, y))  # 更新哈希表island
+                index += 1  # index + 1
+
+            else:
+                temp = mark[0]  # 如果mark不为空，将mark中所有的岛屿编号统一
+                grid[x][y] = temp  # 设定mark[0]，即temp为统一值
+                island[temp].add((x, y))  # 更新grid[x][y]和哈希表island
+
+                for num in mark[1:]:  # 对于mark中的其他岛屿编号
+                    for i, j in island[num]:  # 从哈希表中取出其所有点的坐标i,j
+                        grid[i][j] = temp  # 更新grid[i][j]
+                    island[temp] |= island[num]  # 更新temp所对应的哈希表，将num对应的坐标加入其中
+                    del island[num]  # 删除哈希表中num的条目
+
+            res.append(len(island))  # 在结果中添加当前哈希表island的长度
+
+        return res
+
+
diff --git a/source/Clarification/Union_Find/323.无向图中连通分量的数目.py b/source/Clarification/Union_Find/323.无向图中连通分量的数目.py
@@ -0,0 +1,28 @@
+# 给定编号从 0 到 n-1 的 n 个节点和一个无向边列表（每条边都是一对节点），请编写一个函数来计算无向图中连通分量的数目。
+#
+# 示例 1:
+#
+# 输入: n = 5 和 edges = [[0, 1], [1, 2], [3, 4]]
+#
+#      0          3
+#      |          |
+#      1 --- 2    4
+#
+# 输出: 2
+
+class Solution:
+    def countComponents(self, n: int, edges: List[List[int]]) -> int:
+        f = {}
+
+        def find(x):
+            f.setdefault(x, x)
+            if x != f[x]:
+                f[x] = find(f[x])
+            return f[x]
+
+        def union(x, y):
+            f[find(x)] = find(y)
+
+        for x, y in edges:
+            union(x, y)
+        return len(set(find(x) for x in range(n)))
diff --git a/source/weeks/5319.删除回文子序列.py b/source/weeks/5319.删除回文子序列.py
@@ -0,0 +1,65 @@
+# 给你一个字符串
+# s，它仅由字母
+# 'a'
+# 和
+# 'b'
+# 组成。每一次删除操作都可以从
+# s
+# 中删除一个回文
+# 子序列。
+#
+# 返回删除给定字符串中所有字符（字符串为空）的最小删除次数。
+#
+# 「子序列」定义：如果一个字符串可以通过删除原字符串某些字符而不改变原字符顺序得到，那么这个字符串就是原字符串的一个子序列。
+#
+# 「回文」定义：如果一个字符串向后和向前读是一致的，那么这个字符串就是一个回文。
+#
+#
+#
+# 示例
+# 1：
+#
+# 输入：s = "ababa"
+# 输出：1
+# 解释：字符串本身就是回文序列，只需要删除一次。
+# 示例
+# 2：
+#
+# 输入：s = "abb"
+# 输出：2
+# 解释："abb" -> "bb" -> "".
+# 先删除回文子序列
+# "a"，然后再删除
+# "bb"。
+# 示例
+# 3：
+#
+# 输入：s = "baabb"
+# 输出：2
+# 解释："baabb" -> "b" -> "".
+# 先删除回文子序列
+# "baab"，然后再删除
+# "b"。
+# 示例
+# 4：
+#
+# 输入：s = ""
+# 输出：0
+#
+# 提示：
+#
+# 0 <= s.length <= 1000
+# s
+# 仅包含字母
+# 'a'
+# 和
+# 'b'
+
+class Solution:
+    def removePalindromeSub(self, s: str) -> int:
+        if s == '':
+            return 0
+        elif s == s[::-1]:
+            return 1
+        else:
+            return 2
diff --git a/source/weeks/5320.餐厅过滤器.py b/source/weeks/5320.餐厅过滤器.py
@@ -0,0 +1,38 @@
+# 给你一个餐馆信息数组 restaurants，其中  restaurants[i] = [idi, ratingi, veganFriendlyi, pricei, distancei]。你必须使用以下三个过滤器来过滤这些餐馆信息。
+#
+# 其中素食者友好过滤器 veganFriendly 的值可以为 true 或者 false，如果为 true 就意味着你应该只包括 veganFriendlyi 为 true 的餐馆，为 false 则意味着可以包括任何餐馆。此外，我们还有最大价格 maxPrice 和最大距离 maxDistance 两个过滤器，它们分别考虑餐厅的价格因素和距离因素的最大值。
+#
+# 过滤后返回餐馆的 id，按照 rating 从高到低排序。如果 rating 相同，那么按 id 从高到低排序。简单起见， veganFriendlyi 和 veganFriendly 为 true 时取值为 1，为 false 时，取值为 0 。
+#
+#  
+#
+# 示例 1：
+#
+# 输入：restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]], veganFriendly = 1, maxPrice = 50, maxDistance = 10
+# 输出：[3,1,5]
+# 解释：
+# 这些餐馆为：
+# 餐馆 1 [id=1, rating=4, veganFriendly=1, price=40, distance=10]
+# 餐馆 2 [id=2, rating=8, veganFriendly=0, price=50, distance=5]
+# 餐馆 3 [id=3, rating=8, veganFriendly=1, price=30, distance=4]
+# 餐馆 4 [id=4, rating=10, veganFriendly=0, price=10, distance=3]
+# 餐馆 5 [id=5, rating=1, veganFriendly=1, price=15, distance=1]
+# 在按照 veganFriendly = 1, maxPrice = 50 和 maxDistance = 10 进行过滤后，我们得到了餐馆 3, 餐馆 1 和 餐馆 5（按评分从高到低排序）。
+
+class Solution:
+    def filterRestaurants(self, restaurants: List[List[int]], veganFriendly: int, maxPrice: int, maxDistance: int) -> List[int]:
+        dic = {}
+        for restaurant in restaurants:
+            if veganFriendly == 0:
+                if restaurant[3] <= maxPrice and restaurant[4] <= maxDistance:
+                        dic[restaurant[0]] = restaurant[1]
+            else:
+                if restaurant[3] <= maxPrice and restaurant[4] <= maxDistance and restaurant[2] == 1:
+                        dic[restaurant[0]] = restaurant[1]
+        res = []
+        # 按照 rating 从高到低排序。如果 rating 相同，那么按 id 从高到低排序。
+        dic = sorted(dic.items(), key = lambda x:[x[1],x[0]],reverse=True)
+        for i in dic:
+            res.append(i[0])
+        return res
+
