广搜经典例题--迷宫问题POJ3894

首先定义一个矩阵：

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

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

如：

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

最基础的广搜。先将起始位置入队列，

每次从队列拿出一个元素，扩展其相邻的4个元素入队列（要判重），直到队头元素为终点为止。队列里的元素记录了指向父节点（上一步）的指针。队列不能用STL和quene或deque，要自己写。用一维数组实现，维护队头指针和队尾指针。

思路：

①从终点出发查找起点，方便记录路径。

②将为此走过的位置定义为不可重复走的点。

③找到起点后，可以立即返回。

我们需要找最短路径，只要最先可以达到，那么就肯定是最短路径。

代码如下：

#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <queue>
using namespace std;
 
const int N = 5;
int Maze[N][N];
pair<int, int> path[N][N];
const int BLOCK = 1;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
 
inline bool isLegal(int x, int y)
{
    return x>=0 && y>=0 && x<N && y<N && !Maze[x][y];
}
 
template<typename T>
inline bool equ(T t1, T t2) { return t1 == t2; }
 
void bfsGetPath(int sx = 0, int sy = 0, int ex = 4, int ey = 4)
{
    queue<pair<int, int> > qu;
    qu.push(make_pair(ex, ey));
    path[ex][ey] = make_pair(-1, -1);
    Maze[ex][ey] = BLOCK;
 
    while (!qu.empty())
    {
        pair<int, int> fa = qu.front();    qu.pop();
        for (int i = 0; i < 4; i++)
        {
            int nx = dx[i] + fa.first, ny = dy[i] + fa.second;
            if (!isLegal(nx, ny)) continue;
 
            path[nx][ny] = fa;
            if (equ(nx, sx) && equ(ny, sy)) return;
 
            qu.push(make_pair(nx, ny));
            Maze[nx][ny] = BLOCK;
        }
    }
}
 
int main()
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            scanf("%d", Maze[i]+j);
        }
    }
 
    bfsGetPath();
 
    int x = 0, y = 0;
    while (x != -1)
    {
        printf("(%d, %d)\n", x, y);
        int nx = path[x][y].first;
        int ny = path[x][y].second;
        x = nx, y = ny；
    }
    return 0;
}

数媒202潘zy