BFS简单迷宫

常见迷宫:

输入迷宫 启点 终点 然后求最短路径 BFS例题

用dist[][]数组来记录 启点到每个点的最短路径

#include <iostream>
#include <fstream>
#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;

const int maxsize = 128;
const int INF = 0xfff3;
int m,n;
int d[2][4] = { {-1, 0, 1, 0}, {0, 1, 0, -1} };
int dist[maxsize][maxsize];//书上方法 : 用dist[m][n]将最短路径储存起来 初始为INF表示无法到达
struct Pos
{
    int x,y;
}st,ed;
char maze[maxsize][maxsize];

bool check(int x, int y)
{
    if(x < 0 || x >= m || y < 0 || y >= n) return false;
    if(maze[x][y] == '#' || dist[x][y] != INF) return false;//!=INF表示可达就已经走到过
    return true;
}
int bfs()
{
    for (int i = 0; i < m; i++)
      for (int j =0 ;j < n; j++)
        dist[i][j] = INF;
    queue<struct Pos> que;
    que.push(st);
    dist[st.x][st.y] = 0;//自己到自己为0
    while (!que.empty())
    {
        int nx, ny;
        Pos node = que.front();
        que.pop();
        //ans ++;//这里出错 并不是 每次出队都是最短路径中的结点 调试可以发现
        if(node.x == ed.x && node.y == ed.y) return dist[ed.x][ed.y];
        for (int i =0 ; i < 4; i++)
        {
            nx = node.x + d[0][i];
            ny = node.y + d[1][i];
            if (check(nx, ny))
            {
                Pos temp;
                temp.x = nx;
                temp.y = ny;//这里用pair更好 方便
                dist[nx][ny] = dist[node.x][node.y] + 1;
                que.push(temp);
            }
        }
    }
    return -1;
}

int main()
{
    ifstream cin("in.txt");
    freopen("in.txt", "r", stdin);
    scanf("%d%d", &m, &n);
    getchar();
    for (int i = 0;i < m; i++)
    {
        gets(maze[i]);
    }
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (maze[i][j] == 'S')
            {
                st.x = i;
                st.y = j;
            }
            if (maze[i][j] == 'G')
            {
                ed.x = i;
                ed.y = j;
            }
        }
    }
    int ans = bfs();
    if (ans == -1) cout << "no way" << endl;
    else cout << ans << endl;
}
//对fill 和 memset 还需了解 是在不行就循环填充
//用dist记录最短路径 而不是每一次出队ans++
//时间复杂度 状态转移是四个方向 每个格至多访问一次 O(4*m*n)