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

题目描述

2022/10/25 每日一题
难度：中等

给定一个大小为 n x n 的二元矩阵 grid ，其中 1 表示陆地，0 表示水域。 岛是由四面相连的 1 形成的一个最大组，即不会与非组内的任何其他 1 相连。grid中恰好存在两座岛。 可以将任意数量的0变为1 ，使两座岛连接起来，变成一座岛。返回使两座岛变成一座岛所必须翻转的0的最小数目。

输入：给定二维数组grid，其中只包含0，1
输出：使两座岛连通的翻转0为1的最小数目

算法思路

从题目中的“连接”可以想到这道题与图结构有关，优先尝试广度优先搜索或深度优先搜索。其次，题目中明确图中只有两座互不连通的岛，则只需从一岛出发连到另一岛则可结束搜索，并返回搜索所需的最短距离。

步骤

1. 广度优先搜索第一个连通图为第一座岛
2. 对第一座岛周围进行一圈圈的扩建，若扩建后的岛能与另一岛相连，则此时扩建的圈数即为连通所需最小距离。

数据结构

• 队列queue用于执行广度优先搜索，广度优先搜索时queue中的元素会变动，因此还需要一个island存储岛的元素
• 列表island用于存储第一个岛中的所有元素，使用List数据结构便于后续将island中的元素遍历复制到队列中
• dirs用于遍历某一元素的上下左右元素，第一列表示对x坐标的操作，第二列表示对y坐标的操作；即对x操作同时不能改变y，反之亦然
• grid中的元素等于-1表示此点已被遍历过
• step记录扩建的圈数

实现细节

1. 寻找第一个岛

• 寻找第一个岛：若元素=1表示为岛的组成部分之一
• 对已遍历到的元素执行广度优先搜索：将队列中的第一个元素出队，并将其相邻元素中为1的元素添加到队列中
• 广度优先搜索的同时将岛的组成元素记录到island中：与queue的区别在于，island的作用仅为记录第一个岛的所有元素，只添加元素而不删除
• 在入队时添加island等同于在出队时添加，因为广度遍历时queue中的每个必然都会先入队再出队
• 队列第一次为空时表示第一个岛的遍历已完成，将island中的岛复制到队列中，便于后续对岛进行扩展

2. 对第一个岛扩建

• 将island中的每个元素的四周均变为-1，表示将岛进行一圈的扩展
• 因为在扩建时会将新扩建的元素也加入到队列中，若不加限制条件会无法区分当前遍历的队列元素是上一圈的还是新扩建的
• sz表示扩建前队列中元素数量，限定每次只对前一圈周围扩建，当s = sz时表示前一圈已遍历完，queue中的其他元素都是新扩建的一圈元素
• 若岛周围的元素是0，则对其扩建，将其直接置为-1，表示先扩建且已遍历
• 若碰到岛周围的元素为1，则表示两岛已能联通，并且是最短距离
• 第一圈是对原始岛周围遍历，由题意可知，此时所有的grid[nx][ny]都一定 = 0，所以step初始时为0
• 一圈遍历完还未碰到另一岛，则扩建圈+1，继续寻找另一岛

3. 程序出口 语法编译规定必须有的返回值，所以在对grid循环完成后return 0，但由题意可知，程序一定不会从此出口出去

代码实现

public int shortestBridge(int[][] grid) {
    Queue<int[]> queue = new ArrayDeque<>();
    List<int[]> island = new ArrayList<>();
    int[][] dirs = new int[][]{{-1, 0}, {1, 0}, {0, 1}, {0, -1}}; 
    int n = grid.length;

    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            if(grid[i][j] == 1){
                queue.offer(new int[]{i, j});
                grid[i][j] = -1;

                while(!queue.isEmpty()){
                    int[] cell = queue.poll();
                    island.add(cell);
                    int x = cell[0], y = cell[1];
                    for(int k = 0; k < 4; k++){
                        int nx = x + dirs[k][0];
                        int ny = y + dirs[k][1];
                        if(nx >= 0 && nx < n && ny >= 0 && ny < n && grid[nx][ny] == 1){
                            queue.offer(new int[]{nx, ny});
                            grid[nx][ny] = -1;
                        }
                    }
                }

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

                int step = 0;
                while(!queue.isEmpty()){
                    int sz = queue.size();
                    for(int s = 0; s < sz; s++){
                        int[] cell = queue.poll();
                        int x = cell[0], y = cell[1];
                        for(int k = 0; k < 4; k++){
                            int nx = x + dirs[k][0];
                            int ny = y + dirs[k][1];
                            if(nx >= 0 && nx < n && ny >= 0 && 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;
}