深度优先搜索(DFS)的几个问题

最新推荐文章于 2024-09-25 13:54:13 发布
最新推荐文章于 2024-09-25 13:54:13 发布
阅读量39 收藏
点赞数 1
分类专栏： 算法与数据结构 文章标签： 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DaisyMaria/article/details/140750930
版权

总的来说，这些题都是第一道题的变形题 

1.迷宫可行路径数

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<cstdio>

const int MAXN = 5;
int n, m, maze[MAXN][MAXN];
bool visited[MAXN][MAXN] = { false };//标记迷宫中的每个位置是否已经访问过，默认为 false
int counter = 0;

const int MAXD = 4;//定义了方向的数量，这里是四个方向：上、下、左、右。

//简化在二维空间中的方向移动操作
//分别定义了在 x 和 y 方向上的移动增量，用来方便地遍历四个方向。
int dx[MAXD] = { 0, 0, 1, -1 };

//dx[0] = 0：表示在 x 方向上不移动（保持当前列）
//dx[2] = 1：表示在 x 方向上向右移动一个单位
//dx[3] =-1：表示在 x 方向上向左移动一个单位。
int dy[MAXD] = { 1, -1, 0, 0 };
//            向 下|上移动

bool isValid(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 0 && !visited[x][y];
}//   不能越过左壁     右壁     上壁      下壁        此处为平地         此处未被访问

void DFS(int x, int y) {
    if (x == n - 1 && y == m - 1) {//如果当前位置 (x, y) 到达了迷宫的右下角 (n-1, m-1)，
        counter++;
        //则将 counter 计数器加一，表示找到了一条从起点到终点的路径
        return;
    }

    visited[x][y] = true;//现标注将此时所处位置已被访问

    for (int i = 0; i < MAXD; i++) {//依据下→上→右→左的顺序依次遍历，
        int nextX = x + dx[i];
        int nextY = y + dy[i];
        if (isValid(nextX, nextY)) {//如果isValid判断无效则再次进入for循环换一个方向遍历
            DFS(nextX, nextY);
        }
    }
    visited[x][y] = false;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &maze[i][j]);
        }
    }
    DFS(0, 0);
    printf("%d", counter);
    return 0;
}

2.指定步数的迷宫问题

对DFS函数判断稍作修改

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<cstdio>

const int MAXN = 5;
int n, m, k, maze[MAXN][MAXN];
bool visited[MAXN][MAXN] = { false };//标记迷宫中的每个位置是否已经访问过，默认为 false
bool canReach = false;
const int MAXD = 4;//定义了方向的数量，这里是四个方向：上、下、左、右。

//简化在二维空间中的方向移动操作
//分别定义了在 x 和 y 方向上的移动增量，用来方便地遍历四个方向。
int dx[MAXD] = { 0, 0, 1, -1 };

//dx[0] = 0：表示在 x 方向上不移动（保持当前列）
//dx[2] = 1：表示在 x 方向上向右移动一个单位
//dx[3] =-1：表示在 x 方向上向左移动一个单位。
int dy[MAXD] = { 1, -1, 0, 0 };
//            向 下|上移动

bool isValid(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 0 && !visited[x][y];
}//   不能越过左壁     右壁     上壁      下壁        此处为平地         此处未被访问

void DFS(int x, int y, int step) {
    if (canReach)return;

    if (x == n - 1 && y == m - 1) {//如果当前位置 (x, y) 到达了迷宫的右下角 (n-1, m-1)，
        if (step == k) {
            canReach = true;
        }
        return;
    }

    visited[x][y] = true;//现标注将此时所处位置已被访问

    for (int i = 0; i < MAXD; i++) {//依据下→上→右→左的顺序依次遍历，
        int nextX = x + dx[i];
        int nextY = y + dy[i];
        if (isValid(nextX, nextY)) {//如果isValid判断无效则再次进入for循环换一个方向遍历
            DFS(nextX, nextY, step + 1);
        }
    }
    visited[x][y] = false;
}

int main() {
    scanf("%d%d%d", &n, &m,&k);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &maze[i][j]);
        }
    }
    DFS(0, 0, 0);
    printf(canReach ? "Yes" : "No");
    return 0;
}

3.矩阵的最大值

结合1.迷宫可行路径数，代码如下:

#define _CRT_SECURE_NO_WARNINGS
#include<cstdio>

const int MAXN = 5;
const int INF = 0x3f3f3f3f;
int n, m, maze[MAXN][MAXN];
bool visited[MAXN][MAXN] = { false };//标记迷宫中的每个位置是否已经访问过，默认为 false
int maxValue = -INF;

