宽度优先搜索（BFS）

最新推荐文章于 2024-08-27 20:36:19 发布
最新推荐文章于 2024-08-27 20:36:19 发布
阅读量697 收藏 2
点赞数 1
文章标签： 数据结构 bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57587757/article/details/120815472
版权
本文介绍了队列的特点和常用操作，并通过二叉树的层次遍历和图的广度优先搜索(BFS)问题，展示了队列在算法中的应用。在层次遍历中，使用队列实现先进先出的原则，逐层访问二叉树节点。在BFS问题中，队列用于存储状态，逐步探索所有可能的状态，直至找到目标状态。同时，文章提供了具体的C++代码示例，解释了如何在实际问题中实现BFS算法。
摘要由CSDN通过智能技术生成

预备知识

队列

特点：

1、先进先出（FIFO）

2、从队头删除元素

3、在队尾加入元素

常见操作

1）判断队列是否为空

2）查询队列大小

3）访问队首元素

4）访问队尾元素

5）加入元素

6）删除元素

STL中队列的基本用法

1）创建队列对象：queue<元素类型>队列名；

2）队列添加元素：队列名.push(元素名)；

3）去掉队首元素：队列名.pop()；

4）访问队首元素：队列名.front()；

5）访问队尾元素：队列名.back()；

6）判断是否为空：队列名.empty()；

7）返回队列大小：队列名.size()；

现在来看BFS，首先看一个例题。

二叉树的层次遍历。

很显然层次遍历的结果为：5 1 7 2 4 6 3.

那么我们如何通过代码实现呢？

算法思想：

维护一个队列，用于存放结点的信息。当访问到一个结点的时候，先访问该结点，然后将该结点的左右儿子分别入队列。

伪代码：

ccbl(int root)

        queue<int>Q；创建一个队列

        Q.push(root)；将根结点入队列

        while(队列不为空){
                获得队首元素

                将队首元素出队

                输出当前结点的值

                如果该结点的左儿子不为空，将左儿子加入到队列中

                如果该结点的右儿子不为空，将右儿子加入到队列中

        }

图的BFS示意图

我们再看一个例题:

题目链接：Problem - 1548 (hdu.edu.cn)

问题描述：

Sample Input

5 1 5

3 3 1 2 5

0

Sample Output

3 

解题代码

#include<bits/stdc++.h>
using namespace std;

int N,Start,End;
int a[202];
int vis[202]; // 标记数组 
struct pos
{
	int level;
	int steps; 
};
void bfs(); // 函数原型声明

int main()
{
	while(scanf("%d",&N)==1)
	{
		if(N==0)
			break;
		scanf("%d%d",&Start,&End);
		for(int i=1;i<=N;i++)
		{
			scanf("%d",&a[i]);
			vis[i]=0;
		}
		bfs();
	}
	return 0;
}

void bfs()
{
	pos cur,nex;
	cur.level=Start;
	cur.steps=0;
	queue<pos>qu;
	qu.push(cur);
	vis[Start]=1;
	while(!qu.empty())
	{
		cur=qu.front();
		qu.pop();
		if(cur.level == End)
		{
			printf("%d\n",cur.steps);
			return;
		}
		nex.level=cur.level+a[cur.level];
		nex.steps=cur.steps+1;
		if(nex.level <= N)
		{
			if(vis[nex.level]==0)
			{
				vis[nex.level]=1;
				qu.push(nex);
			}
		}
		nex.level=cur.level-a[cur.level];
		nex.steps=cur.steps+1;
		if(nex.level>=1)
		{
			if(vis[nex.level]==0)
			{
				vis[nex.level]=1;
				qu.push(nex);
			}
		}
	}

	printf("-1\n");
	return;
}

运行结果 

下面我们再来看一道例题：

题目链接：Problem - 1495 (hdu.edu.cn)

Problem Description

大家一定觉的运动以后喝可乐是一件很惬意的事情，但是seeyou却不这么认为。因为每次当seeyou买了可乐以后，阿牛就要求和seeyou一起分享这一瓶可乐，而且一定要喝的和seeyou一样多。但seeyou的手中只有两个杯子，它们的容量分别是N 毫升和M 毫升 可乐的体积为S （S<101）毫升　(正好装满一瓶) ，它们三个之间可以相互倒可乐 (都是没有刻度的，且 S==N+M，101＞S＞0，N＞0，M＞0) 。聪明的ACMER你们说他们能平分吗？如果能请输出倒可乐的最少的次数，如果不能输出"NO"。

