目录

BFS

走迷宫

---

BFS

算法特点

• 优先考虑宽度，换句话说就是按层推进，直到最后一层。

• 空间复杂度：O（2^h）

• BFS是按宽度搜索，所以可以找到最短路，适用于解决像最短路，最少之类的问题

按照广度来搜索。具体表现就是以距离作为扩展的准则，从距离为一的点开始找距离起点距离都为一的点，之后距离为三的点，以此类推，直到搜到终点，这种方式本身就有最短路径的特点。

板子

bfs算法的思想：根据边长遍历距离自己最近的点，依次放入队列，队列的元素从左往右一定是距离根节点最近的点。


int bfs()
{
	queue<> q;
	q.push({0,0})
	d[0][0]=0
	while(q.size())
	{
		for(迭代与q节点连接的所有边)
			d 记录距离
			按照距离大小从小到大放入q队列中
			可能存在边界问题
	}
	return d[n-1][m-1];//最后一个点的距离就是最短路。
}

走迷宫

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

typedef pair<int, int> PII;

const int N = 110;

int n, m;
int g[N][N], d[N][N];//g[N][N]用来存迷宫,d[N][N]用来存移动次数

int bfs()
{
    queue<PII> q;

    memset(d, -1, sizeof d);
    d[0][0] = 0;
    q.push({ 0, 0 });//这是起始点，也就可以理解为第0层

    int dx[4] = { -1, 0, 1, 0 }, dy[4] = { 0, 1, 0, -1 };//每个点有四种走向，上下左右。

    while (q.size())//只要不为0，就一直循环
    {
        //while在广搜作用是对这一层的每个节点进行遍历

        auto t = q.front();//取队头元素
        q.pop();//干掉对头元素

        for (int i = 0; i < 4; i++)//作用是在每个节点的基础上搜索下一层的节点，最终放入队列，形成新的一层
        {
            int x = t.first + dx[i], y = t.second + dy[i];//这是从每一节点开始的第一层广搜

            if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)//判断范围，筛选一下
            {
                d[x][y] = d[t.first][t.second] + 1;//记录当前搜到的节点与起点的距离也就是走了几步
                q.push({ x, y });//把所有第一层的点放在队列，利用while循环进行在此基础上的广搜
                //队列的作用就是记录上一层广搜到的点，然后利用这些节点进行下一步的搜索，是借助循环来实现
            }
        }
    }
    //当搜到唯一点时，放在队列里，再一次进入循环，在这一点的基础上继续搜索，知道按照广度遍历完所有的点
    return d[n - 1][m - 1];//最后遍历玩迷宫所有点时，直接输出迷宫终点存的值即可。
}

int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            cin >> g[i][j];

    cout << bfs() << endl;

    return 0;
}

距离为1，每次更新到的点都是最短路径，不需要考虑一个点的最小距离多次更新的情况。