BFS 经典问题 走迷宫

题目描述

定义一个二维数组：

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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

输入描述

一个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

样例输出

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

代码

接下来粘贴代码，有什么看不明白的地方直接评论或者私信我都可，我天天上线。

#include<stdio.h>
#include<queue>
using namespace std;
int a[4][2]={1,0,-1,0,0,1,0,-1};
int maze[5][5];
struct node
{
	int x;
	int y;
	int prex;
	int prey;
};
node in[5][5];
void bfs(int i,int j)
{
	queue<node> q;
	node temp;
	temp.x=i;
	temp.y=i;
	q.push(temp);
	while(q.size())
	{
		node g=q.front();
		for(int k=0;k<=3;k++)
		{
			//maze[g.x+a[k][0]][g.y+a[k][1]]
			if(g.x+a[k][0]<0||g.y+a[k][1]<0||g.x+a[k][0]>4||g.y+a[k][1]>4)
				continue;
			if(maze[g.x+a[k][0]][g.y+a[k][1]]==1)
				continue;
			if(maze[g.x+a[k][0]][g.y+a[k][1]]==0)
			{	
				in[g.x+a[k][0]][g.y+a[k][1]].x=g.x+a[k][0];
				in[g.x+a[k][0]][g.y+a[k][1]].y=g.y+a[k][1];
				in[g.x+a[k][0]][g.y+a[k][1]].prex=g.x;
				in[g.x+a[k][0]][g.y+a[k][1]].prey=g.y;
				node r;
				r.x=g.x+a[k][0];
				r.y=g.y+a[k][1];
				r.prex=g.x;
				r.prey=g.y;
				q.push(r);
				maze[g.x][g.y]=1;
				if(g.x+a[k][0]==4&&g.y+a[k][1]==4)
					return ;
			}
		}
		q.pop();	
	}
	return ;
}
node ans[30];
int cnt=0;
void print(int i,int j)
{
	ans[cnt].x=i;
	ans[cnt].y=j;
	int prx=in[i][j].prex;
	int pry=in[i][j].prey;
	while(1)
	{
		cnt++;
		ans[cnt].x=prx;
		ans[cnt].y=pry;
		if(prx==0&&pry==0)
			return ;
		int tt=prx;
		prx=in[prx][pry].prex;
		pry=in[tt][pry].prey;
	}
}
int main()
{
	for(int i=0;i<=4;i++)
		for(int j=0;j<=4;j++)
			scanf("%d",&maze[i][j]);
	bfs(0,0);
	print(4,4);
	for(int i=cnt;i>=0;i--)
		printf("(%d, %d)\n",ans[i].x,ans[i].y);
}