feat: add solutions to lc problem: No.0317

No.0317.Shortest Distance from All Buildings

Author: yanglbme

solution/0300-0399/0317.Shortest Distance from All Buildings/README.md

@@ -51,22 +51,217 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+BFS。
+
+记 total 变量表示建筑物（`grid[i][j] = 1`）的个数，`cnt[i][j]` 表示空地 `(i, j)` 上能到达的建筑物数量；`dist[i][j]` 表示空地 `(i, j)` 到每个建筑物的距离之和。求解的是满足 `cnt[i][j] == total` 的空地距离和的最小值。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def shortestDistance(self, grid: List[List[int]]) -> int:
+        m, n = len(grid), len(grid[0])
+        q = deque()
+        total = 0
+        cnt = [[0] * n for _ in range(m)]
+        dist = [[0] * n for _ in range(m)]
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == 1:
+                    total += 1
+                    q.append((i, j))
+                    d = 0
+                    vis = set()
+                    while q:
+                        d += 1
+                        for _ in range(len(q), 0, -1):
+                            r, c = q.popleft()
+                            for a, b in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
+                                x, y = r + a, c + b
+                                if 0 <= x < m and 0 <= y < n and grid[x][y] == 0 and (x, y) not in vis:
+                                    cnt[x][y] += 1
+                                    dist[x][y] += d
+                                    q.append((x, y))
+                                    vis.add((x, y))
+        ans = float('inf')
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == 0 and cnt[i][j] == total:
+                    ans = min(ans, dist[i][j])
+        return -1 if ans == float('inf') else ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int shortestDistance(int[][] grid) {
+        int m = grid.length;
+        int n = grid[0].length;
+        Deque<int[]> q = new LinkedList<>();
+        int total = 0;
+        int[][] cnt = new int[m][n];
+        int[][] dist = new int[m][n];
+        int[] dirs = {-1, 0, 1, 0, -1};
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 1) {
+                    ++total;
+                    q.offer(new int[]{i, j});
+                    int d = 0;
+                    boolean[][] vis = new boolean[m][n];
+                    while (!q.isEmpty()) {
+                        ++d;
+                        for (int k = q.size(); k > 0; --k) {
+                            int[] p = q.poll();
+                            for (int l = 0; l < 4; ++l) {
+                                int x = p[0] + dirs[l];
+                                int y = p[1] + dirs[l + 1];
+                                if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 0 && !vis[x][y]) {
+                                    ++cnt[x][y];
+                                    dist[x][y] += d;
+                                    q.offer(new int[]{x, y});
+                                    vis[x][y] = true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        int ans = Integer.MAX_VALUE;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 0 && cnt[i][j] == total) {
+                    ans = Math.min(ans, dist[i][j]);
+                }
+            }
+        }
+        return ans == Integer.MAX_VALUE ? -1 : ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int shortestDistance(vector<vector<int>>& grid) {
+        int m = grid.size();
+        int n = grid[0].size();
+        typedef pair<int, int> pii;
+        queue<pii> q;
+        int total = 0;
+        vector<vector<int>> cnt(m, vector<int>(n));
+        vector<vector<int>> dist(m, vector<int>(n));
+        vector<int> dirs = {-1, 0, 1, 0, -1};
+        for (int i = 0; i < m; ++i)
+        {
+            for (int j = 0; j < n; ++j)
+            {
+                if (grid[i][j] == 1)
+                {
+                    ++total;
+                    q.push({i, j});
+                    vector<vector<bool>> vis(m, vector<bool>(n));
+                    int d = 0;
+                    while (!q.empty())
+                    {
+                        ++d;
+                        for (int k = q.size(); k > 0; --k)
+                        {
+                            auto p = q.front();
+                            q.pop();
+                            for (int l = 0; l < 4; ++l)
+                            {
+                                int x = p.first + dirs[l];
+                                int y = p.second + dirs[l + 1];
+                                if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 0 && !vis[x][y])
+                                {
+                                    ++cnt[x][y];
+                                    dist[x][y] += d;
+                                    q.push({x, y});
+                                    vis[x][y] = true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        int ans = INT_MAX;
+        for (int i = 0; i < m; ++i)
+            for (int j = 0; j < n; ++j)
+                if (grid[i][j] == 0 && cnt[i][j] == total)
+                    ans = min(ans, dist[i][j]);
+        return ans == INT_MAX ? -1 : ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func shortestDistance(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	var q [][]int
+	total := 0
+	cnt := make([][]int, m)
+	dist := make([][]int, m)
+	for i := range cnt {
+		cnt[i] = make([]int, n)
+		dist[i] = make([]int, n)
+	}
+	dirs := []int{-1, 0, 1, 0, -1}
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] == 1 {
+				total++
+				q = append(q, []int{i, j})
+				vis := make([]bool, m*n)
+				d := 0
+				for len(q) > 0 {
+					d++
+					for k := len(q); k > 0; k-- {
+						p := q[0]
+						q = q[1:]
+						for l := 0; l < 4; l++ {
+							x, y := p[0]+dirs[l], p[1]+dirs[l+1]
+							if x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 0 && !vis[x*n+y] {
+								cnt[x][y]++
+								dist[x][y] += d
+								q = append(q, []int{x, y})
+								vis[x*n+y] = true
+							}
+						}
+					}
+				}
+			}
+		}
+	}
 
+	ans := math.MaxInt32
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] == 0 && cnt[i][j] == total {
+				if ans > dist[i][j] {
+					ans = dist[i][j]
+				}
+			}
+		}
+	}
+	if ans == math.MaxInt32 {
+		return -1
+	}
+	return ans
+}
 ```
 
 ### **...**