迷宫问题 POJ - 3984

最新推荐文章于 2020-11-03 16:36:14 发布

WA你离我远点

最新推荐文章于 2020-11-03 16:36:14 发布

阅读量162

点赞数

分类专栏： oj 搜索

oj 同时被 2 个专栏收录

31 篇文章

订阅专栏

搜索

19 篇文章

订阅专栏

本文介绍了一种解决迷宫最短路径问题的算法，通过使用广度优先搜索（BFS）策略，从迷宫的起点出发，寻找到达终点的最短路径。文章详细展示了如何定义迷宫的二维数组表示，以及如何实现BFS算法来遍历迷宫并记录路径。此外，还提供了一个C++代码示例，用于演示如何应用该算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

定义一个二维数组：

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

Sample Output

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

AC代码（个人觉得记录路径是一个难点）

Select Code

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
//#include <bits/stdc++.h>
using namespace std;
int mp[10][10];
int vis[10][10];
int n = 5;
struct node
{
    int x, y;
    int c;
}s, t, q[100];
int nxt[5][3] = {{0,1},{0,-1},{1,0},{-1,0}};
void yin(int head) //先走到最后然后再通过递归来输出路线
{
    while(q[head].c!=-1)
    {
        yin(q[head].c);
        printf("(%d, %d)\n",q[head].x, q[head].y);
        return;
    }
   printf("(%d, %d)\n",0,0);
}
void bfs(int ii, int jj)
{
    int i;
    memset(vis, 0, sizeof(vis));
    int tail = 0, head = 0;
    s.x = ii, s.y = jj, s.c = -1;
    q[tail++] = s;
    vis[s.x][s.y] = 1;
    while(head<tail)
    {
        s = q[head];
        if(s.x==4&&s.y==4)
        {
            yin(head);
            return;
        }
        for(i = 0;i<4;i++)
        {
            t.x = s.x+nxt[i][0];
            t.y = s.y+nxt[i][1];
            if(t.x>=0&&t.x<n&&t.y>=0&&t.y<n&&mp[t.x][t.y]!=1&&!vis[t.x][t.y])
            {
                vis[t.x][t.y] = 1;
                t.c = head; //记录上一个走过的点
                q[tail++] = t;
            }
        }
        head++;
    }
    return;
}
int main()
{
    int i, j;
    for(i = 0;i<n;i++)
    {
        for(j = 0;j<n;j++)
        {
            scanf("%d",&mp[i][j]);
        }
    }
    bfs(0,0);
    return 0;
}