Input

三个整数 : S 可乐的体积 , N 和 M是两个杯子的容量，以"0 0 0"结束。

Output

如果能平分的话请输出最少要倒的次数，否则输出"NO"。

Sample Input

7 4 3

4 1 3

0 0 0

Sample Output

NO

3

Author

seeyou

Source

“2006校园文化活动月”之“校庆杯”大学生程序设计竞赛暨杭州电子科技大学第四届大学生程序设计竞赛

解题代码

#include<iostream>
#include<cstring>
#include<queue>

using namespace std;

int s,n,m;
int vis[105][105][105];
struct node{
	int s,n,m;
	int step;
};

bool check(int x,int y,int z){
	return x == 0 && y == z || y == 0 && x == z || z == 0 && x == y;
}

int bfs(){
	if(s % 2) return 0;
	queue<node> q;
	node now,next;
	now.s = s,now.n = 0,now.m = 0,now.step = 0;
	q.push(now);
	vis[s][0][0] = 1;
	while(q.size()){
		now = q.front();
		q.pop();
		if(check(now.s,now.n,now.m)){
			return now.step;
		}
		// s-->n
		if(now.s && now.n < n){      // s不为空且n未满 
			if(now.s < n - now.n){  //s无法倒满n 
 				next.n = now.n + now.s;
				next.s = 0;
				next.m = now.m;
			}
			else{                    //s可以倒满 n 
				next.s = now.s - (n - now.n);
				next.n = n;
				next.m = now.m;
			}
			if(!vis[next.s][next.n][next.m]){
				next.step = now.step + 1;
				vis[next.s][next.n][next.m] = 1;
				q.push(next);
			}
		}
			// s-->m
		if(now.s && now.m < m){      // s不为空且m未满 
			if(now.s < m - now.m){  //s无法倒满m 
 				next.m = now.m + now.s;
				next.s = 0;
				next.n = now.n;
			}
			else{                    //s可以倒满 m 
				next.s = now.s - (m - now.m);
				next.m = m;
				next.n = now.n;
			}
			if(!vis[next.s][next.n][next.m]){
				next.step = now.step + 1;
				q.push(next);
				vis[next.s][next.n][next.m] = 1;
			}
		}
			// n-->s
		if(now.n && now.s < s){      // n不为空且s未满 
			if(now.n < s - now.s){  //n无法倒满s 
 				next.s = now.s + now.n;
				next.n = 0;
				next.m = now.m;
			}
			else{                    //n可以倒满 s 
				next.n = now.n - (s - now.s);
				next.s = s;
				next.m = now.m;
			}
			if(!vis[next.s][next.n][next.m]){
				next.step = now.step + 1;
				q.push(next);
				vis[next.s][next.n][next.m] = 1;
			}
		}
		// n-->m
		if(now.n && now.m < m){      // n不为空且m未满 
			if(now.n < m - now.m){  //n无法倒满m 
 				next.m = now.m + now.n;
				next.n = 0;
				next.s = now.s;
			}
			else{                    //n可以倒满 m 
				next.n = now.n - (m - now.m);
				next.m = m;
				next.s = now.s;
			}
			if(!vis[next.s][next.n][next.m]){
				next.step = now.step + 1;
				q.push(next);
				vis[next.s][next.n][next.m] = 1;
			}
		}
			// m-->s
		if(now.m && now.s < s){      // m不为空且s未满 
			if(now.m < s - now.s){  //m无法倒满s
 				next.s = now.s + now.m;
				next.m = 0;
				next.n = now.n;
			}
			else{                    //m可以倒满 s 
				next.m = now.m - (s - now.s);
				next.s = s;
				next.n = now.n;
			}
			if(!vis[next.s][next.n][next.m]){
				next.step = now.step + 1;
				q.push(next);
				vis[next.s][next.n][next.m] = 1;
			}
		}
		// m-->n
		if(now.m && now.n < n){      // m不为空且n未满 
			if(now.m < n - now.n){  //m无法倒满n 
 				next.n = now.n + now.m;
				next.m = 0;
				next.s = now.s;
			}
			else{                    //m可以倒满 n 
				next.m = now.m - (n - now.n);
				next.n = n;
				next.s = now.s;
			}
			if(!vis[next.s][next.n][next.m]){
				next.step = now.step + 1;
				q.push(next);
				vis[next.s][next.n][next.m] = 1;
			}
		}
	}
	return 0;
}

