POJ 3984 迷宫（BFS）

Description

定义一个二维数组：

int maze[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,

};

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

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。
Output

左上角到右下角的最短路径，格式如样例所示。
Sample Input

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
Sample Output

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

PS：其实这个题目我打算用DFS去做，但是很遗憾没有做出来，一搜题解发现是个BFS的题目，题目要求输出每一个步骤，我刚开始是从正反向去做，发现输出了很多其他的点，当时不明白的我现在知道了，其他点都是代表遍历过的点，并不是路径上的点，题解是用一个结构体数组去存储路径上的每个点，然后方向递归输出，一旦涉及到递归一定有两个必不可缺的条件：递归表达式和递归结束条件，只要少了一部分递归就不成立，除此之外这个题目基本上都是和普通的bfs代码差不多

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
int d[4][2] = {
   -1, 0, 1, 0, 0, -1, 0, 1};
int a[100][100], vis[100][100];

struct node
{
   
    int x, y;
};
node pre[100][100];
void bfs()
{
   
    queue<node> q;
    node s, e;
    s.x = s.y = 0;
    q.push(s);
    vis[s.x][s.y] = 1;
    while (!q.empty())
    {
   
        s = q.front();
        q.pop();
        for (int i = 0; i < 4; ++i)
        {
   
            e.x = s.x + d[i][0];
            e.y = s.y + d[i][1];
            if (e.x >= 0 && e.x < 5 && e.y >= 0 && e.y < 5 && a[e.x][e.y] == 0 && !vis[e.x][e.y])
            {
   
                vis[e.x][e.y] = 1;
                q.push(e);
                pre[e.x][e.y] = s;//就是说如果当前点可以往下走，就记录当前点
            }
        }
    }
}
void print(node x)
{
   
    if (x.x == 0 && x.y == 0)//递归结束条件
    {
   
        printf("(0, 0)\n");
        return;
    }
    print(pre[x.x][x.y]);
    printf("(%d, %d)\n", x.x, x.y);
}
int main()
{
   
    for (int i = 0; i < 5; ++i)
        for (int j = 0; j < 5; ++j)
            scanf("%d", &a[i][j]);
    bfs();
    node y;
    y.x = y.y = 4;
    print(y);
    return 0;
}

附上另一个用pair做的，代码基本一样，但是也有参考的价值

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
pair<int, int> Path[6][6], now, Next; // Path数组用来标记路径
int dir[4][2] = {
   1, 0, 0, 1, -1, 0, 0, -1};
bool vis[6][6];
int MAP[6][6];
int step;
void bfs()
{
   
   step = 0;
   memset(vis, 0, sizeof(vis));
   queue<pair<int, int> > q;
   q.push(make_pair(0, 0));
   while (!q.empty())
   {
   
      now = q.front();
      q.pop();
      if (now.first == 4 && now.second == 4)
         return;
      for (int i = 0; i < 4; i++)
      {
   
         int u = Next.first;
         int v = Next.second;
         u = now.first + dir[i][0];
         v = now.second + dir[i][1];
         if (u >= 0 && v >= 0 && u < 5 && v < 5 && MAP[u][v] == 0 && !vis[u][v])
         {
   
            vis[u][v] = 1;
            Path[u][v].first = now.first; // 将Path数组的Next保存为上一个点的坐标now
            Path[u][v].second = now.second;
            q.push(make_pair(u, v));
         }
      }
   }
}

void output(int x, int y)
{
    // 递归过程
   if (x == 0 && y == 0)
   {
   
      printf("(%d, %d)\n", x, y);
      return;
   }
   output(Path[x][y].first, Path[x][y].second);
   printf("(%d, %d)\n", x, y);
}

int main()
{
   
   for (int i = 0; i < 5; i++)
      for (int j = 0; j < 5; j++)
         scanf("%d", &MAP[i][j]);
   bfs();
   output(4, 4);
   return 0;
}