bfs广度优先搜索（插入知识点利用C++标准库中的队列模板、C++值STL库的pair用法）

BFS（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和广度优先搜索类似的思想。属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。

·bfs是一层一层的往下搜的，这也是与dfs的不同之处，相比与dfs它是用队列搜的。

·应用：

1.最短路问题（前提是所有边权重都相同）

2.寻找其中一个连通分支中的所有节点。（扩散性）

3.bfs染色法判断是否为二分图。

·bfs一般都有一个常用框架：

①插入一个知识点，之前在上篇博客里是用数组模拟队列的，详情见http://t.csdn.cn/DFw8r

这里用C++标准模板库中提供的队列模板来做，其头文件#include<queue>。C++中直接构造了一个queue语句：queue<T> q；  即定义了名为q、存储类型变量为T的队列（初始时q为空，T可以是int、double、string或者自定义类型 ）

1.入队，通过push()在队尾插入一个新的元素

q.push(1);
q.push(2); //此时q为 1 2

2.获得队首元素，用front()

q.push(1);
cout<<q.front()<<endl; //输出结果为1
q.push(2); //此时q为 1 2
cout<<q.front()<<endl;  //输出结果为1

3.出队，pop()，让队首元素弹出

q.push(1);
cout<<q.front()<<endl; //输出结果为1
q.push(2); //此时q为 1 2
q.pop();//1出队
cout<<q.front()<<endl;//输出结果为2

4.判断队列是否为空，用empty()，如果为空，则返回true；否则返回false

（这个的意义就是我们每次调用front()和pop()之前，都要检查一下，保证队列不为空，否则在去访问队列首部或者让其出队时若是空队列，则会发生错误）

可以用循环去清空队列（队列无clear方法）

while(!q.empty())
{
	q.pop();
}

下面用两道题以不同方法来具体展示

例1：

给定一个 N×M 的网格迷宫 G。G 的每个格子要么是道路，要么是障碍物（道路用 . 表示，障碍物用 * 表示）已知迷宫的入口位置为 设为S，出口位置为 T。问从入口走到出口，最少要走多少个格子。

     先存图，用结构体构造函数记录当前状态（位置和走的步数）；在移动时只能往上下左右移动，这里用二维数组记录dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};，对于判断是否越界问题，下面用了bool函数去判断，学到了。

下面代码可以带你体会道结构体构造函数的方便之处

代码如下:

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

int n,m;   // 迷宫的行数和列数
string maze[100];   // 存储迷宫的二维数组
bool vis[100][100];   // 标记迷宫中的位置是否已经访问过
int dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};   // 定义四个方向上的移动差
				//x-1左移，x+1右移，y—1上移，y+1下移

bool in(int x,int y){   // 判断位置 (x,y) 是否在迷宫范围内，防止越界
	return 0<=x&&x<n&&0<=y&&y<m;
}

// 定义一个结构体，用来表示迷宫中当前位置和距离起点的步数
struct node{
	int x,y,d;   // 位置坐标 (x,y) 和距离起点的步数 d
	node(int xx,int yy,int  dd){
		x=xx;
		y=yy;
		d=dd;
	}
};

//bfs搜
int bfs(int sx,int sy)
{
	queue<node> q;  // 队列，用于存放待扩展的节点
	q.push(node(sx,sy,0));   // 将起点入队
	vis[sx][sy]=true;   // 标记起点为已访问
	
	while(!q.empty())  // 当队列不为空时，继续搜索，为空时即表示全部搜完
	{
		node now=q.front();   // 先取出队列的头节点存一下，下面会用，再出队
		q.pop(); 
		
		for(int i=0;i<4;i++)  // 遍历四个方向上的相邻节点，上下左右
		{
			int tx=now.x+dir[i][0];   // 往下走的点，左 or 右
			int ty=now.y+dir[i][1];  //上 or 下
			if(in(tx,ty)&&maze[tx][ty]!='*'&&!vis[tx][ty])   // 判断相邻点能不能走通且未被访问过
			{
				if(maze[tx][ty]=='T')  // 如果找到终点，返回当前步数加一
				{
					return now.d+1;
				}
				else 
				{
					vis[tx][ty]=true;   // 标记相邻节点为已访问
					q.push(node(tx,ty,now.d+1));   // 将相邻节点入队，并更新步数
				}
			}
		}
	}
	
	return -1;   // 如果没有找到终点，则返回 -1 表示无法从起点走到终点
}