int main()
{
	while(cin>>s>>n>>m && s && n && m){
		memset(vis,0,sizeof(vis));
		int ans = bfs();
		if(ans == 0)
            cout<<"NO"<<endl;
		else
            cout<<ans<<endl;
	}
	return 0;
}

运行结果

状态转移规则（倒水规则）：

如果i水杯内水的容量大于j水杯内倒满所需的容量x，则——i水杯倒水后的容量为：i-x，j水杯倒水后容量为：j+x.

如果i水杯内水的容量小于j水杯内倒满所需的容量x，则——i水杯倒水后的容量为：0，j水杯倒水后容量为：j+x.

每操作一次，最少倒水次数+1.

总结

BFS基本思想：

从初始状态S开始，利用规则，生成所有可能的状态，构成树的下一层结点。

检查是否出现目标状态G，若未出现，就对该层所有状态结点，分别依次利用规则，生成再下一层的所有状态结点。

对新一层的所有状态结点继续检查是否出现G，若未出现，继续按上面思想生成再下一层的所有状态结点，这样一层一层往下展开，直到出现目标状态为止。

BFS算法（伪代码）：

Node bfs(node source，node target){

        memset(visit，0，sizeof(visit))；

        queue<node>Q；

        Q.push(source)；

        visit[source]=1；

        while(!Q.empty()){

                Node a = Q.front()；

                Q.pop()；

                if(a==target)

                {  return a;  }

                for(对于a所有的后继结点b)

                        if(visit[b]){  continue;  }

                        Q.push(b)；

                        visit[b]=1；// 剪枝，保证结点只进队列一次

                }

                return NULL；

}

