算法：迷宫问题（宽搜）

宽搜

bfs不同于dfs,它不需要用到显式的递归操作，而是将状态存储在队列中，可以用来求权值为1的最短路。
每次都将队首的元素取出，然后将可以由这个元素经过一步操作达到的放入队尾。在最短路问题中只要到达过的节点，之后就不会再到达。

问题描述

给定一个n*m的二维整数数组，用来表示一个迷宫，数组中只包含0或1，其中0表示可以走的路，1表示不可通过的墙壁。

最初，有一个人位于左上角(1, 1)处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。

请问，该人从左上角移动至右下角(n, m)处，至少需要移动多少次。

数据保证(1, 1)处和(n, m)处的数字为0，且一定至少存在一条通路。

输入格式

第一行包含两个整数n和m。

接下来n行，每行包含m个整数（0或1），表示完整的二维数组迷宫。

输出格式

输出一个整数，表示从左上角移动至右下角的最少移动次数。

数据范围

1≤n,m≤100

输入样例：

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出样例：

8

代码

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N = 110;
int m, n;
typedef struct queue{
    int value[N * N][2];
    int bg = 0;
    int ed = 0;
}queue;
queue q;
int map[N][N];
int flag[N][N];
int dir[4][2] = {0, -1, 0, 1, 1, 0, -1, 0}; // 左右下上
int bfs(){
    while(q.bg <= q.ed){
        int x = q.value[q.bg][0];
        int y = q.value[q.bg][1];
        q.bg++;
        for(int i = 0; i < 4; ++i){
            int g = x + dir[i][0], h = y + dir[i][1];
            if(g == n + 1 || g == 0 || h == m + 1 || h == 0 || map[g][h] == 1 || flag[g][h] != -1) {
                continue;
            }else{
                flag[g][h] = flag[x][y] + 1;
                q.ed++;
                q.value[q.ed][0] = g;
                q.value[q.ed][1] = h;
            }

        }
    }
    return flag[n][m];
}

// 宽搜
int main(){
    cin >> n >> m;
    for(int i = 1; i <= n; ++i){
        for(int j = 1; j <= m; ++j){
            scanf("%d", &map[i][j]);
        }
    }
    memset(flag, -1, sizeof flag);
    q.value[q.ed][0] = 1;
    q.value[q.ed][1] = 1;
    flag[1][1] = 0;
    cout << bfs() << endl;
    return 0;

}

原题链接