bfs（二维数组方式储存图）使用queue来操作：

bfs如果仅有一条最短路径，可直接设置flag结束遍历，因为广度搜索已经遍历了每一步的所有可能，第一个找到的解已经是最短路径（之一）
而dfs则不行，回溯式的结构不能使得找到的第一个解为最短路
1 创建地图 标记 方向数组（建议地图与标记分别用一个二维数组）
2 创建结构体（需要输出路径的话要在结构体中加入struct Node *A）不是struct Node A
3 创建队列queue<Node>q;
4 起始位置的Node入队并标记 设置flag判断是否结束
5 移动（new_x ， new_y）
5 判断是否出界（continue） 是否能不是障碍且未走过
6 满足条件进入后，标记 --》创建新的结构体 --》新结构体入队
7 判断是否找到（找到则break）
8 出队（最后一次不出队）
9 main中输出 队尾 的step值 （此时亦可以输出路径）

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

int n,m;
int a[51][51] = {0}, book[51][51] = {0}, dir[4][2] = {{0, 1}, {1 ,0 }, {0 ,-1}, {-1 , 0}};

struct Node{
    int x;
    int y;
    int step;
    struct Node *A;
};

queue<Node>q;

void bfs(Node cur, int s, int d){
    q.push(cur);
    book[cur.x][cur.y] = 1;
    int flag = 0;
    while(!q.empty()){
        for(int i = 0; i <= 3; i++){
            int nx = q.front().x + dir[i][0], ny = q.front().y + dir[i][1];
            if(nx < 1 || nx > n || ny < 1 || ny > m) continue;
            if(book[nx][ny] == 0 && a[nx][ny] == 0){
                book[nx][ny] = 1;
                Node new_node = {nx, ny, q.front().step + 1, &q.front()};
                q.push(new_node);
            }
            
            if(nx == s&&ny == d){
                flag = 1;
                break;
            }
        }
        //cout<<q.front().step <<q.front().x<<q.front().y<<" ";
        if(flag == 1) break;
        q.pop();
    }
}

int main(){
    int startx, starty, stopx , stopy;
    scanf("%d %d", &n ,&m);
    for(int i = 1; i <= n ; i++){
        for(int j = 1; j <= m; j++){
            scanf("%d", &a[i][j]);
        }
    }
    scanf("%d %d %d %d", &startx, &starty, &stopx, &stopy);
    Node cur = {startx, starty, 0 , NULL};
    bfs(cur , stopx, stopy);
    printf("%d\n", q.back().step);
    Node z = q.back();
    while(z.A != NULL){
        printf("(%d,%d)-->", z.x, z.y);
        z = *z.A;
    }
    printf("(%d,%d)", startx, starty);
    return 0;
}