original commit

Author: Ziming M

README.md

@@ -39,7 +39,7 @@
 ## 关于作者
 - 我的博客：[ziming.xyz](https://www.ziming.xyz/)
 - LeetCode主页：[Pumpkin🎃](https://leetcode-cn.com/u/ml-zimingmeng/)
-- 微信: [🔰Wechat](/me/wechat.png)
+- 微信: [🔰Wechat](/me/wechat.jpg)
 ## 结尾
 - 为了带来最佳的阅读体验，本文遵循[「中文文案排版指北」](https://github.com/mzlogin/chinese-copywriting-guidelines)。
 - 更多 Markdown 语法，请查看 [官方文档](https://www.markdownguide.org/basic-syntax/)。

me/wechat.jpg

@@ -0,0 +1,39 @@
+# 有一队人（两人或以上）想要在一个地方碰面，他们希望能够最小化他们的总行走距离。
+
+# 给你一个 2D 网格，其中各个格子内的值要么是 0，要么是 1。
+
+# 1 表示某个人的家所处的位置。这里，我们将使用 曼哈顿距离 来计算，其中 distance(p1, p2) = |p2.x - p1.x| + |p2.y - p1.y|。
+
+# 示例：
+
+# 输入:
+
+# 1 - 0 - 0 - 0 - 1
+# |   |   |   |   |
+# 0 - 0 - 0 - 0 - 0
+# |   |   |   |   |
+# 0 - 0 - 1 - 0 - 0
+
+# 输出: 6
+
+# 解析: 给定的三个人分别住在(0,0)，(0,4) 和 (2,2):
+#      (0,2) 是一个最佳的碰面点，其总行走距离为 2 + 2 + 2 = 6，最小，因此返回 6。
+
+class Solution:
+    def minTotalDistance(self, grid: List[List[int]]) -> int:
+        if len(grid) == 0 or len(grid[0]) == 0: return 0
+        n, m = len(grid), len(grid[0])
+        lx, ly = [], []
+        for y in range(n):
+            for x in range(m):
+                if grid[y][x] == 1:
+                    lx.append(x)
+                    ly.append(y)
+        lx.sort()
+        ly.sort()
+        cnt = len(lx)
+        mx, my = lx[cnt >> 1], ly[cnt >> 1]
+        res = 0
+        for x in lx:    res += abs(x - mx)
+        for y in ly:    res += abs(y - my)
+        return res

source/All_Solutions/296.最佳的碰头地点.py

@@ -0,0 +1,84 @@
+# 你是个房地产开发商，想要选择一片空地 建一栋大楼。你想把这栋大楼够造在一个距离周边设施都比较方便的地方，通过调研，你希望从它出发能在 最短的距离和 内抵达周边全部的建筑物。请你计算出这个最佳的选址到周边全部建筑物的 最短距离和。
+#
+#  
+#
+# 注意：
+#
+# 你只能通过向上、下、左、右四个方向上移动。
+#
+# 给你一个由 0、1 和 2 组成的二维网格，其中：
+#
+# 0 代表你可以自由通过和选择建造的空地
+# 1 代表你无非通行的建筑物
+# 2 代表你无非通行的障碍物
+#  
+#
+# 示例：
+#
+# 输入: [[1,0,2,0,1],[0,0,0,0,0],[0,0,1,0,0]]
+#
+# 1 - 0 - 2 - 0 - 1
+# |   |   |   |   |
+# 0 - 0 - 0 - 0 - 0
+# |   |   |   |   |
+# 0 - 0 - 1 - 0 - 0
+#
+# 输出: 7
+#
+# 解析:
+# 给定三个建筑物 (0,0)、(0,4) 和 (2,2) 以及一个位于 (0,2) 的障碍物。
+# 由于总距离之和 3+3+1=7 最优，所以位置 (1,2) 是符合要求的最优地点，故返回7。
+
+import queue
+import sys
+
+
+class Solution:
+    def shortestDistance(self, grid: List[List[int]]) -> int:
+        r = len(grid)
+        c = len(grid[0])
+        count = [[0 for _ in range(c)] for _ in range(r)]
+        dist = [[0 for _ in range(c)] for _ in range(r)]
+        d = [[0, 1], [0, -1], [1, 0], [-1, 0]]
+        buildings = 0
+
+        # initial
+        for i in range(r):
+            for j in range(c):
+                if grid[i][j] == 1:
+                    buildings += 1
+                    qu = queue.Queue()
+                    visit = [[0 for _ in range(c)] for _ in range(r)]
+
+                    qu.put((i, j))
+                    visit[i][j] = 1
+                    step = 0
+                    while not qu.empty():
+                        sz = qu.qsize()
+                        step += 1
+
+                        for k in range(sz):
+                            curr = qu.get()
+                            for m in range(4):
+                                x = curr[0] + d[m][0]
+                                y = curr[1] + d[m][1]
+                                if x >= 0 and x < r and y >= 0 and y < c:
+                                    if visit[x][y] == 0 and grid[x][y] == 0:
+                                        visit[x][y] = 1
+                                        count[x][y] += 1
+                                        dist[x][y] += step
+                                        qu.put((x, y))
+
+        res = sys.maxsize
+        for i in range(0, r):
+            for j in range(0, c):
+                if grid[i][j] == 0 and count[i][j] == buildings:
+                    res = min(res, dist[i][j])
+
+        if res == sys.maxsize:
+            return -1
+        else:
+            return res
+
+
+

source/All_Solutions/317.离建筑物最近的距离.py

@@ -0,0 +1,60 @@
+# 想象一下炸弹人游戏，在你面前有一个二维的网格来表示地图，网格中的格子分别被以下三种符号占据：
+#
+# 'W' 表示一堵墙
+# 'E' 表示一个敌人
+# '0'（数字 0）表示一个空位
+#
+#
+# 请你计算一个炸弹最多能炸多少敌人。
+#
+# 由于炸弹的威力不足以穿透墙体，炸弹只能炸到同一行和同一列没被墙体挡住的敌人。
+#
+# 注意：你只能把炸弹放在一个空的格子里
+#
+# 示例:
+#
+# 输入: [["0","E","0","0"],["E","0","W","E"],["0","E","0","0"]]
+# 输出: 3
+# 解释: 对于如下网格
+#
+# 0 E 0 0
+# E 0 W E
+# 0 E 0 0
+#
+# 假如在位置 (1,1) 放置炸弹的话，可以炸到 3 个敌人
+
+class Solution:
+    def maxKilledEnemies(self, grid: List[List[str]]) -> int:
+        if not grid: return 0
+        r = len(grid)
+        c = len(grid[0])
+
+        def cal(row,col):
+            res = 0
+            left,right = col - 1,col + 1
+            while left >= 0 and grid[row][left] != "W":
+                if grid[row][left] == 'E':
+                    res += 1
+                left -= 1
+            while right < c and grid[row][right] != 'W':
+                if grid[row][right] == 'E':
+                    res += 1
+                right += 1
+            up,down = row - 1,row + 1
+            while up >= 0 and grid[up][col] != 'W':
+                if grid[up][col] == 'E':
+                    res += 1
+                up -= 1
+            while down < r and grid[down][col] != 'W':
+                if grid[down][col] == 'E':
+                    res += 1
+                down += 1
+            return res
+        res = 0
+        for i in range(r):
+            for j in range(c):
+                if grid[i][j] == "0":
+                    res = max(res,cal(i,j))
+        return res
+
+

source/All_Solutions/361.轰炸敌人.py

@@ -0,0 +1,39 @@
+# 有一队人（两人或以上）想要在一个地方碰面，他们希望能够最小化他们的总行走距离。
+
+# 给你一个 2D 网格，其中各个格子内的值要么是 0，要么是 1。
+
+# 1 表示某个人的家所处的位置。这里，我们将使用 曼哈顿距离 来计算，其中 distance(p1, p2) = |p2.x - p1.x| + |p2.y - p1.y|。
+
+# 示例：
+
+# 输入:
+
+# 1 - 0 - 0 - 0 - 1
+# |   |   |   |   |
+# 0 - 0 - 0 - 0 - 0
+# |   |   |   |   |
+# 0 - 0 - 1 - 0 - 0
+
+# 输出: 6
+
+# 解析: 给定的三个人分别住在(0,0)，(0,4) 和 (2,2):
+#      (0,2) 是一个最佳的碰面点，其总行走距离为 2 + 2 + 2 = 6，最小，因此返回 6。
+
+class Solution:
+    def minTotalDistance(self, grid: List[List[int]]) -> int:
+        if len(grid) == 0 or len(grid[0]) == 0: return 0
+        n, m = len(grid), len(grid[0])
+        lx, ly = [], []
+        for y in range(n):
+            for x in range(m):
+                if grid[y][x] == 1:
+                    lx.append(x)
+                    ly.append(y)
+        lx.sort()
+        ly.sort()
+        cnt = len(lx)
+        mx, my = lx[cnt >> 1], ly[cnt >> 1]
+        res = 0
+        for x in lx:    res += abs(x - mx)
+        for y in ly:    res += abs(y - my)
+        return res

source/Clarification/Matrix/296.最佳的碰头地点.py

@@ -0,0 +1,84 @@
+# 你是个房地产开发商，想要选择一片空地 建一栋大楼。你想把这栋大楼够造在一个距离周边设施都比较方便的地方，通过调研，你希望从它出发能在 最短的距离和 内抵达周边全部的建筑物。请你计算出这个最佳的选址到周边全部建筑物的 最短距离和。
+#
+#  
+#
+# 注意：
+#
+# 你只能通过向上、下、左、右四个方向上移动。
+#
+# 给你一个由 0、1 和 2 组成的二维网格，其中：
+#
+# 0 代表你可以自由通过和选择建造的空地
+# 1 代表你无非通行的建筑物
+# 2 代表你无非通行的障碍物
+#  
+#
+# 示例：
+#
+# 输入: [[1,0,2,0,1],[0,0,0,0,0],[0,0,1,0,0]]
+#
+# 1 - 0 - 2 - 0 - 1
+# |   |   |   |   |
+# 0 - 0 - 0 - 0 - 0
+# |   |   |   |   |
+# 0 - 0 - 1 - 0 - 0
+#
+# 输出: 7
+#
+# 解析:
+# 给定三个建筑物 (0,0)、(0,4) 和 (2,2) 以及一个位于 (0,2) 的障碍物。
+# 由于总距离之和 3+3+1=7 最优，所以位置 (1,2) 是符合要求的最优地点，故返回7。
+
+import queue
+import sys
+
+
+class Solution:
+    def shortestDistance(self, grid: List[List[int]]) -> int:
+        r = len(grid)
+        c = len(grid[0])
+        count = [[0 for _ in range(c)] for _ in range(r)]
+        dist = [[0 for _ in range(c)] for _ in range(r)]
+        d = [[0, 1], [0, -1], [1, 0], [-1, 0]]
+        buildings = 0
+
+        # initial
+        for i in range(r):
+            for j in range(c):
+                if grid[i][j] == 1:
+                    buildings += 1
+                    qu = queue.Queue()
+                    visit = [[0 for _ in range(c)] for _ in range(r)]
+
+                    qu.put((i, j))
+                    visit[i][j] = 1
+                    step = 0
+                    while not qu.empty():
+                        sz = qu.qsize()
+                        step += 1
+
+                        for k in range(sz):
+                            curr = qu.get()
+                            for m in range(4):
+                                x = curr[0] + d[m][0]
+                                y = curr[1] + d[m][1]
+                                if x >= 0 and x < r and y >= 0 and y < c:
+                                    if visit[x][y] == 0 and grid[x][y] == 0:
+                                        visit[x][y] = 1
+                                        count[x][y] += 1
+                                        dist[x][y] += step
+                                        qu.put((x, y))
+
+        res = sys.maxsize
+        for i in range(0, r):
+            for j in range(0, c):
+                if grid[i][j] == 0 and count[i][j] == buildings:
+                    res = min(res, dist[i][j])
+
+        if res == sys.maxsize:
+            return -1
+        else:
+            return res
+
+
+

source/Clarification/Matrix/317.离建筑物最近的距离.py

@@ -0,0 +1,60 @@
+# 想象一下炸弹人游戏，在你面前有一个二维的网格来表示地图，网格中的格子分别被以下三种符号占据：
+#
+# 'W' 表示一堵墙
+# 'E' 表示一个敌人
+# '0'（数字 0）表示一个空位
+#
+#
+# 请你计算一个炸弹最多能炸多少敌人。
+#
+# 由于炸弹的威力不足以穿透墙体，炸弹只能炸到同一行和同一列没被墙体挡住的敌人。
+#
+# 注意：你只能把炸弹放在一个空的格子里
+#
+# 示例:
+#
+# 输入: [["0","E","0","0"],["E","0","W","E"],["0","E","0","0"]]
+# 输出: 3
+# 解释: 对于如下网格
+#
+# 0 E 0 0
+# E 0 W E
+# 0 E 0 0
+#
+# 假如在位置 (1,1) 放置炸弹的话，可以炸到 3 个敌人
+
+class Solution:
+    def maxKilledEnemies(self, grid: List[List[str]]) -> int:
+        if not grid: return 0
+        r = len(grid)
+        c = len(grid[0])
+
+        def cal(row,col):
+            res = 0
+            left,right = col - 1,col + 1
+            while left >= 0 and grid[row][left] != "W":
+                if grid[row][left] == 'E':
+                    res += 1
+                left -= 1
+            while right < c and grid[row][right] != 'W':
+                if grid[row][right] == 'E':
+                    res += 1
+                right += 1
+            up,down = row - 1,row + 1
+            while up >= 0 and grid[up][col] != 'W':
+                if grid[up][col] == 'E':
+                    res += 1
+                up -= 1
+            while down < r and grid[down][col] != 'W':
+                if grid[down][col] == 'E':
+                    res += 1
+                down += 1
+            return res
+        res = 0
+        for i in range(r):
+            for j in range(c):
+                if grid[i][j] == "0":
+                    res = max(res,cal(i,j))
+        return res
+
+