广度优先搜索（C++代码实现）

广度优先搜索（C++代码实现）

题目问题，请参照我的上一篇文章（深度优先搜索）。

思考一下，上次的深度优先搜索是从起点开始顺时针的顺序进行方向选择下一个路径点；那么这次的广度优先搜索，顾名思义，就是这个点可以移动到的下一步位置的所有点都进行测试，再以这些点为路径的头点，进行下一个点的搜索…

代码如下（含注释）

#include<iostream>
using namespace std;
struct note {
	int x;//X坐标
	int y;//Y坐标
	int s;//步数
};

int main() {
	//定义队列，路径，50*50，最多不超过2500
	struct note que[2501];
	//a用来记录地图，0可以行走，1表示有障碍；book用来记录走过的路径点，防止走重复的路径
	int a[51][51] = { 0 }, book[51][51] = { 0 };
	//定义一个游走方向的数组，方便方向的改变
	int next[4][2] = {
		{0,1},//向右
		{1,0},//向下
		{0,-1},//向左
		{-1,0}//向上
	};
	//定义查找的路径上的头尾
	int head, tail;
	//startX,startY为路径起点坐标；p,q为目的地坐标；tx,ty为走的过程中的坐标；flag用来标记是否到达目的地
	int i, j, k, n, m, startX, startY, p, q, tx, ty, flag;
	cin >> n >> m;
	for (i = 1; i <= n; i++) {
		for (j = 1; j <= m; j++) {
			cin >> a[i][j];
		}
	}
	cin >> startX >> startY >> p >> q;
	//初始化队列
	head = 1;
	tail = 1;
	//往队列插入迷宫入口的坐标
	que[tail].x = startX;
	que[tail].y = startY;
	que[tail].s = 0;
	tail++;
	book[startX][startY] = 1;

	flag = 0;
	//队列不为空的时候循环
	while (head < tail) {
		//枚举四个方向
		for (k = 0; k <= 3; k++) {
			//计算下一个点的坐标
			tx = que[head].x + next[k][0];
			ty = que[head].y + next[k][1];
			//判断是否越界
			if (tx<1 || ty<1 || tx>n || ty>m) {
				continue;
			}
			//判断障碍物和路径是否走过
			if (a[tx][ty] == 0 && book[tx][ty] == 0) {
				//此点可以走，那么久标记此点走过
				book[tx][ty] = 1;
				//插入tx,ty这个新点到队列中
				que[tail].x = tx;
				que[tail].y = ty;
				que[tail].s = que[head].s + 1;
				tail++;
			}
			//如果到目的地，停止扩展，任务结束，退出循环
			if (tx == p && ty == q) {
				flag = 1;
				break;
			}
		}
		if (flag == 1) {
			break;
		}
		//当一个点扩展结束后，head++继续对后面的点扩展
		head++;
	}
	cout << que[tail - 1].s;
	return 0;
}

本博客原发布于：2020-08-30 09:08:17
以下为数据结构章节补充：

BFS过程：
从起点出发，把起点相连的节点全部搜索完，再遍历起点第一个搜索的点，重复往后，直到没路，或者路的后续节点已经搜索过，此时往回退到这个节点的下一个遍历节点进行再继续搜索。。。。fuck,形容不好了，代码解释吧还是。。。
关键代码如下：（python）
由于这个回退是，比如说：A到B，A到C，那么遍历完B后，就遍历C。这个是按正序，所以用队列辅助一下最合适。
像之前的DFS其实也可以使用栈辅助，我的DFS博客写的是用递归，都一样。

def BFS(myMap, begin):#myMap:图, s:开始结点
    queue=[] #定义一个队列
    queue.append(begin) #起点入队列
    seen=set()#记录访问结点
    seen.add(begin) #起点被访问
    while (len(queue)>0): #当队列空的时候，就是搜索完的时候
        v = queue.pop(0) #获取队列的首个，也就相当于层序遍历二叉树
        nodes=myMap[v]#V节点能到的节点数组
        for w in nodes:
            if w not in seen:#判断是否访问过，使用一个数组
                queue.append(w) #入队列，开始排队等着遍历
                seen.add(w) #W被搜索，记录一下
        print(v) #V被遍历过，输出。

可测试代码：

myMap={
    'A':['B','C','D'],
    'B':['A','E'],
    'C':['A','D','F'],
    'D':['A','C','E'],
    'E':['B','D','F'],
    'F':['C','E']
}
def BFS(myMap, begin):#myMap:图, s:开始结点
    queue=[] #定义一个队列
    queue.append(begin) #起点入队列
    seen=set()#记录访问结点
    seen.add(begin) #起点被访问
    while (len(queue)>0): #当队列空的时候，就是搜索完的时候
        v = queue.pop(0) #获取队列的首个，也就相当于层序遍历二叉树
        nodes=myMap[v]#V节点能到的节点数组
        for w in nodes:
            if w not in seen:#判断是否访问过，使用一个数组
                queue.append(w) #入队列，开始排队等着遍历
                seen.add(w) #W被搜索，记录一下
        print(v) #V被遍历过，输出。
print(BFS(myMap,'A'))

测试截图：