【POJ3984】迷宫问题

最新推荐文章于 2019-02-20 11:07:57 发布

idealistic

最新推荐文章于 2019-02-20 11:07:57 发布

阅读量255

点赞数

分类专栏：懵懂(￣o￣) . z Z 编程语言 POJ DFS（深度搜索） BFS（广搜+队列）

编程语言同时被 3 个专栏收录

307 篇文章

订阅专栏

懵懂(￣o￣) . z Z

34 篇文章

订阅专栏

POJ

27 篇文章

订阅专栏

本文介绍了一种解决迷宫问题的方法，通过使用广度优先搜索（BFS）算法找到从迷宫左上角到右下角的最短路径。文章提供了一个具体的5x5迷宫示例，并给出了完整的C语言实现代码。

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

迷宫问题

Time Limit:1000MS Memory Limit:65536KB 64bit IO Format:%lld & %llu

Submit Status Practice POJ 3984

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

Sample Output

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
int map[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,
};  
int dx[4] = { 1,-1,0,0 };  
int dy[4] = { 0,0,1,-1 };    
struct node  
{  
    int x, y, pre;  
}que[100];  
  
void print(int i)//递归倒序输出经过的路径，头尾输出不了  
{  
    if (que[i].pre != -1)  
    {  
        print(que[i].pre);  
        printf("(%d, %d)\n", que[i].x, que[i].y);  
    }  
}  
void bfs(int x1,int y1)  
{  
    que[0].x = x1;  
    que[0].y = y1;  
    que[0].pre = -1;  
    int front = 0, rear = 1;//用队列数组  
    while (front < rear)  
    {  
        for (int i = 0; i < 4; i++)  
        {  
            int xx = dx[i] + que[front].x;  
            int yy = dy[i] + que[front].y;  
            if (xx < 0 || xx >= 5 || yy < 0 || yy >= 5 || map[xx][yy]==1)  
            continue;  
            else  
            {  
                map[xx][yy] = 1; //记录为走过的点 
                que[rear].x = xx;  
                que[rear].y = yy;  
                que[rear].pre = front;//记录前驱，也就是路径  0,1,2,3... 
                rear++;             //入队  
            }  
            if (xx == 4 && yy == 4)  
                print(front);//用front尾部不包括，用rear-1尾部包括  
        }  
        front++;        //出队  
    }  
}  
  
int main()  
{    
    printf("(0, 0)\n");  
    bfs(0, 0);  
    printf("(4, 4)\n");  
    return 0;  
}