const int MAXD = 4;//定义了方向的数量，这里是四个方向：上、下、左、右。
//简化在二维空间中的方向移动操作
//分别定义了在 x 和 y 方向上的移动增量，用来方便地遍历四个方向。
int dx[MAXD] = { 0, 0, 1, -1 };
//dx[0] = 0：表示在 x 方向上不移动（保持当前列）
//dx[2] = 1：表示在 x 方向上向右移动一个单位
//dx[3] =-1：表示在 x 方向上向左移动一个单位。
int dy[MAXD] = { 1, -1, 0, 0 };
//            向 下|上移动

bool isValid(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && !visited[x][y];
}//   不能越过左壁     右壁     上壁      下壁     此处未被访问

void DFS(int x, int y, int nowValue) {
    if (x == n - 1 && y == m - 1) {//如果当前位置 (x, y) 到达了迷宫的右下角 (n-1, m-1)，
        if (nowValue>maxValue) {
            maxValue = nowValue;
        }
        return;
    }

    visited[x][y] = true;//现标注将此时所处位置已被访问

    for (int i = 0; i < MAXD; i++) {//依据下→上→右→左的顺序依次遍历，
        int nextX = x + dx[i];
        int nextY = y + dy[i];
        if (isValid(nextX, nextY)) {//如果isValid判断无效则再次进入for循环换一个方向遍历
            int nextValue = nowValue + maze[nextX][nextY];
            DFS(nextX, nextY, nextValue);
        }
    }
    visited[x][y] = false;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &maze[i][j]);
        }
    }
    DFS(0, 0, maze[0][0]);
    printf("%d", maxValue);
    return 0;
}

注意以下代码：

const int INF = 0x3f3f3f3f;
... ...
int maxValue = -INF;

在这段代码中，定义 const int INF = 0x3f3f3f3f; 是为了表示一个无穷大的值，它实际上是十进制数 1061109567。这种表示方法通常用于算法中，特别是在动态规划或者搜索问题中，用来表示一个足够大的数值，作为无穷大的替代。

而为什么 int maxValue = -INF; 呢？这是因为在初始化时，我们希望 maxValue 初始值是一个负的无穷小，这样在搜索过程中能够确保任何有效的路径值都可以比较并更新 maxValue。因此，将 maxValue 初始化为 -INF 是为了确保它可以在后续的搜索中被正确更新为任何有效路径的最大值。

总结起来，INF 和 -INF 的定义和使用是为了方便地处理路径搜索中的最大值问题，确保代码的逻辑和比较操作都能正确处理各种可能的路径值。

4.矩阵最大权值路径

#define _CRT_SECURE_NO_WARNINGS
#include<cstdio>
#include<vector>
#include<utility>

using namespace std;

typedef pair<int, int> Position;

const int MAXN = 5;
const int INF = 0x3f;
int n, m, maze[MAXN][MAXN];
bool visited[MAXN][MAXN] = { false };//标记迷宫中的每个位置是否已经访问过，默认为 false
int maxValue = -INF;
vector<Position>tempPath, optPath;
//tempPath 用来暂时存储当前探索的路径，而 optPath 则记录找到的最优路径。

const int MAXD = 4;//定义了方向的数量，这里是四个方向：上、下、左、右。
//简化在二维空间中的方向移动操作
//分别定义了在 x 和 y 方向上的移动增量，用来方便地遍历四个方向。
int dx[MAXD] = { 0, 0, 1, -1 };
//dx[0] = 0：表示在 x 方向上不移动（保持当前列）
//dx[2] = 1：表示在 x 方向上向右移动一个单位
//dx[2] =-1：表示在 x 方向上向左移动一个单位。
int dy[MAXD] = { 1, -1, 0, 0 };
//            向 下|上移动

bool isValid(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && !visited[x][y];
}//   不能越过左壁     右壁     上壁      下壁     此处未被访问

void DFS(int x, int y, int nowValue) {
    if (x == n - 1 && y == m - 1) {
//如果当前位置是迷宫的终点 (n-1, m-1)，则更新最大价值路径 maxValue 和最优路径 optPath。
        if (nowValue>maxValue) {
            maxValue = nowValue;
            optPath=tempPath;
        }
        return;
    }

    visited[x][y] = true;//现标注将此时所处位置已被访问

    for (int i = 0; i < MAXD; i++) {//依据下→上→右→左的顺序依次遍历，
        int nextX = x + dx[i];
        int nextY = y + dy[i];
        if (isValid(nextX, nextY)) {//如果isValid判断无效则再次进入for循环换一个方向遍历
            int nextValue = nowValue + maze[nextX][nextY];
            
            tempPath.push_back(Position(nextX, nextY));
            //tempPath 用来暂时存储当前探索路径，每次递归调用前将下一个位置加入 tempPath，递归结束后再将其移除
            
            DFS(nextX, nextY, nextValue);
            tempPath.pop_back();
            //如果该路径走不通则弹出
        }
    }
    visited[x][y] = false;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &maze[i][j]);
        }
    }
    tempPath.push_back(Position(0, 0));
    DFS(0, 0, maze[0][0]);
    for (int i = 0; i < optPath.size(); i++)
    {
        printf("%d %d\n", optPath[i].first + 1, optPath[i].second + 1);
        //最后输出最优路径 optPath 中的每个位置。
    }

    return 0;
}

