leetcode-934.最短的桥

深度优先搜索(dfs)

广度优先搜索(bfs)

---

题目详情

在给定的二维二进制数组 A 中，存在两座岛。（岛是由四面相连的 1 形成的一个最大组。）
现在，我们可以将 0 变为 1，以使两座岛连接起来，变成一座岛。
返回必须翻转的 0 的最小数目。（可以保证答案至少是 1 。）

---

题意理解:示例一:

填了这个海0就能让两个岛屿1相连
示例二:

填了这两个海0就能让两个岛屿1相连
示例三:

这个示例三是一圈1,一圈1就是一个岛屿,中间独立的1又是另一个,只需填补一个0

示例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

我的代码：

思路:

先通过任意搜索方法找到其中一个岛屿
然后利用广度优先搜索，查找其与另一个岛屿的最短距离。

class Solution 
{
public:
    vector<int> direction{-1, 0, 1, 0, -1}; //bfs上下左右移动用

    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)  //越界 或 [i,j]处是搜索过的陆地
    {
        return;
    }
    if (grid[i][j] == 0)        //[i,j]处是海洋
    {
        points.push({i, j});    //将海洋点计入队列
        return;
    }

    grid[i][j] = 2;            //如果没越界 不是海洋 没搜过的陆地,则将此处陆地标记搜索过,通过将1置为2
    //dfs递归继续执行
    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);  //右
    

    }
    
    int shortestBridge(vector<vector<int>>& grid) 
    {
        int m = grid.size(), n = grid[0].size();
        queue<pair<int, int>> points;
        //dfs寻找第一个岛屿,标记就是将这块岛屿置为2
        bool flipped = false;       //用flipped作为跳出递归条件
        //遍历
        for (int i = 0; i < m; ++i)
        {
            if (flipped) break;      //如果找到一整块岛屿了,跳出外层for
            for(int j = 0; j < n; ++j)
            {
                if (grid[i][j] == 1)    //如果[i,j]是陆地,则将其作为起点进行dfs寻找其他相邻'1'块以和其构成同一块岛屿
                {
                    //这个区块只有找到起点后才会开始dfs
                    //直到递归完毕通过flipped一层层break递归回来,就搜索完毕一个岛屿
                    dfs(points, grid, m, n, i, j);
                    flipped = true;
                    break;
                }
            }
        }

        //bfs寻找第二个岛屿,并把寻找过程中的0置为2,即填海
        int x, y;
        int level = 0; //填海数量
        //因为points记录了所有海,而且是queue,肯定是从离第一块陆地最近的海洋开始搜索的(bfs)
        while (!points.empty()) 
        {
            ++level;    //填一块海
            int n_points = points.size();   
            while (n_points--)              
            {
                auto [r, c] = points.front();   //以最近这一块海作为起点开始搜索第二块岛屿(此处的起点一定是最短路径的一个点)
                points.pop();                   //将起点(利用完)出列
                //从起点[r,c]四面八方搜索
                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});                //否则就还是海洋'0',再将这块海洋push进列,等会儿以它为起始点继续扩张
                        grid[x][y] = 2;                     //将这块利用完毕的起始点置为2 防止等会新起点再扩张搜索到它
                    }
                }
            }
        }
        return 0;
    }
};

涉及知识点:

1.深度优先搜索(dfs)

深度优先搜索（depth-first seach，DFS）在搜索到一个新的节点时，立即对该新节点进行遍历；因此遍历需要用先入后出的栈来实现，也可以通过与栈等价的递归来实现。对于树结构而言，由于总是对新节点调用遍历，因此看起来是向着“深”的方向前进。

2.广度优先搜索(bfs)

广度优先搜索（breadth-first search，BFS）不同与深度优先搜索，它是一层层进行遍历的，因此需要用先入先出的队列而非先入后出的栈进行遍历。由于是按层次进行遍历，广度优先搜索时按照“广”的方向进行遍历的，也常常用来处理最短路径等问题。