万能的搜索之BFS

最新推荐文章于 2024-07-13 10:36:41 发布
最新推荐文章于 2024-07-13 10:36:41 发布
阅读量196 收藏 1
点赞数 1
分类专栏： 算法学习知识点总结 文章标签： bfs 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LXYDSF/article/details/115716534
版权
1.拯救小哈之BFS

具体题目描述 点击这里

参考代码
#include<iostream>
#include<queue>
using namespace std;
struct node {
	int x;
	int y;
	int f;
	int s;//步数
};

int NEXT[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
int n, m, startx, starty, p, q, tx, ty, flag;
queue<node> que;
int main()
{
	
	int a[51][51] = { 0 }, book[51][51] = { 0 };
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++) {
			cin >> a[i][j];
		}
	}
	cin >> startx >> starty >> p >> q;
	node nd;
	nd.x = startx;
	nd.y = starty;
	nd.f = 0;
	nd.s = 0;
	que.push(nd);
	book[startx][starty] = 1;
	flag = 0;//标记是否到达目标点
	//当队列不为空的时候循环
	while (!que.empty()) {
		//四个方向
		node n1 = que.front();
		for (int i = 0; i <= 3; i++) {
			tx = n1.x + NEXT[i][0];
			ty = n1.y + NEXT[i][1];
			//是否越界
			if (tx < 1 || tx > n || ty <1 || ty > m) {
				continue;
			}
			if (a[tx][ty] == 0 && book[tx][ty] == 0) {
				book[tx][ty] = 1;
				node n2;
				n2.x = tx;
				n2.y = ty;
				n2.f = n1.f;
				n2.s = n1.s + 1;
				que.push(n2);
			}
			//如果到目标点了,停止扩展,结束循环
			if (tx == p && ty == q) {
				flag = 1;
				break;
			}
		}
		if (flag) {
			break;
		}
		//当前点扩展结束,弹出改点.
		que.pop();

	}
	if (que.size() > 0) {
		cout << que.back().s << endl;
	}
	return 0;
}
2.炸弹人

游戏简述
通过放置炸弹的方法来消灭敌人，炸弹只能放置在空地上，炸弹可以向上下左右四个方向炸开，碰到敌人可以消灭，但是碰到墙则停止这个炸弹在这个方向上的威力。
在这里插入图片描述

现在有个特殊的关卡，只有一枚炸弹（炸弹威力大杀伤距离足够强威力足够大），请问这个炸弹放置在地图上的哪个空位上，能够消灭最多数量的敌人。
在这里插入图片描述
先将地图模型化，把墙用符号“#”表示，敌人用大写字母G表示，空地用英文点号“.”表示，整张地图可以抽象成一个二维数组。接下来我们使用BFS解决.

参考代码
#include<iostream>
#include<queue>
using namespace std;
struct node {
	int x;
	int y;//横纵坐标
};
char a[25][25];//用来存储地图
int sum1, x, y,max1,mx,my,n,m,startx,starty,tx,ty;
queue<node> que;
int book[25][25];//定义一个标记
int NEXT[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };//方向数组
int getnum(int i, int j) {
	int sum;
	sum = 0;//用于计数
	x = i;
	y = j;
	//向上统计  可以消灭的敌人
	while (a[x][y] != '#') {//判断该点是不是墙
		if (a[x][y] == 'G') {
			sum++;
		}
		x--;

	}
	//向下统计
	x = i;
	y = j;
	while (a[x][y] != '#') {
		if (a[x][y] == 'G') {
			sum++;
		}
		x++;
	}
	//向左统计
	x = i;
	y = j;
	while (a[x][y]!='#')
	{
		if (a[x][y] == 'G') {
			sum++;
		}
		y--;

	}
	//向右统计
	x = i;
	y = j;
	while (a[x][y] != '#')
	{
		if (a[x][y] == 'G') {
			sum++;
		}
		y++;

	}
	return sum;
}

