第九章：广度优先和深度优先搜索的一些总结

最新推荐文章于 2024-06-13 14:58:11 发布
最新推荐文章于 2024-06-13 14:58:11 发布
阅读量4.6k 收藏 21
点赞数 1
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WANGHAOXIN364/article/details/122909995
版权

 图文详解两种算法：深度优先遍历（DFS）和广度优先遍历（BFS）

阅读本文前，请确保你已经掌握了递归、栈和队列的基本知识，如想掌握搜索的代码实现，请确保你能够用代码实现栈和队列的基本操作。

深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search，简称 BFS)是图论中两种非常重要的算法，也是进行更高的算法阶段学习的最后一道门槛。搜索算法频繁出现在算法竞赛题中， 尤其是深度优先搜索，在竞赛中，它是用来进行保底拿分的神器！

本文将会从以下几个方面来讲述深度优先遍历，广度优先遍历，相信大家看了肯定会有收获。

  • 什么是搜索？搜索用来干什么？

  • 深度优先遍历，广度优先遍历介绍

  • DFS vs BFS

  • 搜索的解题流程

  • 搜索中的常用术语

  • 搜索的一些优化

  • 习题演练

什么是搜索？搜索用来干什么？

搜索本质上就是枚举，只不过是一种有策略的枚举

搜索算法是利用计算机的高性能来有目的的穷举一个问题解空间的部分或所有的可能情况，从而求出问题的解的一种方法。现阶段一般有枚举算法、深度优先搜索、广度优先搜索、A*算法、回溯算法、蒙特卡洛树搜索、散列函数等算法。搜索本质上就是枚举，只不过是一种有策略的枚举， 通常在搜索前，根据条件降低搜索规模；根据问题的约束条件进行剪枝；利用搜索过程中的中间解，避免重复计算这几种方法进行优化 。

搜索算法实际上是根据 初始条件 和 扩展规则 构造一棵“解答树”并寻找符合目标状态的节点的过程。所有的搜索算法从最终的算法实现上来看，都可以划分成两个部分——控制结构（扩展节点的方式）和产生系统（扩展节点），而所有的算法优化和改进主要都是通过修改其控制结构来完成的。我们所熟悉的最常用的搜索算法：深度优先搜索和广度优先搜索就是有两种不同的控制结构（策略）的搜索算法。

其实，在这样的思考过程中，我们已经不知不觉地将一个具体的问题抽象成了一个模型——树，即搜索算法的使用 第一步在于搜索树的建立 。

深度优先遍历

深度优先遍历

主要思路是从图中一个未访问的顶点 V 开始，沿着一条路一直走到底，然后从这条路尽头的节点回退到上一个节点，再从另一条路开始走到底......，不断递归重复此过程，直到所有的顶点都遍历完成，它的特点是**不撞南墙不回头**，先走完一条路到底，再换一条路继续走。

树是图的一种特例(连通无环的图就是树)，

