迷宫问题(bfs)

定义一个二维数组：

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)

# include<iostream>
# include<queue>
# include<cstring>
# include<vector>
using namespace std;
int maze[5][5];
struct point{
	int r;   //行 
	int c;   //列
	point(int rr,int cc)
	{
		r=rr;
		c=cc;
	 } 
	 point()
	 {
	 	
	 }
};
int dr[]={0,-1,0,1};
int dc[]={1,0,-1,0}; 
int dis[5][5];
point pre[5][5];
point walk(point u,int i)
{
	return point(u.r+dr[i],u.c+dc[i]);
}
bool isleagle(point ss)
{
	return ss.r>=0&&ss.r<5&&ss.c<5&&ss.c>=0;
}
/*void print(point u,point v)   //从v->u的最短路径 
{
	if(u.r==v.r&&u.c==v.c)
	{
		cout<<"("<<u.r<<", "<<u.c<<")"<<endl;
	}
	else 
	   {
           print(pre[u.r][u.c],v);
		   cout<<"("<<u.r<<", "<<u.c<<")"<<endl;	       	
		   }
	
}*/

//非递归输出从u到v的最短路径 
void print(point v,point u)   //从目标点逆序追溯到初始节点 
{
	vector<point> ss;
	for(;;)
	{
		ss.push_back(v);
		if(dis[v.r][v.c]==0)
		   break;
		v=pre[v.r][v.c];
	}
	
	
	for(int i=ss.size()-1;i>=0;i--)
	{
	  	cout<<"("<<ss[i].r<<", "<<ss[i].c<<")"<<endl;  	
	  }
	
}
void bfs(point ww)
{
     queue<point> q;	
	memset(dis,-1,sizeof(dis));    //初始化距离，且用于表示为访问的点 即dis[u][v]<0表示点(u,v)未访问 
	dis[ww.r][ww.c]=0;//初始节点距离为0;
	q.push(ww);
	while(!q.empty())
	{
		point u=q.front();q.pop();
		if(u.c==4&&u.r==4)
		{
			print(u,ww);
			return ;
		}
		for(int i=0;i<4;i++)
	   	{
	   		point v=walk(u,i);
	   		if(dis[v.r][v.c]<0&&isleagle(v)&&!maze[v.r][v.c])
	   		{
	   			dis[v.r][v.c]=dis[u.r][u.c]+1;
	   			pre[v.r][v.c]=u;
	   			q.push(v);
			   }
			 }  
	}	
}
int main()
{
	point ww(0,0);
	for(int i=0;i<5;i++)
	  for(int j=0;j<5;j++)
	     cin>>maze[i][j];
	bfs(ww);
	return 0;
 }

总结
（1）bfs需要构建广度优先搜索树，构建出广度优先搜索树，再去遍历广度优先搜索树，从而解决问题.