广度优先搜索(BFS)

广度优先搜索

广度优先搜索：当碰到岔道口时，总是先依次访问从该岔道口能直接到达的所有结点，然后再按这些结点被访问的顺序去依次访问它们能直接到达的所有结点，以此类推，直到所有结点都被访问为止。

广度优先搜索(BFS)一般由队列实现，且总是按层次的顺序进行遍历。

1. 定义队列q，并将起点s入队
2. 写一个while循环，循环条件时队列q非空
3. 在while循环中，先取出队首元素top，然后访问它(访问可以时任何事情，例如将其输出)。访问完后将其出队
4. 将top的下一层结点中所有未曾入队的结点入队，并标记它们的层号为now的层号加1，同时设置这些入队的结点已入过队
5. 返回2继续循环

void BFS(int s)
{
	queue<int> q;
	q.push(s);
	while(!q.empty())
	{
		取出队首元素top;
		访问队首元素top;
		将队首元素出队;
		将top的下一层结点中未曾入队的结点全部入队，并设置为已入队;
	}
}

例题1

给出一个 mxn 的矩阵，矩阵中的元素为0或1。称位置(x, y)与其上下左右四个位置(x, y+1)、(x, y-1)、(x+1, y)、(x-1, y)是相邻的。如果矩阵中有若干个1是相邻的(不必两两相邻)，那么称这些 1 构成了一块“块”。求给定的矩阵中“块”的个数。
0 1 1 1 0 0 1
0 0 1 0 0 0 0
0 0 0 0 1 0 0
0 0 0 1 1 1 0
1 1 1 0 1 0 0
1 1 1 1 0 0 0
例如上面 6x7 的矩阵中，“块”的个数为4。

分析

枚举每一个位置的元素
如果为0，则跳过
如果为1，则使用BFS查询与该位置相邻的4个位置
判断它们是否为1(如果某个相邻的位置为1，则同样去查询与该位置相邻的4个位置，直到整个“1”块访问完毕)。

为了防止走回头路，设置一个bool型数组 inq 来记录每个位置是否在BFS中已入过队

小技巧：对当前位置(x, y)来说，由于与其相邻的四个位置分别为(x, y+1)、(x, y-1)、(x+1, y)、(x-1, y)，那么不妨设置下面两个增量数组，来表示四个方向(0, 1)、(0, -1)、(1, 0)、(-1, 0)

int X[] = {0, 0, 1, -1};
int Y[] = {1, -1, 0, 0};

使用for循环来枚举4个方向，以确定当前坐标(nowX, nowY)相邻的4个位置。

for(int i = 0; i < 4; i++)
{
	newX = nowX + X[i];
	newY = nowY + Y[i];
}

BFS

#include <cstdio>
#include <queue>
using namespace std;
const int maxn = 100;
struct node
{
	int x, y; //位置(x, y)
}Node;

int n, m; //矩阵大小为n*m
int matrix[maxn][maxn]; //01矩阵
bool inq[maxn][maxn] = {false}; //记录位置(x, y)是否已入过队
int X[4] = {0, 0, 1, -1}; //增量数组
int Y[4] = {1, -1, 0, 0};
//判断坐标(x, y)是否需要访问
bool judge(int x, int y)
{
    //越界返回false
	if(x >= n || x < 0 || y >= m || y < 0)
		return false;
    //当前位置为0，或(x, y)已入过队，返回false
	if(matrix[x][y] == 0 || inq[x][y] == true)
		return false;
    //以上都不满足，返回true
	return true;
}
//BFS函数访问位置(x, y)所在的块，将该块中所有“1”的inq都设置为true
void BFS(int x, int y)
{
	queue<node> Q; //定义队列
	Node.x = x, Node.y = y; //当前结点的坐标为(x, y)
	Q.push(Node); //将结点Node入队
	inq[x][y] = true; //设置(x, y)已入队
	while(!Q.empty())
	{
		node top = Q.front(); //取出队首元素
		Q.pop(); //队首元素出队
		for(int i = 0; i < 4; i++) //循环4次，得到4个相邻位置
		{
			int newX = top.x + X[i];
			int newY = top.y + Y[i];
			if(judge(newX, newY)) //如果新位置(newX, newY)需要访问
			{
			    //设置Node的坐标为(newX, newY)
				Node.x = newX, Node.y = newY;
				Q.push(Node); //将结点Node加入队列
				inq[newX][newY] = true; //设置位置(newX, newY)已入过队
			}
		}
	}
}

