持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第24天，点击查看活动详情

题目详情

LeetCode题库序号 934. 最短的桥 ，难度为中等。

Tag : 「深度优先搜索」

给你一个大小为 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 中恰有两个岛

深度优先搜索

题解思路：

这道题目使用深度优先搜索的方式，题目中有两座岛，由1组成，那么我们可以先找到其中的一个岛，将它的位置全部进行标记为-1，然后从岛的每个位置出发进行寻找，每寻找一圈，步骤就会累加，最后碰到1位置后，表明已经找到该岛，并且位置是最短的。题目解法详情见以下代码：

题解代码

class Solution {
    public int shortestBridge(int[][] grid) {

        int n = grid.length;
        int[] dx = new int[]{0, 1, 0, -1};
        int[] dy = new int[]{1, 0 , -1, 0};
        List<int[]> island = new ArrayList<int[]>();
        Queue<int[]> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    grid[i][j] = -1;
                    queue.offer(new int[]{i, j});

                    while (!queue.isEmpty()) {
                        int[] pos = queue.poll();
                        island.add(pos);

                        for (int x = 0; x < 4; x++) {
                            int nx = pos[0] + dx[x];
                            int ny = pos[1] + dy[x];

                            if (nx >= 0 && ny >= 0 && nx < n && ny < n && grid[nx][ny] == 1) {
                                grid[nx][ny] = -1;
                                queue.offer(new int[]{nx, ny});
                            }
                        }
                    }

                    for (int[] arr : island) {
                        queue.offer(arr);
                    }

                    int step = 0;
                    while (!queue.isEmpty()) {
                        int len = queue.size();
                        for (int k = 0; k < len; k++) {
                            int[] pos = queue.poll();
                            for (int x = 0; x < 4; x++) {
                                int nx = pos[0] + dx[x];
                                int ny = pos[1] + dy[x];
                                if (nx >= 0 && ny >= 0 && nx < n && ny < n) {
                                    if (grid[nx][ny] == 0) {
                                        grid[nx][ny] = -1;
                                        queue.offer(new int[]{nx, ny});
                                    } else if (grid[nx][ny] == 1) {
                                        return step;
                                    }
                                }
                                
                            }
                        }
                        step++;
                    }
                }
            }
        }

        return 0;
    }
}

结尾

我的"刷完LeetCode题库"系列文章的第 No.934. 最短的桥 序号的题目，本次刷题之旅系列开始于 2022-06-12，因为LeetCode上部分是有锁题，我自己的目标是将先把所有不带锁的题目刷完。自己能够通过这次刷题之旅勉励自己，并且提升逻辑思维能力。这个系列的文章就是会见证我自己的一个成长过程！

思路虽然不是最优的，但是我会尽我所能！

为了让我自己的刷题之旅不中断，我特地建立了相关的仓库，来记录我自己的刷题之旅。 github.com/jackpan123/… 。

刷完LeetCode题库——934. 最短的桥

题目详情

深度优先搜索

结尾