每日一题——最短的桥

给你一个大小为 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

提示：

n == grid.length == grid[i].length
2 <= n <= 100
grid[i][j] 为 0 或 1
grid 中恰有两个岛

思路：

BFS常用来处理最短路径问题，或可达性问题所以会想到运用BFS。

因为只存在两片岛屿：

1. 可以先找到其中一片岛屿，找到之后就直接跳出找第一个岛屿的循环过程，运用DFS把它标识为2，与另一片岛屿进行区分，也防止重复遍历。
2. DFS的过程：从找到的第一个岛屿开始，往四个方向找，如果值为1，则继续执行DFS；如果值为0，则代表海洋，加入队列；如果值为2，则代表是已经遍历过的岛屿，跳过。主要是收集这个点周围的0（海洋）。
3. BFS搜索队列，逐层往外填充，直到遇到第二片岛屿，统计所需最小的次数

class Solution {
private:
    queue<pair<int, int>> points;
    vector<int> direction = {-1, 0, 1, 0, -1};
    void dfs(vector<vector<int>>& grid, int i, int j) {
        grid[i][j] = 2;
        for (int k = 0; k < 4; k++) {
            int x = i + direction[k];
            int y = j + direction[k + 1];
            if (x >= 0 && x < grid.size() && y >= 0 && y < grid[0].size()) {
                if (grid[x][y] == 2) continue;
                if (grid[x][y] == 1) dfs(grid, x, y);
                // 收集这个岛屿附近的0
                if (grid[x][y] == 0) points.push({x, y});
            }
        }
    }
public:
    int shortestBridge(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        // 找到第一个岛屿
        bool isFind = false;
        for (int i = 0; i < m; i++) {
            if (isFind) break;
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    // 调用dfs把这个岛屿都标志为2
                    dfs(grid, i, j);
                    isFind = true;
                    break;
                }
            }
        }
        // 找另一个岛屿 BFS
        int res = 0;
        while (!points.empty()) {
            int size = points.size();
            res++;
            while (size--) {
                auto [x, y] = points.front();
                points.pop();
                // 把这一层的0全部填为2，再把外层的0再加入队列，逐层填陆地，直到碰到第二片岛屿
                for (int k = 0; k < 4; k++) {
                    int p = x + direction[k];
                    int q = y + direction[k + 1];
                    if (p >= 0 && p < m && q >= 0 && q < n) {
                        if (grid[p][q] == 1) return res;
                        if (grid[p][q] == 2) continue;
                        points.push({p, q});
                        grid[p][q] = 2;
                    }
                }
            }
        }
        return res;
    }
};