BFS、DFS、蓝桥杯、迷宫、方格分割

最新推荐文章于 2024-09-12 14:47:19 发布
最新推荐文章于 2024-09-12 14:47:19 发布
阅读量159 收藏 1
点赞数
分类专栏： 算法+蓝桥杯 文章标签： 深度优先 宽度优先 蓝桥杯 容器 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53131577/article/details/123162810
版权

文章目录

算法BFS

  宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。
算法：
1.将起点入队；
2.队首结点拓展的点入队；
如果没有拓展的点，将队首结点出队，重复该步骤，直到到达目标位置；

例题1：

在这里插入图片描述
坐标点（1,1）可以向坐标点（1,2）和（2,1）拓展，坐标点（1,2）和（2,1）只能向坐标点（2,2）拓展，当坐标点（1,1）可以向坐标点（1,2）和（2,1）拓展时，坐标点（1,2）和（2,1）入队，坐标点（1,1）出对，以此类推。

求坐标（1,1）—>（6,6）最短路径：
1代表障碍物，0代表可通行
001010
000000
110110
000100
011101
000000

用BFS解决例题1：
答案是：12
参考代码：

#include<iostream>
#include<queue>
#include<string>
using namespace std;
//地图
string MAP[6] = 
{
"001010",
"000000",
"110110",
"000100",
"011101",
"000000"
};
//是否访问
bool vis[6][6];
//移动
int mv[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
struct node 
{
	int x;
	int y;
	int step;

	node(int _x, int _y, int _step)
	{
		x = _x;
		y = _y;
		step = _step;
	}
};
int main()
{
	//定义队
	queue<node>q;
	//标记起点
	vis[0][0] = true;
	q.push(node(0, 0, 0));

	//BFS
	while (!q.empty())  //队空
	{
		node now = q.front();
		q.pop();
		if (now.x == 5 && now.y == 5)
		{
			cout << now.step << endl;
			break;
		}
		for (int i = 0; i < 4; i++)
		{
			int tx = now.x + mv[i][0];
			int ty = now.y + mv[i][1];
			if (tx >= 0 && tx < 6 && ty >= 0 && ty < 6 && MAP[tx][ty] == '0' && !vis[tx][ty])
			{
				vis[tx][ty] = true;
				q.push(node(tx, ty, now.step + 1));
			}
		}
	}
	return 0;
}

算法DFS

  深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次.
举例说明之：下图是一个无向图，如果我们从A点发起深度优先搜索（以下的访问次序并不是唯一的，第二个点既可以是B也可以是C,D），则我们可能得到如下的一个访问过程：A->B->E（没有路了！回溯到A)->C->F->H->G->D（没有路，最终回溯到A,A也没有未访问的相邻节点，本次搜索结束）
在这里插入图片描述
深度优先遍历图的方法是，从图中某顶点v出发：
（1）访问顶点v；
（2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；
（3）若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。

例题2：

在这里插入图片描述

先访问到从（1,1）–>（2,1）–>(3,1)–>……–>(6,6)访问一个点标记已访问，再返回去寻找最短路径

求坐标（1,1）—>（6,6）的最短路径：
1代表障碍物，0代表可通行
001101
010000
000010
011000
010010
000100

用DFS解决例题2：
参考代码：

