【LeetCode】934. 最短的桥

题目

934. 最短的桥

给你一个大小为 n x n 的二元矩阵 grid ，其中 1 表示陆地，0 表示水域。

岛 是由四面相连的 1 形成的一个最大组，即不会与非组内的任何其他 1 相连。grid 中 恰好存在两座岛 。

你可以将任意数量的 0 变为 1 ，以使两座岛连接起来，变成 一座岛 。

返回必须翻转的 0 的最小数目。

示例 1：

输入：grid = [[0,1],[1,0]]
输出：1

示例 2：

输入：grid = [[0,1,0],[0,0,0],[0,0,1]]
输出：2

示例 3：

输入：grid = [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]
输出：1

提示：

• n == grid.length == grid[i].length
• 2 <= n <= 100
• grid[i][j] 为 0 或 1
• grid 中恰有两个岛

思路

• 遍历整个矩阵，计算陆地的数量，并选取一个陆地作为起始点
• 从起始点开始广度优先搜索，优先搜索周围的路径，当所有的地点都被搜索过之后，返回距离

代码

class Solution:
    def shortestBridge(self, grid: List[List[int]]) -> int:
        count = 0
        start = (-1,-1)
        visited = [[False] * len(grid) for _ in range(len(grid))]
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j] == 1:
                    count += 1
                    start = (i,j)
        queue = []
        heapq.heappush(queue, (0, start[0], start[1]))
        visited[start[0]][start[1]] = True
        ret = 0
        while count > 0 and queue:
            d, r, c = heapq.heappop(queue)
            if grid[r][c] == 1: count -= 1
            if count <= 0: return ret
            ret = max(ret, d)
            for dr,dc in ((-1,0),(0,-1),(0,1),(1,0)):
                newR,newC = r+dr, c+dc
                if 0<=newR<len(grid) and 0<=newC<len(grid) and not visited[newR][newC]:
                    if grid[newR][newC] == 1:
                        heapq.heappush(queue, (d, newR, newC))
                    else:
                        heapq.heappush(queue, (d+1, newR, newC))
                    visited[newR][newC] = True
        return ret

复杂度

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