Leetcode第934题：最短的桥（Shortest Bridge）

解题思路

由于0代表水域，1代表陆地，我们要区分两个岛屿，所以，在遍历grid矩阵的时候，只要第一次发现了某个格子为1，则开始将发现的新大陆进行编号，即将1变为2。在此过程中，我们采用深度遍历的方式寻找整个岛，在深度遍历的过程中，如果我们发现了某个格子为0，则说明我们已经遍历到了岛屿的边缘部分，则将其也赋值为2，即将0变为2，与此同时，将这个“边缘的格子”放入到双向队列queue<int[]> edges中，edges中保存着int[]数组，队列中的每个数组长度都是2，即int[0]保存这个 “边缘的格子”的行，int[1]保存这个 “边缘的格子”的列。

遍历完整个岛屿之后，我们除了将其赋值为2之外，在队列edges中还保存了这个岛屿的所有“边缘格子”（深度遍历过程中保存到队列中的），那么下一步骤，我们·就需要开启while循环，即每次循环都根据edges中保存的这个岛屿的所有“边缘格子”对外进行一层的岛屿扩充操作。即从edges中出队列每个“边缘格子”，再分别从direction[][]定义的上/下/右/左，四个方向去查看相邻的格子，如果发现是0，则表明是新的一层边缘格子，将其赋值为2，并将其加入到队列edges中，用于下一次while循环。

在对外一层层的扩展岛屿操作过程中，只要发现有“边缘格子”的四周出现了1，则说明已经与另一个岛屿接壤了，直接返回扩展层数（遍历edges队列的次数）即可。

代码如下：

class Solution 
{
    void findIsland1(vector<vector<int>>& grid, queue<pair<int, int>>& edge)
    {
        for(int i = 0; i < grid.size(); ++i)
        {
            for(int j = 0; j < grid[0].size(); ++j)
            {
                if(grid[i][j] == 1)
                {
                    dfs(grid, i, j, edge);
                    return;
                }   
            }
        }
    }
 
    void dfs(vector<vector<int>>& grid, int i, int j, queue<pair<int, int>>& edge)
    {
        //超出范围
        if(!(i >= 0 && j >= 0 && i < grid.size() && j < grid[0].size()))
            return;
        //边缘海域，插入队列并置为2，防止重复访问
        if(grid[i][j] == 0)
        {
            edge.push(make_pair(i, j));
            grid[i][j] = 2;
            return;
        }
        else if(grid[i][j] == 2)
            return;
        //岛屿
        grid[i][j] = 2;
        dfs(grid, i+1, j, edge);
        dfs(grid, i-1, j, edge);
        dfs(grid, i, j+1, edge);
        dfs(grid, i, j-1, edge);
    }
 
public:
    int shortestBridge(vector<vector<int>>& grid) 
    {
        int ret = 0;
        vector<vector<int>> direction = {{1,0}, {-1,0}, {0,1}, {0,-1}};
        //先找到岛屿1的所有边缘海域的位置
        queue<pair<int, int>> edge;
        findIsland1(grid, edge);
        
        //逐层扩张边缘海域，直到遇到另一座岛屿
        while(!edge.empty())
        {
            ++ret;
            int n = edge.size();
            while(n--)
            {
                pair<int, int> coor = edge.front();
                edge.pop();
                int i, j;
                //向四个方向扩张
                for(int k = 0; k < 4; ++k)
                {
                    i = coor.first + direction[k][0];
                    j =  coor.second + direction[k][1];
                    //如果超出范围
                    if(!(i >= 0 && j >= 0 && i < grid.size() && j < grid[0].size()))
                        continue;
                    //岛内元素
                    else if(grid[i][j] == 2)
                        continue;
                    //边缘海域，插入队列并置为2
                    else if(grid[i][j] == 0)
                    {
                        edge.push(make_pair(i, j));
                        grid[i][j] = 2;
                    }
                    //遇到另一个岛屿
                    else if(grid[i][j] == 1)
                        return ret;
                }
            }
        }
        return 0;
    }
};