poj 3984

迷宫问题

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 9325		Accepted: 5523

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)

Source

刚刚开始学数据结构的小白一枚~因为很多东西都没学 这里只是记载自己的思路和想法

慢慢开始更新研究的acm题目

这个3984, 我的思路是这样的

一开始试图用链表堆栈，通过如果走到死胡同就删除末端结点

但是这样无法找到最短的路径 找到的只是某条路径

因为刚刚学了队列·····

将所有的一步一步走的点构造为一个队列 显然无法用链表表示所有的

所以考虑用结构体数组

里面是所有能走的位置 则需要一个record记录每条线路的结点的先后关系

设立rear front

但是这里很特殊

front不是一直停留在某个路线的头，而是作为步数+1各种情况的一个讨论（自己写的自己都要看不懂了·····

也就是说只要令现在正在讨论的满足路线的点的record 置为其上一级 front 就可以实现用record在数组里查找路线了

没走一步 就当做那个位置变成了墙壁 即可进行条件判断能不能走

最后输出的时候也是模仿别人的~写了个递归

以下是源代码

#include<iostream>
#define mazesize 5


int maze[mazesize][mazesize];
using namespace std;


int front=0,rear=0;






struct map{
int nx,ny;
int record;
} way[100];
void insert(int a,int b)
{
way[rear].nx=a;
way[rear].ny=b;
if(rear!=front)
way[rear].record=front;
rear++;
}
bool empty()
{
if(front!=rear)
return false;
return true;
}
void print(int i)
{
if(way[i].record !=-1)
{
print(way[i].record);//way[way[i].record].record
cout<<"("<<way[i].nx <<", "<<way[i].ny <<")"<<endl;
}
}










int main()
{


int mx[4]={0,0,-1,1},my[4]={1,-1,0,0};
int x=0,y=0;
int dx,dy;
for(int i=0;i<mazesize;i++)
for(int j=0;j<mazesize;j++)
cin>>maze[i][j];
insert(x,y);
way[0].record=-1;
while(!empty())
{
for(int k=0;k<4;k++)
{
dx=mx[k]+way[front].nx ;
dy=my[k]+way[front].ny ;
if(dx>4||dy>4||maze[dx][dy]||dx<0||dy<0)
continue;
else
{
maze[dx][dy]=1;
insert(dx,dy);

}
if(dx==4&&dy==4)
{
cout<<"(0, 0)"<<endl;
print(front);
cout<<"(4, 4)"<<endl;
}
}
front++;
}
return 0;
}