Shortest Bridge -- 广度优先搜索 --力扣101算法题解笔记

6.4Shortest Bridge -- 广度优先搜索

广度优先搜索概念了解

广度优先搜索跟深度优先搜索是不同的。区别在于遍历方向。是一层层遍历的。因此需要用先入先出的队列，而非先入后出的栈进行遍历。由于是按照层次进行遍历，广度优先搜索是按照广的思路进行遍历的，也经常被用于找最短路径。

/ \

2 3

还是先来看这个简单的树，从1号节点开始遍历，假如遍历顺序是从左子节点到右子节点，那么按照优先向着"广"的方向前进的策略，队列顶端的元素变化过程为 $1$ -> $2-\>3$ -> $4$ ，其中方括号代表每一层的元素。

当然，跟深度优先搜索一样，都可以用来处理"是否可达"的问题，即从一个节点开始，是否能顺利到达另一个节点，因为深度优先搜索可以用递归来简单实现，但是在实际工程需要的时候是基本没有递归写法，基本都是用栈来写，或者是用队列。当然这两种差异也不是很大，工程要看具体需要来写。

题目描述

给定一个二维0-1矩阵，其中1表示陆地，0表示海洋。每个位置与上下左右相连。已知矩阵中有且只有两个岛屿，求最少要填海造毒多少个位置才可以将两个岛屿相连

输入输出样例

Input ：

【 $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$ 】

Output：1

题解

这道题的解决思路就是，求两个岛屿之间最短的距离，因此我们可以先通过任意搜索方法，找到其中一个岛屿，然后用广度优先搜索，查找其与另一个岛屿的最短距离就行。

为了方向统一且正确，定义了一个方向数组来实现对方向的判断。

cpp 复制代码

#include <vector>
#include <iostream>
#include <queue>
using namespace std;

vector<int> direction{ -1,0,1,0,-1 };

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);
}

int shortestBridge(vector<vector<int>>& grid) {
    int m = grid.size(), n = grid[0].size();
    queue<pair<int, int>> points;
    //dfs寻找第一个岛屿，然后把1全赋值成2
    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;
            }
        }
    }
    //bfs寻找第二个岛屿，并把过程中经过的0赋值为2
    int x, y;
    int level = 0;
    while (!points.empty()) {
        ++level;
        int n_points = points.size();
        while (n_points--) {
            int r = points.front().first;
            int c = points.front().second;
            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;
                }
            }
        }
    }
}

int main() {
    vector<vector<int>> 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}};
    cout << shortestBridge(grid) << endl;
    return 0;
}