int main() {
	cin >> n >> m >> startx >> starty;
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
	//队列初始化
	node nd;
	nd.x = startx;
	nd.y = starty;
	que.push(nd);
	max1 = getnum(startx, starty);
	mx = startx;
	my = starty;
	//队列不为空时进行循环
	while (!que.empty()) {
		//枚举四个方向
		node nd2 = que.front();
		for (int i = 0; i <= 3; i++) {
			sum1 = 0;
			tx = nd2.x + NEXT[i][0];
			ty = nd2.y + NEXT[i][1];
			if (tx < 0 || tx > n - 1 || ty < 0 || ty > m - 1) {//判断是否越界
				continue;
			}
			if (a[tx][ty] == '.' && book[tx][ty] == 0) {
				book[tx][ty] = 1;
				node nd3;
				nd3.x = tx;
				nd3.y = ty;
				que.push(nd3);
				sum1 = getnum(tx, ty);
				if (sum1 > max1) {
					max1 = sum1;
					mx = tx;
					my = ty;
					//cout << "哈哈哈" << max1 << endl;
				}
			}
			
		}
		que.pop();
	}
	cout << "将炸弹放在:" << mx <<" "<< my << "处,最多可以消灭的敌人是" << max1 << endl;
	return 0;
}

/*
13 13 3 3
#############
#GG.GGG#GGG.#
###.#G#G#G#G#
#.......#..G#
#G#.###.#G#G#
#GG.GGG.#.GG#
#G#.#G#.#.#.#
##G...G.....#
#G#.#G###.#G#
#G#.#G#G#.#G#
#GG.GGG#G.GG#
#GG.GGG#G.GG#
#############


*/
运行结果

在这里插入图片描述
可以看出BFS的核心是:搜索所有的空白快,完毕后输出最小的即可.
该题也可使用DFS进行解决

参考代码2
#include<iostream>
using namespace std;
char a[25][25];//用来存储地图
int sum1, x, y, max1, mx, my, n, m, startx, starty, tx, ty;
int book[25][25];//定义一个标记
int NEXT[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };//方向数组
int getnum(int i, int j) {
	int sum;
	sum = 0;//用于计数
	x = i;
	y = j;
	//向上统计可以消灭的敌人
	while (a[x][y] != '#') {//判断的点是不是墙
		if (a[x][y] == 'G') {
			sum++;
		}
		x--;

	}
	//向下统计
	x = i;
	y = j;
	while (a[x][y] != '#') {
		if (a[x][y] == 'G') {
			sum++;
		}
		x++;
	}
	//向左统计
	x = i;
	y = j;
	while (a[x][y] != '#')
	{
		if (a[x][y] == 'G') {
			sum++;
		}
		y--;

	}
	//向右统计
	x = i;
	y = j;
	while (a[x][y] != '#')
	{
		if (a[x][y] == 'G') {
			sum++;
		}
		y++;

	}
	return sum;
}

void dfs(int x, int y) {
	sum1 = getnum(x, y);
	if (sum1 > max1) {
		max1 = sum1;
		mx = x;
		my = y;
	}
	for (int i = 0; i <= 3; i++) {
		sum1 = 0;
		tx = x+ NEXT[i][0];
		ty = y + NEXT[i][1];
		if (tx < 0 || tx > n - 1 || ty < 0 || ty > m - 1) {
			continue;
		}
		//判断是否走过
		if (a[tx][ty] == '.' && book[tx][ty] == 0) {
			book[tx][ty] = 1;
			dfs(tx, ty);
		}
	}
	return;
}

int main() {
	cin >> n >> m >> startx >> starty;
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
	book[startx][starty] = 1;
	max1 = getnum(startx, starty);
	mx = startx;
	my = starty;
	dfs(startx, starty);
	cout << "将炸弹放在:" << mx << " " << my << "处,最多可以消灭的敌人是" << max1 << endl;
	return 0;
}

DFS解决的话,在于只要遍历过就行,无需回溯.

3.宝岛冒险

小哼通过秘密方法得到了一张不完整的钓鱼岛航拍地图。钓鱼岛由一个主岛和一些附属岛屿组成，小哼决定去钓鱼岛冒险。下面这个 10 * 10 的二维码矩阵就是钓鱼岛的航拍地图。图中数字代表海拔，0 表示海洋，1~9 表示陆地。小哼的飞机将会在（6，8）处，现在需要计算出小哼落地所在岛屿的面积（即有多少个格子）。

1 2 1 0 0 0 0 0 2 3
3 0 2 0 1 2 1 0 1 2
4 0 1 0 1 2 3 2 0 1
3 2 0 0 0 1 2 4 0 0
0 0 0 0 0 0 1 5 3 0
0 1 2 1 0 1 5 4 3 0
0 1 2 3 1 3 6 2 1 0
0 0 3 4 8 9 7 5 0 0
0 0 0 3 7 8 6 0 1 2
0 0 0 0 0 0 0 0 1 0