最低0.47元/天 解锁文章
WANGHAOXIN364
关注
  • 1
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
8-Puzzle：贪婪最佳优先搜索，广度优先搜索，深度优先搜索
02-15
这个谜题通常用作演示各种搜索算法的理想实例，包括深度优先搜索（DFS）、广度优先搜索（BFS）以及贪婪最佳优先搜索（GBFS）。在这个场景下，我们将深入探讨这些算法如何应用于8拼图问题，并讨论它们各自的优缺点。 ...
【基础知识】一文看懂深度优先算法和广度优先算法
fumeidonga的博客
06-08 9099
先上个图现在我们要访问图中的每个节点，即图的遍历。图的遍历是指，从给定图中任意指定的顶点（称为初始点）出发，按照某种搜索方法沿着图的边访问图中的所有顶点，使每个顶点仅被访问一次，这个过程称为图的遍历。我们根据访问节点的顺序与方式（根据搜索方法），可以分为广度优先（BFS）和深度优先（DFS），这是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻路(走迷宫)，搜索引擎，爬虫等。我们分别来介绍。
深度优先搜索（DFS）和广度优先搜索（BFS）
weixin_43955293的博客
08-21 2万+
DFS && BFS
广度优先算法和深度优先算法
最新发布
m0_72556244的博客
06-13 313
的区别主要体现在搜索策略、数据结构、完备性、
搜索算法——深度优先、广度优先
weixin_62773441的博客
03-13 2754
函数使用栈来实现深度优先搜索。它从起始节点开始，将其入栈。然后进入一个循环，弹出栈顶节点，如果该节点没有被访问过，则输出该节点，将其添加到已访问集合中，并将其邻居节点压入栈中。循环继续，直到栈为空。深度优先搜索（DFS）是一种用于图遍历或树遍历的算法。它的核心思想是尽可能地向深度方向遍历，直到到达最深处，然后返回上一个节点，继续向另一个方向遍历。如果当前节点没有被访问过，则输出该节点，将其添加到已访问集合中，并递归访问其邻居节点。深度优先搜索的实现可以使用递归或栈（迭代版本）来实现。
深度优先搜索(DFS)和广度优先搜索(BFS)
Go-Hello的博客
07-28 6910
深度优先搜索（DFS）和广度优先搜索（BFS）是图论中两个非常重要的算法，主要用于拓扑排序，寻路（走迷宫）和搜索引擎等。
第九章：增量式爬虫_第九章：增量式爬虫_
10-02
2. **URL管理**：爬虫会维护一个URL队列，新发现的URL会被添加到队列中，然后按照某种策略（如深度优先、广度优先）进行爬取。 3. **网页变化检测**：增量爬虫的核心是能够识别网页内容的变化。这通常通过比较网页...
深度优先搜索算法和广度优先搜索算法解八数码问题
12-29
总结来说，八数码问题的解决方案涉及到理解并实现搜索算法，包括深度优先搜索和广度优先搜索。在C#编程环境下，这需要对数据结构、递归、状态表示以及可能的优化策略如启发式函数有深入的理解。通过分享这个程序，...
第五章：查找-2021-11
08-03
3. **图的遍历**：深度优先搜索（DFS）和广度优先搜索（BFS）是常用的图遍历算法。 4. **图的基本应用**：图在路径搜索、网络设计等领域有广泛应用。 **五、查找** 1. **查找的基本概念**：根据给定值在数据集合中...
九宫问题的广度优先java实现
05-08
这个问题有助于理解回溯法、深度优先搜索（DFS）以及广度优先搜索（BFS）等算法。在这个场景中，我们将讨论如何使用Java语言来实现基于广度优先搜索的九宫格问题解决方案。 首先，让我们解析给定的文件信息： 标题...
深度优先搜索与广度优先搜索
Hopefully Sky的博客
07-10 7509
算法是作用于具体数据结构之上的，深度优先搜索算法和广度优先搜索算法都是基于“图”这种数据结构的。
深度优先和广度优先算法
bgogo的博客
10-18 8714
1、深度优先算法 遍历规则：不断地沿着顶点的深度方向遍历。顶点的深度方向是指它的邻接点方向。 最后得出的结果为：ABDECFHG。 Python代码实现的伪代码如下： 2、广度优先算法： 遍历规则： 1）先访问完当前顶点的所有邻接点。(应该看得出广度的意思) 2）先访问顶点的邻接点先于后访问顶点的邻接点被访问。 最后得出的结果为：ABCDEFGH。 Python代码实现的伪代码如下： 3.总结 深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每...
用队列实现bfs & 用栈实现dfs & 用dfs实现bfs
weixin_44284194的博客
04-12 844
样例输入 3 6 2 2 2 3 4 1 样例输出 9 思路： 典型的bfs问题，这里尝试用bfs和dfs两种方法解，旨在练习两者实现方式和对比 样例说明 　　用1表示灌溉到，0表示未灌溉到。 　　打开水管时： 　　000000 　　010000 　　000100 　　1分钟后： 　　010000 　　111100 　　011110 　　共有9个方格被灌溉好。 数据规模和约定 　　对于所有评测用例，1 <= n, m <= 100, 1 <= t <= 10, 1 <= .
深度优先算法和广度优先算法
weixin_44456232的博客
08-11 2628
1、深度优先算法 遍历规则： 不断地沿着顶点的深度方向遍历。顶点的深度方向是指它的邻接点方向。 最后得出的结果为：ABDECFHG。 类似于二叉树的前序遍历 2、广度优先算法： 遍历规则： 先访问完当前顶点的所有邻接点。(应该看得出广度的意思) 先访问顶点的邻接点先于后访问顶点的邻接点被访问。 最后得出的结果为：ABCDEFGH。 类似于二叉树的层序遍历 ...
BFS算法和DFS算法（含图解：简单易懂）
热门推荐
qian_yu_的博客
08-30 4万+
图解BFS算法和DFS算法BFS算法算法思路实现过程Python代码实现DFS算法算法思路实现过程Python代码实现 BFS算法 BFS类似于树的层次遍历过程,从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。 舍去空间换时间。 算法思路 队列（先进先出） 1、创建一个空队列queue（用来存放节点）和一个空列表visit（用来存放已访问的节点） 2、依次将起始点及邻接点加入queue和visit中 3、poo出队
深度优先搜索和广度优先搜索的比较与分析
木牛的博客
04-29 5970
深度优先搜索和广度优先搜索的深入讨论 （一）深度优先搜索的特点是： （1）无论问题的内容和性质以及求解要求如何不同，它们的程序结构都是相同的，即都是深度优先算法（一）和深度优先算法（二）中描述的算法结构，不相同的仅仅是存储结点数据结构和产生规则以及输出要求。 （2）深度优先搜索法有递归以及非递归两种设计方法。一般的，当搜索深度较小、问题递归方式比较明显时，用递归方法设计好，它可以使得程序结构更简捷易懂。当搜索深度较大时，当数据量较大时，由于系统堆栈容量的限制，递归容易产生溢出，用非递归方法设计比.
【算法】广度优先遍历 (BFS)
代码星辰的博客
01-11 9679
本文介绍了 BFS 的概述、代码实现以及应用。
C++实现：综合使用A*算法，广度优先算法和深度优先算法实现九宫重排
06-02
好的，下面我将为你提供C++实现。首先，我们需要定义一个节点类，用来保存每个状态的信息和路径： ```c++ class Node { public: string state; // 当前状态 int depth; // 路径长度 string path; // 路径 Node(string state, int depth, string path) : state(state), depth(depth), path(path) {} }; ``` 接下来，我们分别实现A*算法，广度优先算法和深度优先算法。 1. A*算法 ```c++ string astar(string start, string end) { unordered_map<string, int> depth; // 用于记录状态的深度 unordered_map<string, string> path; // 用于记录状态的路径 priority_queue<pair<int, Node*>, vector<pair<int, Node*>>, greater<pair<int, Node*>>> pq; // 用于存储待扩展节点 pq.push({manhattan(start, end), new Node(start, 0, "")}); // 将初始状态加入到pq中 depth[start] = 0; // 初始状态的深度为0 while (!pq.empty()) { auto cur = pq.top().second; // 取出f值最小的节点 pq.pop(); if (cur->state == end) return cur->path; // 找到目标状态，返回路径 if (depth[cur->state] < cur->depth) continue; // 已经扩展过的状态不再扩展 for (auto next : get_next_states(cur->state)) { // 扩展当前节点 int d = cur->depth + 1; // 子节点的深度为父节点的深度加1 if (!depth.count(next) || d < depth[next]) { // 如果子节点未被扩展或者新路径更优 depth[next] = d; // 记录子节点的深度 path[next] = cur->path + direction(next, cur->state); // 记录子节点的路径 pq.push({d + manhattan(next, end), new Node(next, d, path[next])}); // 将子节点加入pq中 } } } return ""; // 没有找到目标状态，返回空路径 } ``` 在上面的代码中，我们使用了一个优先队列pq来存储待扩展的节点，其中节点的优先级为f值（即深度加上曼哈顿距离）。对于每个被扩展的节点，我们都生成它的所有合法子节点，并计算它们的f值。如果子节点未被扩展或者新路径更优，就将子节点加入到pq中。 2. 广度优先算法 ```c++ string bfs(string start, string end) { unordered_map<string, int> depth; // 用于记录状态的深度 unordered_map<string, string> path; // 用于记录状态的路径 queue<Node*> q; // 用于存储待扩展节点 q.push(new Node(start, 0, "")); // 将初始状态加入到q中 depth[start] = 0; // 初始状态的深度为0 while (!q.empty()) { auto cur = q.front(); // 取出队列中的第一个节点 q.pop(); if (cur->state == end) return cur->path; // 找到目标状态，返回路径 for (auto next : get_next_states(cur->state)) { // 扩展当前节点 int d = cur->depth + 1; // 子节点的深度为父节点的深度加1 if (!depth.count(next)) { // 如果子节点未被扩展 depth[next] = d; // 记录子节点的深度 path[next] = cur->path + direction(next, cur->state); // 记录子节点的路径 q.push(new Node(next, d, path[next])); // 将子节点加入到q中 } } } return ""; // 没有找到目标状态，返回空路径 } ``` 在上面的代码中，我们使用了一个队列q来存储待扩展的节点。对于每个被扩展的节点，我们都生成它的所有合法子节点，并将未被扩展的子节点加入到q中。 3. 深度优先算法 ```c++ string dfs(string start, string end, int max_depth) { unordered_map<string, int> depth; // 用于记录状态的深度 unordered_map<string, string> path; // 用于记录状态的路径 stack<Node*> s; // 用于存储待扩展节点 s.push(new Node(start, 0, "")); // 将初始状态加入到s中 depth[start] = 0; // 初始状态的深度为0 while (!s.empty()) { auto cur = s.top(); // 取出栈顶的节点 s.pop(); if (cur->state == end) return cur->path; // 找到目标状态，返回路径 if (cur->depth >= max_depth) continue; // 如果达到最大深度，不再扩展 for (auto next : get_next_states(cur->state)) { // 扩展当前节点 int d = cur->depth + 1; // 子节点的深度为父节点的深度加1 if (!depth.count(next)) { // 如果子节点未被扩展 depth[next] = d; // 记录子节点的深度 path[next] = cur->path + direction(next, cur->state); // 记录子节点的路径 s.push(new Node(next, d, path[next])); // 将子节点加入到s中 } } } return ""; // 没有找到目标状态，返回空路径 } ``` 在上面的代码中，我们使用了一个栈s来存储待扩展的节点。对于每个被扩展的节点，我们都生成它的所有合法子节点，并将未被扩展且深度未达到最大深度的子节点加入到s中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值