poj 3984 迷宫问题（BFS+回溯）

迷宫问题

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 11256		Accepted: 6733

点击打开链接

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

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)

题目分析：

题目看着挺简单的本以为用个STL中的队列就可以解决，最后还是没出来，最后还得用模拟的队列(因为前驱,STL的那些队头、队尾指针是不晓得的),被这个小简单的给搞死了；

我觉得最重要的一点是：必须得回溯，否则路径就是错的

AC代码：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<algorithm>
using namespace std;
int map[5][5];
int vis[5][5];
int fx[4]={1,0,-1,0};
int fy[4]={0,1,0,-1};
int sx=0,sy=0;

struct node
{
	int x,y;
	int pre;
}q[30];

int valid(int x,int y)
{
	if(x>=0&&x<5&&y>=0&&y<5)
	return 1;
	else
	return 0;
}

void print(int pos)//递归求路径
{ 
  if(q[pos].pre!=-1)
  {
  	print(q[pos].pre);
  	printf("(%d, %d)\n",q[pos].x,q[pos].y);
  }
}

void BFS()
{
  int front=0,rear=1;
  q[front].x=sx;
  q[front].y=sy;
  q[front].pre=-1;
  
  while(front<rear)
  {
  	for(int i=0;i<4;i++)
  	{
  	  int a=q[front].x+fx[i];
	  int b=q[front].y+fy[i];
	  
	  if(!vis[a][b]&&!map[a][b]&&valid(a,b))
	  {
	  	vis[a][b]=1;
	  	q[rear].x=a;
	  	q[rear].y=b;
	  	q[rear].pre=front;//记录前驱
	  	rear++;
	  }
	  if(a==4&&b==4)
	   print(front);
	}
	front++;//头指针+1<=>出队&&保存着当前节点
  }
}

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

来贴个一直错的代码：

思路：用两个队列，一个保存之前的那个节点，一个保存当前的节点

求大神支招来解决，被这个困扰了

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<algorithm>
using namespace std;
int map[5][5];
int vis[5][5];
int fx[4]={1,0,-1,0};
int fy[4]={0,1,0,-1};

struct node
{
	int x,y;
	int time;
};
int sx=0,sy=0;
queue<node>q,q1;

int valid(node p)
{
	if(p.x>=0&&p.x<5&&p.y>=0&&p.y<5)
	return 1;
	else
	return 0;
}

void print()
{ 
	while(!q1.empty())
	{
	  node a=q1.front();
	  q1.pop();
	  printf("(%d, %d)\n",a.x,a.y);
	}
	printf("(4, 4)\n");
}

void BFS()
{
  node p1,p2;
  p1.x=sx;
  p1.y=sy;
  p1.time=0;
  while(!q.empty())
  q.pop();
  
  vis[p1.x][p1.y]=1;
  q.push(p1);
  
  while(!q.empty())
  {
  	p1=q.front();
  	q.pop();
  	for(int i=0;i<4;i++)
  	{
  	  p2.x=p1.x+fx[i];
	  p2.y=p1.y+fy[i];
	  
	  if(!vis[p2.x][p2.y]&&!map[p2.x][p2.y]&&valid(p2))
	  {
		p2.time=p1.time+1;
	  	vis[p2.x][p2.y]=1;
	  	q.push(p2);
	  	q1.push(p1);
	  }
	  if(p2.x==4&&p2.y==4)
	  {
	   print();
	   return ;
	  }
	  
	}
  }
}

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