934. 最短的桥

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

输入：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

题目链接

返回翻转的0的最小数目使两座岛连接在一起。即求最小从一座岛到另一座岛的最小步数。与之前求点到点最短路径不同的是，岛屿可以从任意部分延伸。因此，可以先用DFS将岛屿标记出来，然后让岛屿的各个部分，延伸。碰到另一个岛，返回延伸的步数即可

class Solution {
public:
    //记录岛
    queue<pair<int,int>>island1;
    //标记处一个岛
    void dfs(int x,int y,vector<vector<int>>& grid){
        if(x<0||x>=grid.size()||y<0||y>=grid[0].size()||grid[x][y]!=1)
            return;
        island1.push({x,y});
        grid[x][y]=2;
        dfs(x+1,y,grid);
        dfs(x-1,y,grid);
        dfs(x,y+1,grid);
        dfs(x,y-1,grid);
    }

    int shortestBridge(vector<vector<int>>& grid) { 
        int step=0;
        for(int i=0;i<grid.size();i++){
            for(int j=0;j<grid[0].size();j++){
                //找到第一个岛屿
                if(grid[i][j]==1){
                    dfs(i,j,grid);
                   
                    int dx[4]={1,-1,0,0};
                    int dy[4]={0,0,1,-1};
                    while(!island1.empty()){
                        int size=island1.size();
                        for(int cnt=0;cnt<size;cnt++){
                            //对于岛的边界，向四周扩展
                            int nx=island1.front().first;
                            int ny=island1.front().second;
                            island1.pop();
                            for(int fd=0;fd<4;fd++){
                                int fx=nx+dx[fd];
                                int fy=ny+dy[fd];
                                if(fx>=0&&fx<grid.size()&&fy>=0&&fy<grid[0].size()){
                                    if(grid[fx][fy]==0){
                                        island1.push({fx,fy});
                                        grid[fx][fy]=2;
                                    }
                                    else if(grid[fx][fy]==1)
                                        return step;
                                }
                            }
                        }
                        step++;
                    }
                }
            }
        }
        return step;
    }
};