AC_Dragon
关注
代码 基于BFS广度优先搜索算法代码
06-04
代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 ...
图的广度优先遍历和深度优先遍历伪代码
m0_62193621的博客
06-01 679
【代码】图的广度优先遍历和深度优先遍历伪代码。
宽度优先搜索算法（BFS）详解（超级详细讲解，附有大图）
热门推荐
aliyonghang的博客
01-18 4万+
​ 补充说明：由上可以知道，广度优先搜索的特征为从起点开始，由近及远进行广泛的搜索。因此，目标顶点离起点越近，搜索结束得就越快。 三.对比与发现 DFS和BFS的区别 bfs 遍历节点是先进先出，dfs遍历节点是先进后出； bfs是按层次访问的，dfs 是按照一个路径一直访问到底，当前节点没有未访问的邻居节点时，然后回溯到上一个节点，不断的尝试，直到访问到目标节点或所有节点都已访问。 bfs 适用于求源点与目标节点距离最近的情况，例如：求最短路径。dfs 更适合于求解一个任意符合方案中的一个或者遍历所有情
Objective-C实现BreadthFirstShortestPath广度优先最短路径算法（附完整源码）
最新发布
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-27 53
Objective-C实现BreadthFirstShortestPath广度优先最短路径算法（附完整源码）
无信息搜索（上）
lipengfei0427的博客
04-20 1282
无信息搜索是指除了问题定义中提供的状态信息外没有任何附加信息。 特点： 算法只能区分状态是不是目标状态； 无法比较非目标状态的好坏。 策略： 宽度优先搜索 一致代价搜索 深度优先搜索 深度受限搜索 迭代加深的深度优先搜索 一、宽度优先搜索 1.基本思想： 宽度优先搜索是简单搜索策略，先扩展根结点，接着扩展根结点的所有后继，然后再扩展它们的后继，依次类推。一般地，在下一层的...
进阶 非常可乐
大太阳
07-17 521
题目链接 非常可乐 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Description 大家一定觉的运动以后喝可乐是一件很惬意的事情，但是seeyou却不这么认为。因为每次当seeyou买了可乐以后，阿牛就要求和se
C++ 算法篇 广度（宽度）优先搜索（BFS）
流年的博客
01-28 9443
广度优先遍历 广度优先遍历(Breadth_First_Search)，又称为广度优先搜索，简称BFS。 图的BFS类似于树的层序遍历。 广度优先遍历 如图将左边的图变形，得到右边的图，然后一层一层的遍历。 这里借助一个队列来实现一层一层的遍历。 邻接矩阵的BFS 核心代码 /** * 邻接矩阵的广度优先遍历算法 */ void BFSTraverse(MGraph G){...
DFS：depth first search深度优先搜索（迷宫寻路） BFS：breadth first search宽度优先搜
10-10
深度优先搜索（DFS，Depth First Search）和宽度优先搜索（BFS，Breadth First Search）是图论和算法中的两种基本搜索策略，常用于解决迷宫寻路、树遍历以及网络爬虫等问题。这两种算法各有其特点，适用于不同的场景...
宽度优先算法解决八数码问题实验报告.zip
05-20
**宽度优先搜索算法（Breadth-First Search, BFS）** 宽度优先搜索是图论中的一个经典算法，常用于寻找图中的最短路径或者解决树的层次遍历问题。在这个实验报告中，它被应用于解决著名的八数码问题，也称为滑动...
深度优先和宽度优先搜索.pdf
09-13
与深度优先搜索相比，宽度优先搜索（Breadth-First Search，BFS）是一种更为常见的搜索算法，它的核心思想是：从初始结点开始，应用算符生成第一层结点，检查目标结点是否在这些后继结点中，若没有，再用产生式规则...
深度优先和宽度优先搜索.docx
09-13
深度优先搜索（Depth-First Search，DFS）和宽度优先搜索（Breadth-First Search，BFS）是两种常用的图搜索算法。深度优先搜索遵循的搜索策略是尽可能“深”地搜索图，而宽度优先搜索则是从初始结点开始，逐层扩展...
算法设计与分析期末复习（部分算法伪代码模板）
jingyu_1的博客
05-08 3277
算法设计与分析期末复习 目录 一、重点概念（容易忽视的定义） 二、一些问题Q & A 三、部分伪代码模板 一、重点概念 1.回溯、分枝限界算法 解空间：实例I的满足显式约束条件的所有元组，构成I的解空间，即所有xi合法取值的元组的集合——可行解。 状态空间树：解空间的树结构称为状态空间树(state space tree) 问题状态：树中的每一个结点代表问题的一个状态，称为问题状态(problem state) 。 状态空间：由根结点到其他结点的所有路径确定了这个问题的状态空间(state sp
宽度优先搜索算法（BFS）
2301_76161469的博客
03-10 2877
先从左向右，再从右向左地对每一层节点进行遍历以示例1为例：即。
广度优先搜索（BFS或宽度优先搜索）算法易懂介绍（内附洛谷p1135，p1451代码）
2302_79114149的博客
08-12 235
算法分析：（见下图）从1号顶点开始（也就是根），我们需要访问所有的“邻居顶点”，（也就是2号顶点与3号顶点）访问完1号的“邻居顶点”，1号变为消费完的元素，2号与3号是1号生产的两个元素，2号再生产出4号和5号……if not (nx < 0 or ny < 0 or ny >= m or nx >= n or bj[nx][ny] or data[nx][ny]=="0"):# 判断是否超了边界，是否细胞为0，是否标记过了。delta=[[0,-1],[-1,0],[1,0],[0,1]]# 方向向量。
宽度优先搜索
qq_43536978的博客
03-02 545
宽度优先搜索二叉搜索树中两个节点之和 二叉搜索树中两个节点之和 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val,
超简单的深度优先搜索代码
feengg的博客
05-27 5345
//深度优先搜索测试 //例： // 1 // / | \ // / | \ // 2 3---5 // | // | // 4 //step1:将存储图的方法称为图的*邻接矩阵存储法* // 通路用1表示，不通用-1表示，自身为0 // 1 2 ...
【算法】图 (2) Breath-first-search 宽度优先搜索
ysugarr
05-18 677
States of vertices during traversal（遍历时顶点的状态）： Undiscovered：还没遍历到该点 Discovered：遍历到该点了，但是对于该点的操作还没有结束 Processed：操作已结束 Predecessor tree（前结点树）： parent[]，parent[1]=2，表示1的parent（前结点）是2. BFS的本质是借助了队列，DFS的本质是借助了栈（通过递归隐式借助栈） 1BFS伪代码 BFS-TREE：初始化需要的数据，..
宽度优先搜索模板（bfs）
2301_81235183的博客
07-11 119
【代码】BFS 模板。
ACM竞赛攻略：宽度优先搜索BFS及其应用
"宽度优先搜索(BFS)是ACM竞赛中常用的一种算法，适用于解决代价与搜索树深度成正比的问题。尽管BFS由于其较大的空间占用而不常被广泛使用，但它在路径寻找问题上展现出独特的优势。双向宽度优先搜索是BFS的一种变体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值