0BFS/DFS中等 LeetCode934. 最短的桥

934. 最短的桥

描述

在给定的二维二进制数组 A 中，存在两座岛。（岛是由四面相连的 1 形成的一个最大组。）

现在，我们可以将 0 变为 1，以使两座岛连接起来，变成一座岛。

返回必须翻转的 0 的最小数目。（可以保证答案至少是 1 。）

示例 1：

输入：A = [[0,1],[1,0]]
输出：1
示例 2：

输入：A = [[0,1,0],[0,0,0],[0,0,1]]
输出：2
示例 3：

输入：A = [[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
 

提示：

2 <= A.length == A[0].length <= 100
A[i][j] == 0 或 A[i][j] == 1

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/shortest-bridge
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

把一个岛屿的全部节点加入到队列里，BFS向外拓展，直到遇到另一个岛屿，记录走了多长的距离。

class Solution {
    public int shortestBridge(int[][] grid) {
        Queue<int[]> queue = new LinkedList<>();
        int ans = 1;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 1) {
                    dfs(grid,i,j,queue);
                    return bfs(grid,queue);
                }
            }
        }
        return ans;
    }

    public void dfs(int[][] grid, int i, int j, Queue<int[]> queue) {
        if (i < 0 || j < 0 || i == grid.length || j == grid[0].length || grid[i][j] != 1) {
            return;
        }
        queue.offer(new int[]{i,j});
        grid[i][j] = -1;
        dfs(grid,i-1,j,queue);
        dfs(grid,i+1,j,queue);
        dfs(grid,i,j-1,queue);
        dfs(grid,i,j+1,queue);
    }

    public int bfs(int[][] grid,Queue<int[]> queue) {
        int[][] dir = new int[][]{{0,1},{1,0},{-1,0},{0,-1}};
        int ans = -1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            ans++;
            for (int k = 0; k < size; k++) {
                int[] arr = queue.poll();
                for (int[] di : dir) {
                    int ni = arr[0] + di[0];
                    int nj = arr[1] + di[1];
                    if (ni < 0 || nj < 0 || ni == grid.length || nj == grid[0].length || grid[ni][nj] == -1) {
            continue;
        }
                    if (grid[ni][nj] == 1) {
                        return ans;
                    } else {
                        grid[ni][nj] = -1;
                        queue.offer(new int[]{ni,nj});
                    }
                }
            }
        }
        return ans;
    }
}