6.4Shortest Bridge -- 广度优先搜索
广度优先搜索概念了解
广度优先搜索跟深度优先搜索是不同的。区别在于遍历方向。是一层层遍历的。因此需要用先入先出的队列，而非先入后出的栈进行遍历。由于是按照层次进行遍历，广度优先搜索是按照广的思路进行遍历的，也经常被用于找最短路径。
1
/ \
2 3
/
4
还是先来看这个简单的树，从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
#include
#include
using namespace std;
vector direction{ -1,0,1,0,-1 };
void dfs(queue>& points, vector>& 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>& grid) {
int m = grid.size(), n = grid[0].size();
queue> 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> 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;
}
```