POJ 3984 迷宫问题

来源: http://poj.org/problem?id=3984

迷宫问题

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 8154		Accepted: 4804

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

[p]Input

一个5 × 5的二维数组。表示一个迷宫。数据保证有唯一解。 Output[/p] 左上角到右下角的最短路径，格式如例子所看到的。

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)

Source

题意:略
题解:  非常基础的题，没有挖坑。

三种方法解决之 1.递归DFS+回溯
2.非递归DFS+回溯      
3.BFS

  //前两种方法均是先将全部路径求出再找出最短路径~~ 第三种方法BFS，不用说了，肯定是最短的。
PS: poj这题的測试数据真的是好弱好弱！

！。 開始交了两个考虑不到位的代码也给过了...
AC代码1:

/*
MummyDing
POJ 3984迷宫问题【DFS】
*/
#include<iostream>
#define Max 100
using namespace std;
int maze[5][5],road[25][2]={0},temproad[25][2],pos=0;
int dir[4][2]={
{1,0},{0,1},{-1,0},{0,-1}  //四个方向
};
struct Road{
int r[30][2],step;    //用于存储路径
}roads[Max];
void dfs(int x,int y,int step){
if(x==4&&y==4){		//达到目标状态
roads[pos].step=step;
for(int i=1;i<step;i++){
roads[pos].r[i][0]=temproad[i][0];
roads[pos].r[i][1]=temproad[i][1];
}
pos++;
return ;
}
for(int i=0;i<4;i++){		//四个方向进行搜索
int dx=x+dir[i][0],dy=y+dir[i][1];
if(dx>=0&&dy>=0&&dx<5&&dy<5&&!maze[dx][dy]){
maze[dx][dy]=1;
temproad[step][0]=dx; temproad[step][1]=dy;
dfs(dx,dy,step+1);   //DFS+回溯
maze[dx][dy]=0;
}
}
}
int main()
{
for(int i=0;i<5;i++)
for(int j=0;j<5;j++)
cin>>maze[i][j];       //输入数据
dfs(0,0,1);			//dfs，找出全部路径
int ans=0;			//找出最短路径
for(int i=1;i<pos;i++)
if(roads[i].step<roads[ans].step)
ans=i;
for(int i=0;i<roads[ans].step;i++)
cout<<'('<<roads[ans].r[i][0]<<", "<<roads[ans].r[i][1]<<')'<<endl;
return 0;
}

AC代码2:

/*
MummyDing
POJ3984迷宫问题【非递归】
*/
#include<iostream>
#include<cstring>
#define Max 100
using namespace std;
struct Node{
int maze[5][5];		//x,y 代表当前位置
int x,y,exdir[4],step;  // exdir标记该方向之前是否被走过
}stack[Max]={0},temp={0};
struct Road{
int r[30][2],step;
}roads[Max];
int  top=0,pos=0;
int dir[4][2]={
{0,1},{1,0},
{-1,0},{0,-1}
};
int main()
{
for(int i=0;i<5;i++)
for(int j=0;j<5;j++)
cin>>stack[0].maze[i][j];
while(~top)
{
if(stack[top].x==4&&stack[top].y==4)  //达到目标状态
{
roads[pos].step=stack[top].step;
for(int i=0;i<=stack[top].step;i++)
{
roads[pos].r[i][0]=stack[i].x;
roads[pos].r[i][1]=stack[i].y;
}
pos++;
}
bool flag=true;
for(int i=0;i<4;i++)
{
temp=stack[top];
int dx=dir[i][0]+temp.x,dy=dir[i][1]+temp.y;
if(dx>=0&&dy>=0&&dx<5&&dy<5&&!temp.maze[dx][dy]&&!temp.exdir[i]){
stack[top].exdir[i]=1;//标记此方向
temp.maze[temp.x][temp.y]=1; //标记走过的点
temp.x=dx;temp.y=dy;  //状态转移到该节点
temp.step++;        //步数加1
stack[++top]=temp;   //结点入栈
memset(stack[top].exdir,0,sizeof(stack[top].exdir));
flag=false;
break;
}
}
if(flag)
top--;
}
int ans=0;
for(int i=1;i<pos;i++)
if(roads[i].step<roads[ans].step)
ans=i;
for(int i=0;i<=roads[ans].step;i++)
cout<<'('<<roads[ans].r[i][0]<<", "<<roads[ans].r[i][1]<<')'<<endl;
return 0;
}
/*
測试数据
0 1 0 0 0
0 0 0 1 0
1 0 1 1 0
1 0 0 0 0
1 1 1 1 0
*/

AC代码3:

/*
MummyDing
POJ 3984迷宫问题BFS
*/
#include<iostream>
#include<cstring>
#define Max 500
using namespace std;
struct Node{
int maze[5][5];
int x,y,step,pre;  //pre用来记录上个节点的位置
}map[Max]={0},temp={0};
int  road[30][2], exdir=0,nodedir=0;
int dir[4][2]={
{0,1},{1,0},{-1,0},{0,-1}
};
bool equal(Node x,Node y)
{
for(int i=0;i<5;i++)
for(int j=0;j<5;j++)
if(x.maze[i][j]^y.maze[i][j]) return false;
return true;
}
bool check(Node x)  //判重
{
for(int k=0;k<exdir;k++)
if(equal(x,map[k])) return false;
return true;
}
int main()
{
for(int i=0;i<5;i++)
for(int j=0;j<5;j++)
cin>>map[0].maze[i][j];
map[0].pre=-1;
while(nodedir<=exdir&&exdir<Max)
{
for(int i=0;i<4;i++)	//四个方向进行搜索
{
temp=map[nodedir];// 头结点
temp.pre=nodedir; temp.maze[temp.x][temp.y]=1; //做标记
temp.x+=dir[i][0]; temp.y+=dir[i][1]; temp.step++;
if(temp.x<5&&temp.y<5&&temp.x>=0&&temp.y>=0&&!temp.maze[temp.x][temp.y])
{
if(temp.x==4&&temp.y==4)
{
int k=temp.step; int m=k;
road[k][0]=temp.x;road[k--][1]=temp.y;
for(;k>0;k--){
road[k][0]=map[temp.pre].x;
road[k][1]=map[temp.pre].y;
temp=map[temp.pre];
}
for(int k=0;k<=m;k++)
cout<<'('<<road[k][0]<<", "<<road[k][1]<<')'<<endl;
return 0;
}
else if(check(temp)) //该节点没有就加到队列中
map[++exdir]=temp;
}
}
nodedir++;
}
return 0;
}
/*
0 1 0 0 0
0 0 0 1 0
1 0 1 1 0
1 0 0 0 0
1 1 1 1 0
*/