BFS求迷宫最短路径(每步为一，无权值)

BFS(广度优先算法)求迷宫最短路径，

可以联想《三体》中ETO为了杀死罗辑的“基因导弹”。

类似“感染”，上下左右的“感染”，“感染”了后再“感染”这个“感染体”的上下左右，直至找到“目标”，或找遍整个数组找不到目标就返回未找到。

此视频很清晰的展示：https://www.bilibili.com/video/BV1Aq4y1B7qH?spm_id_from=333.337.search-card.all.click

附上代码，输入迷宫由0，1组成，可自设：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 105;
int n, m;        //n行m列，全局是为了在DFS函数中防止越界的比较 
const int stepArr[4][2] = {0, 1, -1, 0,
                    　　　　1, 0, 0, -1};    //“感染”右下左上 
int visit[maxn][maxn];//标记是否被访问过的数组，访问后不再访问 
int mazeArr[maxn][maxn];    //迷宫数组 
struct Node{    //定义节点类型 
    int x, y, step;    //x, y当前位置，step计算步数 
    Node(int x1, int y1, int step1):x(x1),y(y1),step(step1){} 
                //传参 
}; 
int BFS(int x_, int y_){//x_, y_为“目标”，即mazeARR[x][y] 
    Node node(0, 0, 0);//从左上角开始，起始为0步，若需要可自设 
    queue<Node> q;    //定义一个队列，特点是“先进先出” 
    while(!q.empty())    q.pop();//使队列为空，初始化 
    q.push(node);    //存入起始位置 
    while(!q.empty()){//直到空结束，即未找到目标 
        node = q.front();//使node为队列第一个元素 
        q.pop();        //取出即删除，下次循环即最近被“感染”的可“感染”物
        if(node.x == x_ && node.y == y_){//判断是否找到，找到直接停止 
            return node.step;            //并返回步数 
        }
        visit[node.x][node.y] = 1;//使之成为被访问过 
        for(int i = 0; i < 4; i++){//按右下左上顺序“感染” 
            int x = node.x + stepArr[i][0];
            int y = node.y + stepArr[i][1];
            if(x >= 0 && x < n && y >= 0 && y < m &&         
               visit[x][y] == 0 && mazeArr[x][y] == 0){
            　　//越界直接排除，为障碍直接排除，被访问过直接排除 
                visit[x][y] = 1; //标记 
                Node next(x, y, node.step+1); 
                q.push(next);        //核心，“感染”扩散过程
            }
        }
    }
    return -1;//未找到 
}
int main()
{
    memset(visit, 0, sizeof(visit));
    memset(mazeArr, 0, sizeof(mazeArr));//初始化 
    int x_, y_;//“目标”位置 
    cin >> n >> m >> x_ >> y_;//输入行列，目标位置 
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            cin >> mazeArr[i][j];//输入迷宫 
    cout << BFS(x_, y_);//记住，目标位置从0，0开始 ，可自设
                        //如BFS(x_-1, y_-1)
}            

 

#include<bits/stdc++.h>
using namespace std;
const int maxn = 105;
int n, m;        
const int stepArr[4][2] = {0, 1, -1, 0, 1, 0, 0, -1};    
int visit[maxn][maxn];
int mazeArr[maxn][maxn];     
struct Node{   
    int x, y, step;     
    Node(int x1, int y1, int step1):x(x1),y(y1),step(step1){} 
               
}; 
int BFS(int x_, int y_){
    Node node(0, 0, 0); 
    queue<Node> q;    
    while(!q.empty())    q.pop();
    q.push(node);    
    while(!q.empty()){
        node = q.front();
        q.pop();       
        if(node.x == x_ && node.y == y_){
            return node.step;             
        }
        visit[node.x][node.y] = 1;
        for(int i = 0; i < 4; i++)
        {
            int x = node.x + stepArr[i][0];
            int y = node.y + stepArr[i][1];
            if(x >= 0 && y >= 0 && x < n && y < m && visit[x][y] == 0 && mazeArr[x][y] == 0)
            {
                visit[x][y]=1;
                Node next(x , y, node.step+1);
                q.push(next);
            }
           }
    }
    return -1;
}
int main()
{
    memset(visit, 0, sizeof(visit));
    memset(mazeArr, 0, sizeof(mazeArr)); 
    int x_, y_;
    cin >> n >> m >> x_ >> y_; 
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            cin >> mazeArr[i][j];
    cout << BFS(x_, y_);
}

详情参见：https://baike.baidu.com/item/%E5%AE%BD%E5%BA%A6%E4%BC%98%E5%85%88%E6%90%9C%E7%B4%A2/5224802?fromtitle=BFS&fromid=542084&fr=aladdin