这道题与 3.矩阵的最大值 不同的是要求输出路径坐标，坐标的输出可以考虑用STL中的pair，在递归过程中存储路径可以考虑用vector存储pair。

5.迷宫最大权值

这道题结合了1.迷宫可行路径数以及3.矩阵的最大值，即需要结合两个路径矩阵进行判断，修改结合了这两题的代码后，得到的代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<cstdio>
//#include<vector>
//#include<utility>

using namespace std;

//typedef pair<int, int> Position;

const int MAXN = 5;
const int INF = 0x3f;
int n, m, maze[MAXN][MAXN],isWall[MAXN][MAXN];
bool visited[MAXN][MAXN] = { false };//标记迷宫中的每个位置是否已经访问过，默认为 false
int maxValue = -INF;
//vector<Position>tempPath, optPath;
//tempPath 用来暂时存储当前探索的路径，而 optPath 则记录找到的最优路径。

const int MAXD = 4;//定义了方向的数量，这里是四个方向：上、下、左、右。
//简化在二维空间中的方向移动操作
//分别定义了在 x 和 y 方向上的移动增量，用来方便地遍历四个方向。
int dx[MAXD] = { 0, 0, 1, -1 };
//dx[0] = 0：表示在 x 方向上不移动（保持当前列）
//dx[2] = 1：表示在 x 方向上向右移动一个单位
//dx[2] =-1：表示在 x 方向上向左移动一个单位。
int dy[MAXD] = { 1, -1, 0, 0 };
//            向 下|上移动

bool isValid(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m &&!isWall[x][y]&& !visited[x][y];
}//   不能越过左壁     右壁     上壁      下壁     此处未被访问