#include<iostream>
#include<string>
using namespace std;
//地图
string MAP[6] =
{
"001101",
"010000",
"000010",
"011000",
"010010",
"000100"
};
int mv[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
bool vis[6][6];//true-->已访问，false-->未访问
int MIN = 99999;//给MIN赋一个比较大的值

void dfs(int x, int y, int step)
{
	if (x == 5 && y == 5)
	{
		if (MIN > step) MIN = step;
		return;
	}
	for (int i = 0; i < 4; i++)
	{
		int tx = x + mv[i][0];
		int ty = y + mv[i][1];
		if (ty >= 0 && ty < 6 && tx >= 0 && tx < 6 && MAP[tx][ty] == '0' && !vis[tx][ty])
		{
			vis[tx][ty] = true;
			dfs(tx, ty, step + 1);
			vis[tx][ty] = false;
		}
	}
}
int main()
{
	//初值
	vis[0][0] = true;
	dfs(0, 0, 0);
	cout << MIN << endl;
	return 0;
}

第十届蓝桥杯 试题E：迷宫

用BFS解决：
答案：

DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR

参考代码：

#include<iostream>
#include<queue>
#include<string>
using namespace std;
int n = 30, m = 50;
bool vis[30][50];
int mv[4][2] = { {1,0},{0,1},{0,-1},{-1,0} };// D R L U 字典序
string Map[30]
{
"01010101001011001001010110010110100100001000101010",
"00001000100000101010010000100000001001100110100101",
"01111011010010001000001101001011100011000000010000",
"01000000001010100011010000101000001010101011001011",
"00011111000000101000010010100010100000101100000000",
"11001000110101000010101100011010011010101011110111",
"00011011010101001001001010000001000101001110000000",
"10100000101000100110101010111110011000010000111010",
"00111000001010100001100010000001000101001100001001",
"11000110100001110010001001010101010101010001101000",
"00010000100100000101001010101110100010101010000101",
"11100100101001001000010000010101010100100100010100",
"00000010000000101011001111010001100000101010100011",
"10101010011100001000011000010110011110110100001000",
"10101010100001101010100101000010100000111011101001",
"10000000101100010000101100101101001011100000000100",
"10101001000000010100100001000100000100011110101001",
"00101001010101101001010100011010101101110000110101",
"11001010000100001100000010100101000001000111000010",
"00001000110000110101101000000100101001001000011101",
"10100101000101000000001110110010110101101010100001",
"00101000010000110101010000100010001001000100010101",
"10100001000110010001000010101001010101011111010010",
"00000100101000000110010100101001000001000000000010",
"11010000001001110111001001000011101001011011101000",
"00000110100010001000100000001000011101000000110011",
"10101000101000100010001111100010101001010000001000",
"10000010100101001010110000000100101010001011101000",
"00111100001000010000000110111000000001000000001011",
"10000001100111010111010001000110111010101101111000"
};
struct Node {
	int x;
	int y;
	int step;
	string str;
	Node(int _x, int _y, int _step, string _str)
	{
		x = _x;
		y = _y;
		step = _step;
		str = _str;
	}
};
int main()
{
	queue<Node>q;
	string s = "";
	vis[0][0] = true;
	q.push(Node(0, 0, 0, ""));
	while (!q.empty())
	{
		Node now = q.front();
		q.pop();
		if (now.x == n - 1 && now.y == m - 1)
		{
			cout << now.str << endl;
		}
		for (int i = 0; i < 4; i++)
		{
			int tx = now.x + mv[i][0];
			int ty = now.y + mv[i][1];
			if (tx >= 0 && tx < n && ty >= 0 && ty < m && !vis[tx][ty] && Map[tx][ty] == '0')
			{
				if (i == 0)
				{
					s = "D";
				}
				else if (i == 1)
				{
					s = "R";
				}
				else if (i == 2)
				{
					s = "L";
				}
				else
				{
					s = "U";
				}
				vis[tx][ty] = true;
				q.push(Node(tx, ty, now.step + 1, now.str + s));
			}
		}
	}
	return 0;
}

第八届蓝桥杯 试题D：方格分割

用DFS解决：
答案：509

参考代码：

#include <iostream>
#include<string>
using namespace std;
int ans = 0;
int mv[4][2] = { {1,0},{-1,0},{0,1},{0,-1} };
bool vis[8][8];
int MAP[8][8] = {0};
void dfs(int x, int y)
{
	if (x == 0 || y == 0 || x == 6 || y == 6) {
		ans++;
		return;
	}
	for (int i = 0; i < 4; i++)
	{
		int tx = x + mv[i][0];
		int ty = y + mv[i][1];
		if (vis[tx][ty] == 0)
		{
			vis[tx][ty] = true;
			vis[6 - tx][6 - ty] = true;
			dfs(tx, ty);
			vis[tx][ty] = 0;
			vis[6 - tx][6 - ty] = 0;
		}
	}
}
int main()
{
	vis[3][3] = true;
	dfs(3, 3);
	cout << ans / 4 << endl;
	return 0;
}

总结：BFS和DFS是对整个地图进行遍历最后得到最短路径，可以这两个算法从最短路径延伸到其他的最优问题求解。

EMPTYTIMESPACE
关注
专栏目录
蓝桥杯专题之递归+dfs+bfs篇
qq_53133234的博客
04-01 2504
题目列表： 2014年：李白打酒，地宫取宝 2015年：牌型种数 2016年：方格填数，剪邮票 2020年：走方格，七段码 1.李白打酒
图像分割算法(BFS)
weixin_50340097的博客
09-12 398
题目描述 描述 给定一个n行m列的二值图像，0为背景，1为前景物，请计算该图像中有多少块区域块（由连接的1构成），并输出 最大的区域块的像点数。 同一个区域块中的点要么是连接的，要么是存在包围关系。 判断两个区域是否连接采用四邻域判定，即一点仅与它的上下左右四个点相连； 判断两个区域是否存在包含关系即一个区域被另一个区域完全包围，如下所示，中间的两个1被外面的16个1完全包围（中间的两个1不 存在通往外界的四邻域通路） 00000000 00111110 00100001 00101101 00100001
广度优先搜索（BFS）基本概念
热门推荐
Jjwj11的博客
07-18 2万+
一：BFS概念 宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。 所谓广度，就是一层一层的，向下遍历，层层堵截，还是这幅图，我们如果要是广度优先遍历的话，我们的结果是V1 V2 V3 V4 V5 V6
初识宽度优先搜索(BFS)(二)
努力的小白马
05-13 1239
P1141 01迷宫 题目描述 有一个仅由数字00与11组成的n \times nn×n格迷宫。若你位于一格00上，那么你可以移动到相邻44格中的某一格11上，同样若你位于一格11上，那么你可以移动到相邻44格中的某一格00上。 你的任务是：对于给定的迷宫，询问从某一格开始能移动到多少个格子（包含自身）。 输入格式 第11行为两个正整数n,mn,m。 下面nn行，每行nn个字符，字符只可能是00或者11，字符之间没有空格。 接下来mm行，每行22个用空格分隔的正整数i,ji,j，对应了迷宫中第ii行第jj列
2017、2019蓝桥杯迷宫问题(DFS+BFS）（相关问题汇总）
hy1255564202的博客
04-08 728
#include<bits/stdc++.h> #define ll long long using namespace std; #define N 4 #define M 6 bool vis[N][M]; char G[N][M]; char ch[]={'D','L','R','U'}; int dir[4][2]={{1,0},{0,-1},{0,1},{-1,0}}; struct Point{ int x,y; string road; Point(int a,int b...
C语言DFS和BFS解决迷宫问题
lxh0113的博客
10-22 960
C语言DFS和BFS解决迷宫问题
蓝桥杯-深度优先搜索dfs
charthor的博客
03-08 251
2017年省赛-填空题-方格分割-644 切割线一定会经过图的中心点，只要确定半条到达边界的分割线，就能根据这半条对称画出另外半条 count = 0 vis = [[0]*7 for i in range(7)] #多给一个 next_node = [[-1, 0], [1, 0], [0, -1], [0, 1]] #按什么顺序应该无所谓吧，也没说字典序啥的 def dfs(x, y): global count #全局变量 if x == 0 or y == 0 or x == .
蓝桥杯C++深度优先搜索(dfs)之组队，迷宫，走方格
IT OR 考公？
12-16 858
dps学习之组队，迷宫，最短路（新手自学未遂）
蓝桥杯day7——DFS&&BFS
qq_57150526的博客
09-28 921
图论开篇，又做了最熟悉的DFS加深了了解以及理解了BFS，感觉BFS的作用还是蛮大的，对Python的切片操作，做了进一步的总结。加油！！
DFS和BFS简述
蓝的博客
02-01 3380
DFS与BFS
DFS和BFS
Eyumbo的博客
11-19 1197
DFS和BFS初学习
洛谷题集——01迷宫（dfs、bfs）
Zhengyangxinn的博客
05-11 723
有一个仅由数字0与1组成的n×n格迷宫。若你位于一格0上，那么你可以移动到相邻4格中的某一格1上，同样若你位于一格1上，那么你可以移动到相邻4格中的某一格0上。 你的任务是：对于给定的迷宫，询问从某一格开始能移动到多少个格子（包含自身）。
算法基础之DFS、BFS、树与图的存储、树与图的DFS和BFS、拓扑排序
qq_37448336的博客
11-15 731
目录1、DFS1.1、 DFS与BFS的对比1.2、排列数字1.3、 n-皇后问题1.3.1 全排列顺序搜索1.3.2 按每个格子的顺序枚举2、BFS2.1、走迷宫2.1.1 数组模拟队列实现2.1.2 queue实现 1、DFS 1.1、 DFS与BFS的对比 1.2、排列数字 #include<iostream> using namespace std; const int N=10; int n; int num[N]; bool st[N]; void dfs(int u
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5152
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
蓝桥杯4. Fizz Buzz 经典问题
最新发布
DANGAOGAO的博客
09-12 449
输入 N，1<N≤104N，1<N≤104.输出一行，如题干所述。
蓝桥杯18小白第5题
qq_73671385的博客
09-11 286
思维，struct sint x,y,z;}q[n];cin>>a;i<=a*2;i++)i<=a*2;i++)int w=0;i<=a*2;i++)if(i%2==1)w+=q[i].x;elsew-=q[i].y;
C语言蓝桥杯:语言基础
kkkkkkkok的博客
09-07 1788
、
k8s中的层级结构，及节点组件的作用
2401_84019227的博客
09-06 3525
这五个是资源文件里面的顶级字段，最后一个status状态大部分情况下可以不写，在创建资源的时候。有各个被管理k8s集群的名称，管理用户，集群的证书cacert，客户端的证书cert，客户端的密钥key，等这些信息。这个配置文件里面有client主机想kubectl config操作的k8s集群的信息。controller-manager可以认为是一些程序的集合，也有对应的配置文件。控制器的作用也是为了实现k8s集群的各个品类的功能的需求的满足。那么这些api资源都是为了让k8s更好的提供容器化服务的工具。
蓝桥杯Java A组历年真题解析：大数运算与迷宫问题
6. **迷宫问题**：这是一个典型的深度优先搜索（DFS）或广度优先搜索（BFS）应用。给定一个二维矩阵表示的迷宫，从起点到终点找最短路径。可以使用递归或队列来实现搜索，同时记录步数和路径，以找到步数最少且字典...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

EMPTYTIMESPACE

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

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

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

打赏作者

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

抵扣说明：

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

余额充值