# poj 3984 迷宫问题【BFS && DFS】【简单】

﻿﻿

 Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 12134 Accepted: 7277

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,
};

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)

BFS☟

0MS 144K

#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
using namespace std;

int map[6][6];
int dis[6][6];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
typedef struct node{
int x, y;
node() {}
node(int x, int y) : x(x), y(y) {}
}node;

void BFS() {
queue <node> Q;
memset(dis, 100, sizeof(dis));
Q.push(node(0, 0));
dis[0][0] = 0;
while(!Q.empty()) {
node k = Q.front();
Q.pop();
int x = k.x;
int y = k.y;
for(int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if(nx < 0 || nx >= 5 || ny < 0 || ny >= 5 || map[nx][ny] == 1)
continue;
if(dis[nx][ny] > dis[x][y] + 1) {
dis[nx][ny] = dis[x][y] + 1;
Q.push(node(nx, ny));
}
}
}
stack <node> S;
int x = 4, y = 4;
S.push(node(x, y));
while(1) {
if(x == 0 && y == 0)
break;
for(int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if(nx < 0 || nx >= 5 || ny < 0 || ny >= 5)
continue;
if(dis[x][y] == dis[nx][ny] + 1) {
x = nx;
y = ny;
S.push(node(x, y));
}
}
}
while(!S.empty()) {
node a = S.top();
S.pop();
printf("(%d, %d)\n", a.x, a.y);
}
}

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

DFS☟

0MS 164K

#include <cstdio>
#include <cstring>
#include <cstdlib>
using namespace std;
int map[6][6];
int dis[7][7];
int n[18];
int m[18];
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};

void dfs(int sc, int sr, int total) {
if(sc < 1 || sc > 5 || sr < 1 || sr > 5)
return ;
if(map[sc][sr] == 1)
return ;
if(total  + 1 >= dis[sc][sr])
return ;
dis[sc][sr] = total  + 1 ;
map[sc][sr] = 1;
for(int i = 0; i < 4; i++) {
int nx = sc + dx[i];
int ny = sr + dy[i];
dfs(nx, ny, dis[sc][sr]);
}
map[sc][sr] = 0;
return ;
}

void Scanf_a() {
memset(dis, 0x3f, sizeof(dis));
for(int i = 1; i < 6; i++)
for(int j = 1; j < 6; j++)
scanf("%d", &map[i][j]);
}

void Printf_a() {
int x = 5, y = 5, q = 0;
int current = dis[x][y];
n[q] = x;
m[q++] = y;
while(x != 1 || y !=1) {
for(int i = 0; i < 4; i++) {
if(dis[x + dx[i]][y + dy[i]] == current - 1) {
x = x + dx[i];
y = y + dy[i];
n[q] = x;
m[q++] = y;
current--;
}
}
}
for(int j = dis[5][5] - 1; j >= 0; j--)
printf("(%d, %d)\n", n[j] - 1, m[j] - 1);
}

int main(){
Scanf_a();
dfs(1, 1, 0);
Printf_a();
system("pause");
return 0;
}

• 本文已收录于以下专栏：

## poj 3984 迷宫问题 dfs 求迷宫路径

• jingqi814
• 2013年09月25日 18:03
• 3330

## POJ3984 迷宫问题【BFS】

• u011676797
• 2015年05月18日 13:03
• 1592

## POJ3984迷宫问题（BFS+队列+栈）

POJ-3984-迷宫问题 http://poj.org/problem?id=3984 大概思路：进行普通的BFS，用队列来操作。在保存路径的时候，可以用栈来输出路径，利用先进后出的特性。...
• Seawindson
• 2016年07月11日 13:20
• 463

## 迷宫问题（maze problem）——深度优先（DFS）与广度优先搜索（BFS）求解

1.问题简介给定一个迷宫，指明起点和终点，找出从起点出发到终点的有效可行路径，就是迷宫问题（maze problem）。迷宫可以以二维数组来存储表示。0表示通路，1表示障碍。注意这里规定移动可以从上、...
• K346K346
• 2016年05月02日 11:27
• 14831

## 迷宫---DFS和BFS解法

• u013174702
• 2015年03月14日 21:31
• 1520

## poj3984迷宫问题（如何输出最短路）

• qq_33279781
• 2016年07月22日 09:42
• 689

## poj3984迷宫问题---适合入门的一道广度优先搜索题

• u012965373
• 2014年05月25日 11:03
• 966

## 迷宫最短路径dfs和bfs代码分析

dfs用递归一步步试探，在所有路径中选出最短的一条路径 代码： //0是路，1是墙 #include #include using namespace std; int x1,y1,x2,y2;//...
• qq_36238595
• 2017年02月09日 12:24
• 617

## BFS求解迷宫问题初探（java版）

BFS，其英文全称是Breadth First Search。 BFS并不使用经验法则算法。从算法的观点，所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。一般的实验里，其邻居节点尚未被检...
• wuhengde
• 2014年01月24日 14:30
• 2662

## 迷宫问题 dfs bfs

• qq_36183935
• 2017年05月24日 17:16
• 181

举报原因： 您举报文章：poj 3984 迷宫问题【BFS && DFS】【简单】 色情 政治 抄袭 广告 招聘 骂人 其他 (最多只允许输入30个字)