poj2251 Dungeon Master

题目大意：你在一个3D的地牢里的开始位置，想要逃跑，但只有一个出口，图中”#“号代表被石头阻塞了，不能通过，图中” . “代表可以通过

问题是：让你从开始点找一条最短的途径逃出这个地牢，并输出逃出所需要的时间如：Escaped in 11 minute(s).

若不能能逃出，则输出被套住了”Trapped!“

     问题分析：这个是一个单点出发，并逐步的寻求到终点，寻求得是最短路径，所以可以考虑用最短路径盲目搜索法BFS

     代码如下：

                                      

#include<iostream>
#include<cstring>
#include <queue>
using namespace std;

typedef class
{
	public:
		int l,r,c;	//层 行 列
		int depth;  //树深（分钟）
}SE;

SE s,e;
bool matrix[40][40][40]; //存储3D地牢的矩阵
int shortminute;	//最短时间
int L,R,C;

//一个方向的数组，共有6个方向，分别为上、下、左、右、前、后
int dr[6][3] = {{1,0,0},{0,1,0},{0,0,1},{-1,0,0},{0,-1,0},{0,0,-1}};
bool myBFS(int l, int r, int c){
	bool visited[40][40][40] = {false};
	queue<SE> q;
	SE p;
	p.l = l;
	p.r = r;
	p.c = c;
	p.depth = 1;
	//初始化开始节点
	visited[l][r][c] = true;
	q.push(p);
	while(!q.empty()){
		//取对首节点，但没弹出
		SE temp = q.front();
		//当展开的节点是终点时，寻找截止
		if(temp.l == e.l && temp.r == e.r && temp.c == e.c){
			shortminute = temp.depth;
			e.depth = temp.depth;
			return true;
		}
		int i,j;

		//每个节点有6种可能的方向可以走
		for(i = 0;i < 6;i++){
			int x,y,z;
			
		//	cout<< dr[i][0]<< dr[i][1]<<dr[i][2]<<endl;
			x = dr[i][0] + temp.l;
			y = dr[i][1] + temp.r;
			z = dr[i][2] + temp.c;

		//	cout<<x<<y<<z<<"  "<<L<<R<<C<<endl;
			//查看是否越界
			if(x>0 && x <=L && y>0 && y <= R && z >0 && z <= C){
				//查看是否访问过，并且该点是否是可通过的，即没被阻塞
				if(visited[x][y][z] == false && matrix[x][y][z] ){
					visited[x][y][z] = true;
					SE pu;
					pu.l = x;
					pu.r = y;
					pu.c = z;
					//cout<<x<<y<<z<<"  "<<endl;
					//更新选择的点的深度，从该点展开的所有节点，其深度均加1
					pu.depth = temp.depth + 1;
					//将该点加入到队列的末尾，以便于从该点展开
					q.push(pu);
				}
			}
		}

		//弹出刚才展开的点,对首
		q.pop();
		
		
	}

	return false;
}

int main(int i,int j,int k)
{
	freopen("in.txt","r", stdin);
	while(cin>>L>>R>>C)
	{
		if(!L && !R && !C)
			break;

		//初始化矩阵,为false表示都不能通过

		memset(matrix,false,sizeof(matrix));
		
		/*Structure the matrix*/

		for(k=1;k<=L;k++)
			for(i=1;i<=R;i++)
				for(j=1;j<=C;j++)
				{
					char temp;
					cin>>temp;
					if(temp=='.')
						matrix[k][i][j]=true;
					//当时开始节点时，记录下来
					if(temp=='S')
					{
						matrix[k][i][j]=true;
						s.l=k;
						s.r=i;
						s.c=j;
					}
					//记录结束节点
					if(temp=='E')
					{
						matrix[k][i][j]=true;
						e.l=k;
						e.r=i;
						e.c=j;
					}
				}

	
		if(myBFS(s.l,s.r,s.c))
			cout<<"Escaped in "<<shortminute-1<<" minute(s)."<<endl;
		else
			cout<<"Trapped!"<<endl;

	}
	return 0;
} 

   宽度搜索总结：
      数据结构：一个是存储整个图的矩阵，如int matrix[40][40][40]
               一个记录走过的节点数组，如bool visited[40][40][40]
               一个节点移动的方法或是一个数据结构，这里是一个方向数组，int dr[6][3] = {{1,0,0},{0,1,0},{0,0,1},{-1,0,0},{0,-1,0},{0,0,-1}};
               一个队列，用于将每一个可以走的节点加入队列，以便于从该点进行展开