C++算法之广度优先搜索算法

最新推荐文章于 2024-05-21 17:20:05 发布

冰焰狼

最新推荐文章于 2024-05-21 17:20:05 发布

阅读量1.9k

点赞数 17

分类专栏： C++算法文章标签：数学建模算法 c++

本文链接：https://blog.csdn.net/weixin_57347115/article/details/131254480

版权

C++算法专栏收录该内容

8 篇文章 5 订阅

订阅专栏

广度优先搜索算法是一种常见的图搜索算法，可以用于解决很多实际问题，如寻找最短路径、迷宫问题等。下面会介绍广度优先搜索算法。

1.结构

program bfs;
初始化；建立队列 data;
设队列首指针 closed:=0;队列尾指针 open:=1;
repeat
closed 增1，取出 closed 所指结点进行扩展；
  for i:=1 to r do begin
    if 子结点符合条件 then begin 
open 增1，并把新结点存入数据库队尾；
if 新结点与原有结点有重复 then 删于该结点(open 减1)
else if 新结点即目标 then 输出并退出 ;
    end{if};
  end{for};
until closed>=open;{队列为空}

2.算法解释

2.1 运行步骤解释

定义一个队列，用来存储需要搜索的节点。
将起点放入队列中，并标记为已访问。
取出队列头部元素，即当前需要搜索的节点。
遍历当前节点的所有邻居节点。如果该邻居节点未被访问，则将该邻居节点加入队列，并标记为已访问。
重复执行步骤3和步骤4，直到队列为空为止。

在实现广度优先搜索算法时，需要用到一个二维数组来表示图的邻接矩阵，以便快速查找两个节点之间是否有边相连。同时，可以为每个节点维护一个“距离”值，表示当前节点到起点的最短距离，每次遍历邻居节点时，可以根据当前节点的距离值来计算邻居节点的距离值。

2.2 例

下面是一个简单的C++实现，用于寻找从起点到终点的最短路径：

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

int main() {
    // 定义二维数组表示邻接矩阵
    int graph[6][6] = {
        {0, 1, 1, 0, 0, 0},
        {1, 0, 0, 1, 1, 0},
        {1, 0, 0, 0, 1, 1},
        {0, 1, 0, 0, 0, 1},
        {0, 1, 1, 0, 0, 1},
        {0, 0, 1, 1, 1, 0}
    };
    // 定义起点和终点
    int start = 0, end = 5;
    // 定义队列存储需要搜索的节点
    queue<int> q;
    // 定义一个数组标记每个节点是否已经被访问过
    bool visited[6] = {false};
    // 定义一个数组记录每个节点到起点的最短距离
    int distance[6] = {0};
    // 将起点放入队列中，并标记为已访问
    q.push(start);
    visited[start] = true;
    // 不断取出队列头部元素进行搜索
    while (!q.empty()) {
        int curr = q.front();
        q.pop();
        // 遍历当前节点的所有邻居节点
        for (int i = 0; i < 6; i++) {
            if (graph[curr][i] == 1 && !visited[i]) {
                // 如果该邻居节点未被访问，则将该节点加入队列，并标记为已访问
                q.push(i);
                visited[i] = true;
                // 计算该邻居节点的距离值
                distance[i] = distance[curr] + 1;
            }
        }
    }
    // 输出起点到终点的最短距离
    cout << "The shortest distance from " << start << " to " << end << " is " << distance[end] << endl;
    return 0;
}

在上面的代码中，我们假设有一个6个节点的图，邻接矩阵表示为一个6x6的二维数组。其中，元素为1表示该节点与相应的节点有边相连，元素为0则表示没有边相连。起点为0，终点为5。我们使用了一个队列来存储需要搜索的节点，并使用了一个数组来标记每个节点是否已经被访问过。同时，我们还定义了一个数组来记录每个节点到起点的最短距离。在每次遍历邻居节点时，我们根据当前节点的距离值来计算邻居节点的距离值。最后，输出起点到终点的最短距离。

**需要注意的是：上面的示例代码只适用于无权图的情况。如果图中存在边权值，则需要使用Dijkstra算法或者A*算法等更高级的算法来寻找最短路径。**

3.例题

细胞

【题目描述】

一矩形阵列由数字00到99组成,数字11到99代表细胞,细胞的定义为沿细胞数字上下左右还是细胞数字则为同一细胞,求给定矩形阵列的细胞个数。如:

阵列

4 10
0234500067
1034560500
2045600671
0000000089

有44个细胞。

【输入】

第一行为矩阵的行n和列m;

下面为一个n×m的矩阵。

【输出】

细胞个数。

【输入样例】

4 10
0234500067
1034560500
2045600671
0000000089

【输出样例】

4

【题目来源】

信息学奥赛一本通（C++版）在线评测系统

设数组vis，vis[i][j]表示(i,j)位置已经访问过。
遍历地图中的每个位置，尝试从每个位置开始进行搜索。
如果该位置不是0且没有访问过，那么访问该位置，并尝试从其上下左右四个位置开始搜索。
在看一个新的位置时，如果该位置在地图内，没有访问过且不是0，那么继续从该位置开始进行搜索。
在遍历网格的过程中，一次成功开始的搜索可以确定一个连通块，统计连通块的个数，即为结果。
搜索方法可以采用深搜或广搜。

#include<bits/stdc++.h>
using namespace std;
#define N 105
struct Node
{
	int x, y;
	Node(){}
	Node(int a, int b):x(a),y(b){}
};
int n, m, ct, dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};//dir：方向数组 
char mp[N][N];//地图 
bool vis[N][N];//vis[i][j]:(i,j) 位置是否已访问过 
void bfs(int sx, int sy)//尝试从(sx,sy)位置开始进行广搜 
{
	queue<Node> que;
	vis[sx][sy] = true;
	que.push(Node(sx, sy));
	while(que.empty() == false)
	{
		Node u = que.front();
		que.pop();
		for(int i = 0; i < 4; ++i)//遍历上下左右四个方向
		{
			int x = u.x + dir[i][0], y = u.y + dir[i][1];//新位置(x,y) 
			if(x >= 1 && x <= n && y >= 1 && y <= m && vis[x][y] == false && mp[x][y] != '0')
			{
				vis[x][y] = true;//访问(x,y)位置 
				que.push(Node(x, y));//(x,y)入队 
			}
		}
	}

}
int main()
{
	cin >> n >> m;
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= m; ++j)
			cin >> mp[i][j];
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= m; ++j)
		{//尝试从每个位置开始进行广搜 
			if(vis[i][j] == false && mp[i][j] != '0')
			{
				bfs(i, j);
				ct++;
			}
		}
	cout << ct;
	return 0;
}

创作不易，白嫖不好，各位的支持和认可，就是我创作的最大动力，如果喜欢我的文章，给个关注吧！

冰焰狼 | 文

如果本篇博客有任何错误，请批评指教，不胜感激！