POJ 3984 迷宫问题

最新推荐文章于 2022-11-15 14:03:19 发布

原创最新推荐文章于 2022-11-15 14:03:19 发布 · 371 阅读

0 ·

CC 4.0 BY-SA版权

算法专栏收录该内容

52 篇文章

订阅专栏

本文介绍了一种使用广度优先搜索（BFS）寻找二维迷宫中最短路径的方法，并通过回溯的方式输出路径坐标。文章提供了一个具体的迷宫实例及其最短路径的求解过程。

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

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)

#include <iostream>
#include <queue>
using namespace std;
char maze[5][5];
int d[5][5]={0};
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
int sx,sy,gx,gy;
int inf=99999999;
typedef pair<int,int> P;
queue<P> que;

void dfsn(int ,int , int);

struct zuobiao
{
	int x;
	int y;
}aa[50];
int main()
{
	int i,j;
	//初始化迷宫 
	for (i=0;i<5;i++)
		for (j=0;j<5;j++)
		{
			cin>>maze[i][j];
			if (maze[i][j]=='0') d[i][j] = inf;
		}
	
	sx = 0; sy = 0;//起点
	gx = 4; gy = 4;//终点 
	
	//初始化队列，先把起点坐标加入到队列中 
	que.push(P(sx, sy));
	d[sx][sy] = 0;
	
	//BFS
	while (que.size())
	{
		P pp=que.front();//pp为当前坐标 
		que.pop();
		if (pp.first==gx && pp.second==gy) break;//如果当前坐标 pp 到达终点，就立即退出循环 
		//遍历 4 个方向 
		for (i=0;i<4;i++)
		{
			int nx=pp.first+dx[i];
			int ny=pp.second+dy[i];
			if (0<=nx && nx<5 && 0<=ny && ny<5 && maze[nx][ny]!='1' && d[nx][ny]==inf)
			{
				que.push(P(nx,ny)); //将符合条件的方向加入到队列 que 中 
				d[nx][ny]=d[pp.first][pp.second] + 1;//步数 +1 
			}
		}
	}
	
	//得到最短路劲坐标坐标，用 DFS从终点一直追溯回起点得到路径坐标 
	dfsn(gx,gy,d[gx][gy]);
	
	//显示结果 
	for (i=1;i<=d[gx][gy];i++)
		cout<<"("<<aa[i].x<<", "<<aa[i].y<<")"<<endl;
		
	cout<<"("<<4<<", "<<4<<")"<<endl;
	return 0;
}

//DFS
void dfsn(int x,int y,int ans)
{
	int i,j;
	int ddx,ddy;
	if (ans>1)
	{
		for (ddx=-1;ddx<=1;ddx++)
			for (ddy=-1;ddy<=1;ddy++)
			{
				int nnx=x+ddx;
				int nny=y+ddy;
				if (0<=x+ddx && x+ddx<5 && 0<=y+ddy && y+ddy<5 && d[nnx][nny]==ans-1)
				{
					aa[ans].x=nnx;
					aa[ans].y=nny;
					dfsn(nnx,nny,ans-1);
				}		
			}
	}

}