leetcode934 最短的桥

在给定的二维二进制数组 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

思路：
本题使用广度优先搜索，为了找到最优解不先搜索到底，而是同步进行搜索，最先找到目标的解即为答案。广度优先搜索更适合数据结构而不是递归，所用的数据结构也不是栈而是队列。不过在那之前先要对第一个岛屿进行标记，这里可以使用递归搜索。

代码：

class Solution {
public:
    int shortestBridge(vector<vector<int>>& grid) {
        vector<int> direction{-1, 0, 1, 0, -1};
int m = grid.size(), n = grid[0].size();
queue<pair<int, int>> points;
bool flipped = false;
for (int i = 0; i < m; ++i) 
{
if (flipped) break;
for (int j = 0; j < n; ++j) 
{
if (grid[i][j] == 1) 
{
dfs(points, grid, m, n, i, j);
flipped = true;
break; 
} 
} 
}
int x, y;
int level = 0;
while (!points.empty())
{
++level;
int n_points = points.size();
while (n_points--) 
{
auto [r, c] = points.front();
points.pop();
for (int k = 0; k < 4; ++k) 
{
x = r + direction[k], y = c + direction[k+1];
if (x >= 0 && y >= 0 && x < m && y < n) 
{
if (grid[x][y] == 2) 
{
continue; 
}
if (grid[x][y] == 1) 
{
return level;
}
points.push({x, y});
grid[x][y] = 2;
} 
} 
} 
}
return 0;
    }

    void dfs(queue<pair<int, int>>& points, vector<vector<int>>& grid, int m, int n , int i,int j) 
    {
if (i < 0 || j < 0 || i == m || j == n || grid[i][j] == 2) 
{
return; 
}
if (grid[i][j] == 0) 
{
points.push({i, j});
return; 
}
grid[i][j] = 2;
dfs(points, grid, m, n, i - 1, j);
dfs(points, grid, m, n, i + 1, j);
dfs(points, grid, m, n, i, j - 1);
dfs(points, grid, m, n, i, j + 1);
}
};