int main()
{
	scanf("%d%d", &n, &m);
	for(int x = 0; x < n; x++)
	{
		for(int y = 0; y < m; y++)
		{
			scanf("%d", &matrix[x][y]); //读入01矩阵
		}
	}
	int ans = 0; //存放块数
	for(int x = 0; x < n; x++) //枚举每一个位置
	{
		for(int y = 0; y < m; y++)
		{
		    //如果元素为1，且未入过队
			if(matrix[x][y] == 1 && inq[x][y] == false)
			{
				ans++; //块数加1
				BFS(x, y); //访问整个块，将该块所有“1”的inq都标记为true
			}
		}
	}
	printf("%d\n", ans);
	return 0;
}

例题2

给定一个n*m大小的迷宫，其中 * 代表不可通过的墙壁，而 . 代表平地,S表示起点，T代表终点。移动过程中，如果当前位置是(x, y)(下标从0开始)，且每次只能前往上下左右(x, y+1)、(x, y-1)、(x-1, y)、(x+1, y)四个位置的平地，求从起点S到达终点T的最少步数。

在上面的样例中，S的坐标为(2, 2)，T的坐标为(4, 3)

分析

由于求最少步数，而BFS是通过层次的顺序来遍历的，因此可以从起点S开始计数遍历的层数，那么在到达终点T时的层数就是需要求解的起点S到达终点T的最少步数。

#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;
const int maxn = 100;
struct node
{
	int x, y; //位置(x, y)
	int step; //step为从起点S到达该位置的最少步数(即层数)
}S, T, Node; //S为起点，T为终点，Node为临时结点

int n, m; //n为行，m为列
char maze[maxn][maxn]; //迷宫信息
bool inq[maxn][maxn] = {false}; //记录位置(x, y)是否已入过队
int X[4] = {0, 0, 1, -1}; //增量数组
int Y[4] = {1, -1, 0, 0};
//检测位置(x, y)是否有效
bool test(int x, int y)
{
	if(x >= n || x < 0 || y >= m || y < 0)
		return false; //超过边界
	if(maze[x][y] == '*')
		return false; //墙壁*
	if(inq[x][y] == true)
		return false; //已入过队
	return true; //有效位置
}

int BFS()
{
	queue<node> q; //定义队列
	q.push(S); //将起点S入队
	while(!q.empty())
	{
		node top = q.front(); //取出队首元素
		q.pop(); //队首元素出队
		if(top.x == T.x && top.y == T.y)
		{
			return top.step; //终点，直接返回最少步数
		}
		for(int i = 0; i < 4; i++) //循环4次，得到4个相邻位置
		{
			int newX = top.x + X[i];
			int newY = top.y + Y[i];
			if(test(newX, newY)) //位置(newX, newY)有效
			{
				//设置Node的坐标为(newX, newY)
				Node.x = newX, Node.y = newY;
				Node.step = top.step + 1; //Node层数为top的层数加1
				q.push(Node); //将结点Node加入队列
				inq[newX][newY] = true; //设置位置(newX, newY)已入过队
			}
		}
	}
	return -1; //无法到达终点T返回-1
}

int main()
{
	scanf("%d%d", &n, &m);
	for(int i = 0; i < n; i++)
	{
		getchar(); //过滤掉每行后面的换行符
		for(int j = 0; j < m; j++)
		{
			maze[i][j] = getchar();
		}
		maze[i][m + 1] = '\0';
	}
	scanf("%d%d%d%d", &S.x, &S.y, &T.x, &T.y); //起点和终点的坐标
	S.step = 0; //初始化起点的层数为0，即S到S的最少步数为0
	printf("%d\n", BFS());
	return 0;
}

//输入数据
5 5 //5行5列
..... //迷宫信息
.*.*.
.*S*.
.***.
...T*
2 2 4 3 //起点S的坐标与终点T的坐标

11 //输出数据

在BFS中设置的inq数组的含义是判断结点是否已入过队，而不是结点是否已被访问。
区别：如果设置成是否被访问，有可能在某个结点正在队列中(但还未访问)时由于其他结点可以到达它而将这个结点再次入队，导致很多结点反复入队，计算量增加。
因此BFS中让每个结点只入队一次，则需要设置inq数组的含义为结点是否已入队。