广度优先搜索算法详解

说到广度优先搜索，大家可能先想到的是广度优先遍历，其实广度优先搜索就是利用了广度优先遍历的一种搜索算法。我个人总结的该算法包含以下几个关键点，掌握了这几个点，该算法也就掌握的很好了。下面也基本上是围绕这几个关键点展开的。

1.状态

2.状态转移方式 

3.有效状态

4.队列

5.标记

我们先来看看一点有意思的吧！

说有一天公主被大魔王抓了，关进了一个迷宫里，需要你这位勇士去营救（当然成功了就自然是升职加薪赢取白富美啦），这个迷宫以二维数组的形式给出（暂定为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表示这里可以走，1表示这里是堵墙不能走，每次只能往上下左右四个方向走一个单位，迷宫入口为左上角，而公主在最右下角，问你是否能找到一条最短的路径成功救出公主，如果能输出其路径（每一个路径以坐标形式给出，如（0,0）），不能输出-1。

当看到什么最短时间啦，最短路径啦（当然不是图那种最短路径），这就适合用广度优先遍历。广度优先遍历其实是对状态的一种遍历，这里就要搞清楚什么是状态。我们先自己想一下，你看到这道题会有什么样的想法，从第一个点出发，可以往右、下走，然后如果往右走，又会延伸出往右、下走，我们用一棵树来表示（（1,2,3）表示x=1,y=2,路径长度也可以叫时间为3）

                               

这里我们便可以看到一个点加上一个时间t便构成了一个所谓的状态，而我们广度优先搜素就是要按层，一层一层地搜索这些状态，直到找到要求状态为止。上面的图我们还应该修改修改，因为，第二次到达的点所需要的时间肯定比第一次到达所需要的时间多，如上图的（0,0,3），所以，我们设置一个标记，凡是我们到达过的点，便不进行第二次的搜索与延伸，此之谓剪枝，这样一来状态的总数便等于A*B（A为总行数，B为总列数），只要这个时间复杂度在我们的接受范围之内，我们便可以采用广度优先搜索。

状态转移呢，是指由一个状态可以延伸出其他哪些状态，也就是可以往哪些地方走的问题。

说了这么多，是时候上点干货了，我们看看代码

#include<iostream>
#include<queue>
#include<stack>
using namespace std;
int migong[5][5];//保存迷宫图
bool flag[5][5];//标记改点是否到达过
class Stat
{
	public:
		int x,y;
		int t;
		Stat* father;//指向其父状态，用于逆向寻找路径
};
int R[4][2]={
	-1,0,
	1,0,
	0,-1,
	0,1
};//用于状态扩展
Stat* BFS()//返回终点状态
{
	 queue<Stat*> Q;//用于存储还没有被扩展的（即将扩展）状态
	 int x=0,y=0,t=0;
	 Stat* start = new Stat();//这里是我栽过大坑，由于是在函数内部定义的对象，必须要用new来分配内存与堆中
	 start->x=start->y=0;
	 start->t = 0;
	 start->father = NULL;//开始状态没有父状态
	 Q.push(start);
	 while(Q.empty() == false)//直到搜索完所有状态退出循环
	 {
 		Stat* temp = Q.front();
 		Q.pop();
 		for(int i=0;i<4;i++)//这里就是状态的扩展，向上下左右四个方向扩展
 		{
		 	x = temp->x+R[i][0];
 			y = temp->y+R[i][1];	
 			if(x<0||y<0||x>4||y>4)//超出边界，便直接舍弃该状态
 				continue;
			if(flag[x][y] == true)//到达过该状态，也直接舍弃
				continue;
			if(migong[x][y] == 1)//没有路，也直接舍弃
				continue;
			Stat* tempS = new Stat();//创建新状态
			tempS->x = x;
			tempS->y = y;
			tempS->t = temp->t+1;//时间加一
			tempS->father = temp;//指向父节点
			if(x == 4 && y == 4)//如果搜索到了目标状态，便返回
			{
				return tempS;
			}
			Q.push(tempS);//将新状态加入队列中
			flag[x][y] = true;//标记该状态已经到达过	
	 	}
 	}
 	return start;
}

int main()
{
	for(int i=0;i<5;i++)//循环输入迷宫
	{
		for(int j=0;j<5;j++)
		{
			cin>>migong[i][j];
			flag[i][j] = false;
		}
	}
	Stat* p = BFS();
	stack<Stat*> S;//放入栈中，主要是为了让其反序，不然从目标状态找其父节点遍历的话，是反的
	while(p != NULL)
	{
		S.push(p);
		p = p->father;	
	}
	while(S.empty() == false)
	{
		Stat* temp = S.top();
		S.pop();
		cout<<"("<<temp->x<<","<<temp->y<<")"<<endl;
	}
}
/*
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
*/

相信大家看了代码，也就大概了解的八九不离十了，但这里需要强调的是这里面队列的作用，主要是利用了队列的先进先出的特性，当一个状态向4个方向扩展时，依次将其放入队列中，再由这四个状态继续扩展，这样队列状态的取出便是按照层次的顺序，一层一层地遍历的，这才是广度优先搜索的的关键。

我们来看看结果

                                             

最后，大家一定要记住我踩过的坑（在函数内定义对象时，如果在以后还要用到的话，一定要用new关键字分配内存于堆中）

ps: 这是我第一次写博客，诸多问题，还请大家指出，海涵。