void DFS(int x, int y, int nowValue) {
    if (x == n - 1 && y == m - 1) {
//如果当前位置是迷宫的终点 (n-1, m-1)，则更新最大价值路径 maxValue 和最优路径 optPath。
        if (nowValue>maxValue) {
            maxValue = nowValue;
            //optPath=tempPath;
        }
        return;
    }

    visited[x][y] = true;//现标注将此时所处位置已被访问

    for (int i = 0; i < MAXD; i++) {//依据下→上→右→左的顺序依次遍历，
        int nextX = x + dx[i];
        int nextY = y + dy[i];
        if (isValid(nextX, nextY)) {//如果isValid判断无效则再次进入for循环换一个方向遍历
            int nextValue = nowValue + maze[nextX][nextY];
            
            //tempPath.push_back(Position(nextX, nextY));
            //tempPath 用来暂时存储当前探索路径，每次递归调用前将下一个位置加入 tempPath，递归结束后再将其移除
            
            DFS(nextX, nextY, nextValue);
            //tempPath.pop_back();
        }
    }
    visited[x][y] = false;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &isWall[i][j]);
        }
    }

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            scanf("%d", &maze[i][j]);
        }
    }

    //tempPath.push_back(Position(0, 0));
    DFS(0, 0, maze[0][0]);
    printf("%d", maxValue);

    return 0;
}
Hilda Leung
关注
专栏目录
C/C++ 深度优先搜索DFS算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-17 6596
深度优先搜索（DFS）是一种用于遍历或搜索图或树的算法。其基本思想是从一个顶点开始，沿着一条路径尽可能地深入，直到不能再继续为止，然后回退到上一个顶点，再选择一条未被访问过的路径继续深入。
DFS深度优先搜索
咸鱼势力登场
06-28 1万+
一、DFS的概念 {DFS的定义 DFS的搜索方式 DFS采用的数据结构 DFS的特点} 二、DFS的实战应用 {1.排列数字 2.n-皇后问题}
（dfs）（深度优先搜索算法）
2302_80364740的博客
01-23 4188
深度优先搜索。
深度优先搜索（DFS）（算法笔记）
Arabot_的博客
03-22 8986
深度优先搜索是一种枚举所有完整路径以遍历所有情况的搜索方法，总是以“深度”作为前进的关键词。实现方式是有很多，最常见的是递归。深度优先搜索属于搜索问题的一种，当问题可以被描述为“路径搜索”时，就可以采用搜素问题的所有解的方式来进行解决，所以DFS本质还是暴力。深度搜索具有两个关键词，即“岔道口”和“死胡同”，这两个词来源于迷宫问题，这也是搜索问题最原始的表现。当碰到岔道口时，总是以“深度”作为前进的关键词，不碰到死胡同就不回头，因此被称为“深搜”。
【C++】深度优先搜索DFS
2401_83006196的博客
03-11 462
C++深度优先搜索（DFS）是一种使用递归或栈的算法，用于在图或树等数据结构中遍历所有可能的路径，直到找到目标节点或遍历完所有节点。
深度优先搜索DFS总结
m0_52246399的博客
01-27 365
1.前言 本篇文章是为了准备蓝桥杯而去写的一篇深度优先搜索DFS的笔记，包括知识点，模板，和例题。 2.DFS简介 3.DFS模板 4.相关例题 5.总结
深度优先算法 DFS总结(算法详解+模板+例题)
Alex_Fufu的博客
08-09 1751
沿着树的深度遍历树的节点，尽可能深的搜索树的分支。共 m+1 行，第 1 行为 2 个数，n 和 m，分别表示一共有 n(n≤105) 篇文章（编号为 1 到 n）以及m(m≤106) 条参考文献引用关系。一个如下的 6×6 的跳棋棋盘，有六个棋子被放置在棋盘上，使得每行、每列有且只有一个，每条对角线（包括两条主对角线的所有平行线）上至多有一个棋子。有一个 n \times mn×m 的棋盘，在某个点 (x, y)(x,y) 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。
深度优先遍历DFS(邻链表版本)
xingloving的博客
05-03 1895
深度优先遍历DFS(邻链表版本)代码及解析
DFS (深度优先搜索) 算法详解 + 模板 + 例题，这一篇就够了
热门推荐
Layman的博客
04-10 10万+
俗称的“不撞南墙不回头算法”！！！在本篇文章中详细介绍了DFS算法的基本步骤，详解了包括，排列组合问题、n皇后问题、素数问题等DFS的基本例题，后续会不断补充例题！！！
【DFS（深度优先搜索）详解】看这一篇就够啦
2202_76097976的博客
07-08 3847
DFS算法的基本思想是从图中的某个顶点v出发，访问此顶点，然后依次从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v有路径相通的顶点都被访问到。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始点，重复上述过程，整个进程反复进行直到所有顶点都被访问为止。指数型枚举是指一共有n个数，每一个数都有两种状态，也就是选或不选，时间复杂度也就是2^n，指数级的。
递归回溯深度优先搜索DFS练习题（含C++源码）
02-10
深度优先搜索（Depth First Search，简称DFS）是一种用于遍历或搜索树或图的算法，它按照“尽可能深”的原则访问节点，直到达到叶节点或回溯到无新节点可访问时为止。在这个过程中，DFS通常与递归和回溯策略结合使用...
DFS.zip_深度优先搜索
09-20
`老鼠娶妻（优先搜索）.cpp`是实现DFS算法的C++代码，它可能包含以下几个部分： 1. 定义数据结构：用于存储图的节点、边以及节点的状态（已访问、未访问等）。 2. DFS函数：作为主要的搜索逻辑，接收当前节点和目标...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5153
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 484
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
【优选算法】（第一篇）
最新发布
weixin_73861555的博客
09-25 969
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
【算法笔记】二分查找 红蓝染色法
weixin_51325964的博客
09-23 793
一个菜鸟的算法笔记
C语言题目之单身狗2
something for nothing的博客
09-22 498
c语言题目之找单身狗2：在一堆数中找到两个只出现过一次数的数
文档矫正算法：DocTr++
Guo_Python的博客
09-23 390
论文提出了一种新的数据处理方式，解决了以前文档矫正只能处理带有边界信息的完整文档，文章通过数据处理定义了三种类型的训练数据。（a）包含完整文档边界，（b）包含部分文档边界，（c）不包含文档边界。算法框架如下：对于任意弯曲的文档，作者首先通过CNN抽取特征，然后通过transformer结构进行编码和解码，最后用Flow Head预测偏移场，用偏移场矫正弯曲图片。
大数据新视界 --大数据大厂之算法在大数据中的核心作用：提升效率与智能决策
青云交的博客
09-20 2594
本文深入剖析算法在大数据中的核心作用。从提升大数据处理效率和助力智能决策两方面展开，涵盖数据过滤与清洗、并行计算优化等多种算法，结合实际案例与代码示例，阐述其原理、优势、局限性及优化方法。强调算法与新兴技术融合的未来发展方向，同时关注安全性、伦理和社会责任。呼吁读者参与互动讨论，分享算法应用经验及对未来发展的期待建议。
C++实现图的深度优先搜索(DFS)算法
在给定的代码中，首先定义了几个常量和类型定义，如`TRUE`和`FALSE`表示布尔值，`MAX_NAME`表示最大顶点名称长度，`MAX_VERTEX_NUM`表示图的最大顶点数。`AdjMatrix`定义了一个邻接矩阵，用于存储图的边信息，每个`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值