Open judge------迷宫

定义一个二维数组： 

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)

   最基本的图搜索题目，唯一的难点在于路径的输出，。需要用到pre[]数组来盛放前一个节点，由于广搜，要用到队列，但是如果用STL的queue，尾指针弄不到，还是自己模拟一个队列。（还好前两天刚看了视频）  h和r分别表示队头和队尾，其中h初始化为0，r初始化为1. 那么的话 head<tail 就等价于 STL中queue的 empty（）函数

AC:

#include<iostream>
using namespace std;
struct node
{
	int x;
	int y;
}t[30];
int dir[4][2]={-1,0,1,0,0,1,0,-1};
int a[5][5],visit[5][5]={0};
int h=0,r=1;
int pre[30];
void print(int tt)            // 以递归回溯的方式输出路径。
{
	if (pre[tt]!=-1)
		    print(pre[tt]);
	cout<<"("<<t[tt].x<<", "<<t[tt].y<<")"<<endl;  //这里的格式是逗号后面有一个空格。
}
void bfs()
{
	
	  t[0].x=0;
	  t[0].y=0;
	  pre[0]=-1;
	while(h<r)
	{
		node tem;
		for (int i=0;i<4;i++)
		{
			tem.x=t[h].x+dir[i][0];
			tem.y=t[h].y+dir[i][1];
			if (tem.x+1==5&&tem.y+1==5)
				{
					print(h);
					cout<<"("<<tem.x<<", "<<tem.y<<")"<<endl;
					return ;
			    }
			if (a[tem.x][tem.y]==0&&tem.x>=0&&tem.x<5&&tem.y>=0&&tem.y<5&&!visit[tem.x][tem.y])
			{
				visit[tem.x][tem.y]=1;
				t[r].x=tem.x;    //新入队的元素放置在队尾
				t[r].y=tem.y;
				pre[r]=h;     //又队头元素t[h]
				r++;
			}
		}
		h++; //队头元素出队
	
	}
}

int main()
{
	for (int i=0;i<5;i++)
		for (int j=0;j<5;j++)
			cin>>a[i][j];
	bfs();
	return 0;
}