宽度优先搜索

广度（宽度）优先搜索的话就是按照层次来寻找
队列实现（普通队列）
宽度，顾名思义就是按照同一个层次进行宽度扩展
层次1：节点1
层次2：节点2
层次3：节点3 节点4
层次4：节点5 节点6 节点7 节点8
实现思路：
首先把相同层次的节点（在迷宫里面，一个点能走到其他八个方向的点是同一个层次）如下图 把相同层次的放到队尾，再把之前得到这些层次的上一层次的元素出队

上图红色路线代表可以走，绿色代表有障碍
首先队列中只有一个节点1
节点1出队 节点2入队 然后节点2出队 节点3和4同时入队（因为他们属于同一个层次）
依次类推

#include<bits/stdc++.h>
using namespace std;
const int maxn = 10;
 struct Node{
    int x;
    int y;
    int pre;///储存推出它的之前的那个点（父亲节点）
}edge[maxn<<4];///队列
int dx[8]={-1,0,1,-1,1,-1,0,1};
int dy[8]={1,1,1,0,0,-1,-1,-1};
bool vis[maxn][maxn];///标记数组
int M[maxn][maxn];///迷宫数组
int front = 0;///队列的头指针
int rear = 0;///队列的尾指针
void f(int m)///答案输出
{
    if (edge[m].pre!=-1)
    {   
        f(edge[m].pre);///在输出之前，他先找到它的父亲输出
        cout<<edge[m].x<<' '<<edge[m].y<<endl;///所以就是反向输出
        ///层次越高越接近出口，这样的话先输出层次小的，也就是离入口近的
    }
}
void BfS(int x,int y)
{
     edge[front].x = x;
     edge[front].y = y;
     edge[front].pre = -1;///自己本身没有父亲，所以直接赋值为-1
     rear = 1；
     while (front<rear)
     {
        int i=0;
        for (i=0;i<8;++i)///直接跑八个方向，都跑一遍
        {
            int xx=edge[front].x+dx[i];
            int yy=edge[front].y+dy[i];
            if (xx<0||xx>=5||yy<0||yy>=5||vis[xx][yy]||M[xx][yy])continue;///越界或者障碍，或者已经经过直接跳过
            else 
            {
                edge[rear].x=xx;
                edge[rear].y=yy;
                edge[rear].pre=front;///储存得到它的父亲的数组下标
                vis[xx][yy]=1;
                M[xx][yy]=1;
                ++rear;///入队所以指针往后移动
            }
            if (xx==4&&yy==4)///如果当前找到了出口
            {
                f(front);///不可rear，因为此时是由front移动得到的
                ///这样只会得到一个答案，因为此时的rear没有移动了，因为之后没有地方移动了
                ///所以最后rear==front
            }
        }
        ++front;///跑完八个方向，队首元素直接出队，没用用了
     }
}
int main()
{
    for(int i=0;i<5;++i)
    {
        for (int j=0;j<5;++j)
        {
            cin>>M[i][j];
        }
    }
    memset(vis,0,sizeof(vis));///vis数组全为0赋值
    BfS(0,0);
    return 0;
}