参考代码1–DFS
#include<iostream>
using namespace std;
int startx, starty,tx,ty,sum;
int NEXT[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
int book[13][13], map[13][13],total= 1;

//深搜  
void dfs(int x, int y) {
	for (int i = 0; i < 4; i++) {
		tx = x + NEXT[i][0];
		ty = y + NEXT[i][1];
		//判断是否越界
		if (tx < 1 || tx > 10 || ty < 1 || ty > 10) {
			continue;
		}
		//判断是否是陆地
		if (map[tx][ty] >= 1 && map[tx][ty] <= 9 && !book[tx][ty]) {
			book[tx][ty] = 1;
			total++;
			dfs(tx, ty);
		}
	}
}
int main()
{
	for (int i = 1; i <= 10; i++) {
		for (int j = 1; j <= 10; j++) {
			cin >> map[i][j];
		}
	}
	book[6][8] = 1;
	dfs(6, 8);
	cout << total << endl;
	return 0;
}

在这里插入图片描述

参考代码2—BFS
#include<iostream>
#include<queue>
using namespace std;
struct node {
	int X;
	int Y;
};
queue<node> que;
int startx, starty,tx,ty,sum;
int NEXT[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
int book[13][13], map[13][13],total= 1;

void bfs(int x, int y) {
	node nd;
	nd.X = x;
	nd.Y = y;
	que.push(nd);
	while (!que.empty()) {
		node nd2;
		nd2 = que.front();
		for (int i = 0; i <= 3; i++) {
			tx = nd2.X + NEXT[i][0];
			ty = nd2.Y + NEXT[i][1];
			//判断是否越界
			if (tx < 1 || tx > 10 || ty < 1 || ty > 10) {
				continue;
			}
			if (map[tx][ty] >= 1 && map[tx][ty] <= 9 && !book[tx][ty]) {
				node nd3;
				nd3.X = tx;
				nd3.Y = ty;
				que.push(nd3);
				book[tx][ty] = 1;
				total++;
			}
		}
		que.pop();
	}
}
int main()
{
	for (int i = 1; i <= 10; i++) {
		for (int j = 1; j <= 10; j++) {
			cin >> map[i][j];
		}
	}
	book[6][8] = 1;
	bfs(6, 8);
	cout << total << endl;
	return 0;
}
/*
1 2 1 0 0 0 0 0 2 3
3 0 2 0 1 2 1 0 1 2
4 0 1 0 1 2 3 2 0 1
3 2 0 0 0 1 2 4 0 0
0 0 0 0 0 0 1 5 3 0
0 1 2 1 0 1 5 4 3 0
0 1 2 3 1 3 6 2 1 0
0 0 3 4 8 9 7 5 0 0
0 0 0 3 7 8 6 0 1 2
0 0 0 0 0 0 0 0 1 0


  38
*/
爱编程的大李子
关注
专栏目录
浅谈迷宫搜索类的双向bfs问题(例题解析)
bigsai
02-15 5783
前言 在搜索问题中，以迷宫问题最具有代表性，无论是八皇后的回溯问题，还是dfs找出口，bfs找最短次数等等题目的问题。在我们刚开始ac的时候、可能有着很多满足感！感觉是个迷宫问题咱么都可以给他这么搜出来 ！！ 然而，当数据达到一定程度，我们使用简单的方法肯定会爆炸的，****。就可能需要一些特殊的巧妙方法处理，比如各种剪枝、优先队列、A*、dfs套bfs，又或者利用一些非常厉害的数学方法比如康托...
啊哈算法之炸弹人
weixin_30617695的博客
06-14 627
简述 本算法摘选自啊哈磊所著的《啊哈！算法》第三章第二节的题目——枚举法破解炸弹人游戏。文中代码使用C语言编写，博主通过阅读和理解，重新由Java代码实现了一遍。 游戏简述 通过放置炸弹的方法来消灭敌人，炸弹只能放置在空地上，炸弹可以向上下左右四个方向炸开，碰到敌人可以消灭，但是碰到墙则停止这个炸弹在这个方向上的威力。 （图片来源于啊哈算法书中截图） 现在有个特殊的关卡，只有一枚炸弹...
广度优先搜索（BFS）
WQhuanm的博客
10-30 1381
bfs旨在面临一个路口时，把所有的岔路口都记下来，然后选择其中一个进入，然后将它的分路情况记录下来，然后再返回来进入另外一个岔路，并重复这样的操作，具有盲目性。因此其算法复杂度与集合总数密切相关，一般BFS算法常用于求最短的步数或者求扩散性质的区域问题。（求最长什么的（去盲目搜索，可能会爆TLE或者MLE）
bfs广度优先搜索
2302_80364740的博客
01-25 2025
最小生成树算法分层。
万能的搜索--之BFS（三）
weixin_30319153的博客
04-14 73
接着（一）start （二）广度优先搜索（BFS） 广度优先搜索（又称宽度优先搜索算法）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。 Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到...
广度优先搜索（BFS）详解
m0_69596371的博客
06-12 5469
广度优先搜索（BFS）是一种用于图形数据结构的遍历算法，它从给定的起始顶点开始，以广度优先的方式逐层搜索图中的节点，直到找到目标节点或遍历完整个图。BFS算法通常使用队列数据结构来实现，它的时间复杂度为O(V+E)，其中V表示图中顶点数，E表示边数。BFS算法在求解最短路径、连通性、拓扑排序等问题中具有重要应用。广度优先搜索（Breadth First Search）,简称广搜（BFS）。广搜是逐层扩展状态的搜索策略，常用于解决连通性问题和最短路问题。
BFS 广度优先搜索 ( Breadth-First-Search )
2301_79203206的博客
05-02 1627
广度优先搜索算法(Breadth First Search)，又称为"宽度优先搜索", BFS是用于图的查找算法(要求能用图表示出问题的关联性)。
【C++】BFS杂讲
最新发布
m0_73812881的博客
07-13 2024
BFS 是什么，它说"我是A*"，它说“我是Dijkstra弱化版”，它说“我是”Flood fill“ ......，BFS 有很多种变形，而变形后也可以成为比较困难的问题，如 K短路问题 等等，所以我准备水一期将一讲 BFS 的一些常见的变形。
搜索算法dfs和bfs解析(附有例题）
秋名山码民的技术小屋
02-07 2334
文章目录前言dfsdfs全排列问题dfs N皇后问题最长快乐字符串二叉树的最近祖先bfs 前言 本文我们主要来介绍dfs和bfs的基础知识在加以几个必要的习题说明，搜索算法dfs和bfs dfs 深度优先搜索算法（简称DFS）：一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。
A*算法最短路径万能通用matlab代码
01-02
它结合了Dijkstra算法的最优性和BFS（广度优先搜索）的效率，通过引入一个评估函数来估计从当前节点到目标节点的代价，从而快速找到接近最优的解决方案。 在MATLAB中实现A*算法通常涉及以下步骤： 1. **定义图形...
【学习笔记】广度优先搜索和深度优先搜索（BFS和DFS）
hcCuriosity的博客
08-06 236
广度优选搜索（bfs） BFS大致思路： 1.首先创建一个visit[ ]数组和一个队列q，分别用来判断该位置是否已经访问过及让未访问过的点入队； 2.初始化visit[ ]数组，清空q队列； 3.让起点start入队，并使该点的visit置1； 4.while（！q.empty()）{…}执行搜索操作， a.取出队头元素后使队头元素出队，判断该元素是否为目标到达点； b.如果是目标点，就返回结果（一般是最短时间、最短路径）； c.如果不是目标点，就继续访问与其相邻的位置点，将可走的相邻的位置点
【BFS】走迷宫（C++）
liuzich的博客
08-21 5143
【题目描述】 一个迷宫由R行C列格子组成，有的格子里有障碍物，不能走；有的格子是空地，可以走。 给定一个迷宫，求从左上角走到右下角最少需要走多少步(数据保证一定能走到)。只能在水平方向或垂直方向走，不能斜着走。 【输入】 第一行是两个整数，Ｒ和Ｃ，代表迷宫的长和宽。（ 1≤ R，C ≤ 40) 接下来是Ｒ行，每行Ｃ个字符，代表整个迷宫。 空地格子用‘.’表示，有障碍物的格子用‘#’表示。 迷宫左上...
啊哈算法第四章 万能的搜索
seineo
04-22 458
从这一章开始就真的步入对我而言全新的算法世界了（因为排序、枚举在上学期还是接触过的，而栈、队列在这学期我看的C++Primer和老师教的Java课里也有所涉及） 一、深度优先搜索（Depth First Search） 首先作者用上章遗留的全排列问题作为引例为我们介绍了DFS是啥东西。 题目1：输入一个数n 请输出1~n的全排列。 当然我们可以用上一章的枚举来做，并且用一个book[10]...
图的遍历
热门推荐
LXYDSF的博客
02-26 1万+
图的遍历 介绍 是从图的某一顶点出发，按照某种搜索方式对图中所有顶点访问一次且仅一次。图的遍历可以解决很多搜索问题，在实际中应用非常广泛。图的遍历根据搜索方式的不同，分为广度优先搜索和深度优先搜索。 一.深度优先遍历 1.1介绍 深度优先搜索（Depth First Search, DFS）是最常见的图搜索方法之一。深度优先搜索沿着一条路径一直走下去，无法行进时，回退到刚刚访问的节点，似“不撞南墙不回头，不到黄河不死心”。深度优先遍历是按照深度优先搜索的方式对图进行遍历。 深度优先遍历秘籍：后被访问的顶点.
斐波那契数列的四种解法
LXYDSF的博客
10-06 6925
题目描述 斐波那契数列（Fibonacci sequence），又称黄金分割数列，因数学家莱昂纳多·斐波那契（Leonardo Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下被以递推的方法定义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用，为此，美国数学会从 1963 年起
详解哈夫曼编码
LXYDSF的博客
04-29 4962
详解哈夫曼编码 概述 通常的编码方法有固定长度和不等长度编码两种。 最优编码方案的目的是使总码长度最短。利用字符的使用频率来编码，是不等长编码方法，使得经常使用的字符编码较短，不常使用的字符编码较长。如果采用等长的编码方案，假设所有字符的编码都等长，则表示n个不同的字符需要位。例如三个不同的字符a,b,c，至少需要2位二进制数表示：a:00，b:01，c:10。如果每个字符的使用频率相等的话，固定长度编码是空间效率最高的方法。在这里我们讨论的是不等长度编码. 1.设计哈夫曼树 不等长编码方法需要解决两个.
最短路径之Dijkstra算法
LXYDSF的博客
05-17 4956
引入 迪科斯彻提出了著名的单源最短路径求解算法——Dijkstra算法。 Dijkstra算法是解决单源最短路径问题的贪心算法，它先求出长度最短的一条路径，再参照该最短路径求出长度次短的一条路径，直到求出从源点到其他各个顶点的最短路径。 Dijkstra算法的基本思想是首先假定源点为u，顶点集合V被划分为两部分:集合S和V-S。初始时S中仅含有源点u，其中S中的顶点到源点的最短路径已经确定。集合V-S中所包含的顶点到源点的最短路径的长度待定，称从源点出发只经过S中的点到达V-S中的点的路径为特殊路径，并用
C++中小数的四舍五入
LXYDSF的博客
03-02 4851
C++中小数的四舍五入 介绍下常见的三个可以让小数转换成整数的函数: 名称 用法 floor(m) <=m的最大整数 (向下取整) ceil(m) >=m的最小整数 (向上取整) round(m) m四舍五入 对于小数而言，round()函数仅仅保留到整数位，即仅仅对小数点后一位四舍五入. 举例 round(1.666) =1.000000 round(-1.56)=-2.000000 如果想要保留小数位数，则可以先乘后除 举例 #include<iostr
八大排序算法总结+例题练习(正在不断补充...)
LXYDSF的博客
10-09 3619
1.插入排序 1.基本介绍 直接插入排序是最简单的排序方法，每次将一个待排序的记录，插入到已经排好序的数据序列中，得到一个新的长度增1的有序表。如图9-3所示。 2.算法步骤: 1)设待排序的记录 存储在数组r[1…n]中，可以把第一个记录r[1]看作-一个有序序列。 2)依次将[国] (i=2，… n)插入到已经排好序的序列r[1…i-1]中，并保持有序性。 例如,利用直接插入排序算法对序列 {12,2,16,30,28,10,16*,20,6,18}进行非递减排序。 初始状态，把r[1]看作-一个有序
搜索算法探索：状态空间与BFS
"状态空间-搜索之BFS算法" 在计算机科学和人工智能领域，搜索算法是一种通用的解题方法，特别是在解决复杂问题时扮演着重要角色。然而，由于其复杂性和灵活性，学习和掌握搜索算法可能具有挑战性。本主题专注于状态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱编程的大李子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值