int main()
{
	cin>>n>>m;  // 输入迷宫的行数和列数
	
	for(int i=0;i<n;i++)
	{
		cin>>maze[i];  // 输入迷宫的每一行
	}
	
	int x,y;
	for(int i=0;i<n;i++)   // 找到起点位置 'S' 的坐标
	{
		for(int j=0;j<m;j++)
		{
			if(maze[i][j]=='S')
				x=i,y=j;
		}
	}
	
	cout<<bfs(x,y)<<endl; 
	
	return 0;
}

text： 

       ——————————————————————————————————————

例2：

相比例1，这里用C++STL（标准模板库）中的pair容器存队列，再用数组模拟

②插入一个知识点  pair的对组创建

pair功能：pair是将2个数据组合成一个数据，可以用与成对出现的数据，如STL中的map就是将key和value放在一起来保存。另一个应用是，当一个函数需要返回2个数据的时候，可以选择利用pair对组返回两个数据。

·pair的实现是一种结构体，主要的两个成员变量是first, second 因为是使用struct不是class，所以可以直接使用pair的成员变量。

·其标准库类型pair类型的头文件为#include <utility>

语法（有两种创建方式）：pair<type,type> p(value1,value2);

                                           pair<type,type> p = make_pair(value1,value2);

(尖括号里指定两个数据类型，其值可以分别用pair中的两个公有函数first，second访问)

#include<iostream>
#include<string>
using namespace std;

void test()
{
	pair<string,int> p("xiaoming",10);
	
	cout<<"name: "<<p.first<<" age:  "<<p.second<<endl;
	
	pair<string,int> p2=make_pair("xiaohong",9);
	
	cout<<"name: "<<p.first<<" age:  "<<p.second<<endl;
}

int main()
{
	test();
	return 0;
}

test：

 好了，进入正题，由下面的题解代码细细体会pair的妙处吧，对于下面代码中Prve[x][y]=t; 不懂的可以看下图，存前驱节点的

 

 

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

typedef pair<int, int> PII;

const int N=110;

int m,n;
int g[N][N];  //存图
int d[N][N];  //用来标记判断是否走过该位置，走过就更新 (d其实就是记录第进步)
PII q[N*N] ,Prve[N][N];  //队列，搜（x，y）

int bfs()
{
	int hh=0,tt=0;
	q[0]={0,0}; //初始化
	
	memset(d,-1,sizeof(d));  //初始化为-1，用来标记判断是否走过该位置，-1为未走过
	d[0][0]=0; 
	
	int dx[4]={-1,0,1,0}, dy[4]={0,1,0,-1};  //记录上下左右四个方向的位置
	
	while(hh<=tt)   //判断队列是否为空，为空时就全部搜完了
	{
		auto t=q[hh++];  //这个表示取出队头，存t中，然后hh++往后移一位，相当于弹出队头
		
		for(int i=0;i<4;i++)  //遍历四个方向
		{
			int x=t.first+dx[i], y=t.second+dy[i]; //从（0，0）点开始走
			
			if(x>=0&&x<n&&y>=0&&y<m&&g[x][y]==0&&d[x][y]==-1)  //直接判断是否越界、能不能走通且未被标记
			{
				d[x][y]=d[t.first][t.second]+1;  //若可以，则更新d[x][y](d其实就是记录第进步or层)
				
				Prve[x][y]=t; //  用来记录每个节点的前驱节点，用于路径回溯
				
				q[++tt]={x,y};  //在队尾插入元素 
				
			}
		}
	}
	
	//初始化未终点，从终点开始回溯到起点  这里的循环是列出路径，更清晰
	int x=n-1,y=m-1;  
	
	while(x||y)  //x或y不是0时，即还未到起点
	{
		cout<<x<<' '<<y<<endl;
		auto t=Prve[x][y];
		x=t.first, y=t.second; //往前查
	}
	
	return d[n-1][m-1];  //返回最短路径
	
}

int main()
{
	cin>>n>>m;
	
	for(int i=0;i<n;i++)  //存图
		for(int j=0;j<m;j++)
			cin>>g[i][j];
	
	cout<<bfs()<<endl;
	return 0;
}

text：

 关于bfs的学习就到这里了，楼主小白选手，有什么错误欢迎指出。