LeetCode #1162 地图分析 多源BFS 动态规划

LeetCode #1162 地图分析

题目描述

你现在手里有一份大小为 N x N 的『地图』（网格） grid，上面的每个『区域』（单元格）都用 0 和 1 标记好了。其中 0 代表海洋，1 代表陆地，你知道距离陆地区域最远的海洋区域是是哪一个吗？请返回该海洋区域到离它最近的陆地区域的距离。

我们这里说的距离是『曼哈顿距离』（ Manhattan Distance）：(x0, y0) 和 (x1, y1) 这两个区域之间的距离是 |x0 - x1| + |y0 - y1| 。

如果我们的地图上只有陆地或者海洋，请返回 -1。

示例 1：

输入：[[1,0,1],[0,0,0],[1,0,1]]
输出：2
解释： 
海洋区域 (1, 1) 和所有陆地区域之间的距离都达到最大，最大距离为 2。

示例 2：

输入：[[1,0,0],[0,0,0],[0,0,0]]
输出：4
解释： 
海洋区域 (2, 2) 和所有陆地区域之间的距离都达到最大，最大距离为 4。

提示：

1 <= grid.length == grid[0].length <= 100
grid[i][j] 不是 0 就是 1

方法一：多源BFS

题目有点绕，实际上相当于海岸线有多远吧，不太好理解。一看到这道题就想到是对每一个陆地或每个海洋做 BFS，但是这样会导致时间复杂度太大了，在题解中学习到 多源BFS 的结果其实和单源是一样的，因为相当于用一个超级源点把你的第 1 层源点连接起来，这样第 1 层源点就相当于是第 2 层了

图片来自@前额叶没长好，侵删

class Solution:
    def maxDistance(self, grid: List[List[int]]) -> int:
        N = len(grid)

        queue = []
        # 遍历gird，取出所有陆地格子
        for i in range(N):
            for j in range(N):
                if grid[i][j]:
                    queue.append((i,j))
        
        # 如果全是海洋或全是陆地返回-1
        if len(queue) == 0 or len(queue) == N * N:
            return -1
        
        distance = -1
        while queue:
            distance += 1
            # 一口气取出n个节点，实现层次遍历
            n = len(queue)
            for i in range(n):
                x, y = queue.pop(0)
                # 上下左右判断，如果遇到了海洋将其改成2表示已经遍历过，并加入队列继续遍历
                # 判断上面：
                if(y-1 >= 0 and not grid[x][y-1]):
                    grid[x][y-1] = 2
                    queue.append((x, y-1))
                # 判断下面:
                if(y+1 < N and not grid[x][y+1]):
                    grid[x][y+1] = 2
                    queue.append((x, y+1))
                # 判断左边:
                if(x-1 >= 0 and not grid[x-1][y]):
                    grid[x-1][y] = 2
                    queue.append((x-1, y))
                # 判断右边:
                if(x+1 < N and not grid[x+1][y]):
                    grid[x+1][y] = 2
                    queue.append((x+1, y))
        
        return distance

• 时间复杂度： $O(N^2)$
• 空间复杂度： $O(N^2)$

方法二：动态规划

来自官方解法：对于每个海洋格子，离它最近的陆地要么从左上方来，要么从右上方来，可以做两次动态规划，第一次从左上，第二次从右下，每次要比较左上和右下哪个距离更近，那么初始化时将陆地离陆地的距离置为 0，海洋置为 inf，比较自己与相邻格子的数值大小，取最小值，因为最近的点可能来自左上方，也可能来自右下方，第二次遍历需要用到第一次的结果，不能单纯分别记录两次的 DP 取最大值 ，这样最后的出来的矩阵就为最近距离矩阵，取出最大的即可。（画图理解，不画图我真的看不懂）

class Solution:
    def maxDistance(self, grid: List[List[int]]) -> int:
        N = len(grid)

        inf = float('inf')

        for i in range(N):
            for j in range(N):
                if grid[i][j]:
                    grid[i][j] = 0
                else:
                    grid[i][j] = inf
        
        # 第一次遍历，从左上角开始
        for i in range(N):
            for j in range(N):
                # 自己就是陆地，跳过
                if not grid[i][j]: continue
                if i > 0:
                    grid[i][j] = min(grid[i][j], grid[i-1][j] + 1)   # 别忘了相邻格+1
                if j > 0:
                    grid[i][j] = min(grid[i][j], grid[i][j-1] + 1)
        
        # 第二次遍历，从右下角开始
        for i in range(N-1, -1, -1):
            for j in range(N-1, -1, -1):
                # 自己就是陆地，跳过
                if not grid[i][j]: continue
                if i < N-1:
                    grid[i][j] = min(grid[i][j], grid[i+1][j] + 1)   # 别忘了相邻格+1
                if j < N-1:
                    grid[i][j] = min(grid[i][j], grid[i][j+1] + 1)

        ans = -1
        for i in range(N):
            for j in range(N):
                ans = max(ans, grid[i][j])

        # ans为0代表全是陆地，ans为inf代表全是海洋
        return -1 if ans == 0 or ans == inf else ans

• 时间复杂度： $O(N^2)$
• 空间复杂度： $O(N^2)$