广度优先

广度优先BFS

核心思想：
一般是用队列实现，这里要记录路径，队列不能用STL的queue或deque，要自己写。用一维数组实现，维护一个 队头指针和队尾指针。
而bfs是是一层层展开（用head控制），比如说从第一个数0开始搜，然后把和0直接连接的数比如1，2，3都搜出来，加入队列，然后再把和1直接连接的搜出来，比如4，加入队列；然后再搜和2直接连接的，依次往下.简单的说就是一层一层的搜，每一条路径的搜索进度都是一样的（所以可以保证找到了就是最短的），因此需要用到队列的知识，不需要使用递归.

因此dfs适合那些求可行性路径数目的，而bfs适合求最短路径之类的（因为一旦搜到，就是最短）.

总时间限制:
1000ms
内存限制:
65536kB

描述

定义一个二维数组： 

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 <vector>
#include <cstring>
using namespace std;
struct Pos
{
	int r,c;
	int father;
	Pos(int rr=0,int cc=0,int ff=0):r(rr),c(cc),father(ff) { }
};

int maze[8][8];
Pos que[100];
int head,tail;
Pos dir[4] = {Pos(-1,0),Pos(1,0),Pos(0,-1),Pos(0,1)}; //移动方向
int main()
{
	memset(maze,0xff,sizeof(maze));
	for( int i = 1;i <= 5; ++i)
		for (int j = 1; j <= 5; ++j )
			cin >> maze[i][j];
	head = 0; //代表遍历的层数
	tail = 1;
	que[0] = Pos(1,1,-1);

	while( head != tail ) {
		Pos ps = que[head];//存放每一层的元素
		if( ps.r == 5 && ps.c == 5 ) {
			vector<Pos> vt;
			while(true) {
				vt.push_back(Pos(ps.r,ps.c,0));
				if( ps.father == -1 )
					break;
				ps = que[ps.father];
			};
			for( int i = vt.size()-1; i >= 0; -- i )
				cout << "(" << vt[i].r -1 << ", " << vt[i].c-1 << ")" << endl;
			return 0;
		}



		else {
			int r = ps.r, c = ps.c;
			for( int i = 0;i < 4; ++i)
				if(! maze[r+dir[i].r][c+dir[i].c]) {
					que[tail++] = Pos(r+dir[i].r,c+dir[i].c,head);
					maze[r+dir[i].r][c+dir[i].c] = 1;
				}
			++head;
		}
	}
	return 0;
}