【数据结构题集】深度优先搜索算法（DFS）+vector容器的使用+pair工具使用---迷宫可行路径数、指定步数的迷宫问题、迷宫问题、矩阵最大权值以及路径问题、迷宫最大权值

已于 2022-07-05 10:45:52 修改
阅读量855 收藏 10
点赞数 4
分类专栏： 数据结构 算法 文章标签： 数据结构 深度优先 算法 蓝桥杯
于 2022-07-04 09:46:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51538341/article/details/125593757
版权

   本篇文章有一些知识点，需要提前了解，这些原理都能搜到，也很好理解，玛卡不在此赘述了~

①DFS算法是什么，递归可以更好地实现深度优先算法，举例Fibonacci数列，更细分到底层，F(0) F(1)可以看成死胡同，使用栈来实现。 

②矩阵类问题 需要用到vector容器、pair工具以及其头文件，内部的函数如push_back等

①迷宫可行路径数（最基本迷宫问题、矩阵移动问题）

题目描述

       现有一个n∗m大小的迷宫，其中1表示不可通过的墙壁，0表示平地。每次移动只能向上下左右移动一格（不允许移动到曾经经过的位置），且只能移动到平地上。求从迷宫左上角到右下角的所有可行路径的条数。

输入描述

    第一行两个整数n​​​、m​​​（2≤n≤5,2≤m≤5​​​），分别表示迷宫的行数和列数；

    接下来n​行，每行m​个整数（值为0或1），表示迷宫。

输出描述

    一个整数，表示可行路径的条数。

样例1

输入

   3 3

   0 0 0

   0 1 0

   0 0 0

输出 

    2

分析

假设左上角坐标是(1,1)​，行数增加的方向为x​增长的方向，列数增加的方向为y​增长的方向。

可以得到从左上角到右下角有两条路径：

  1. (1,1)​​​=>(1,2)​​​=>(1,3)​​​=>(2,3)​​​=>(3,3)​​​
  2. (1,1)​=>(2,1)​=>(3,1)​=>(3,2)​=>(3,3)​​​

  初始visited[][]全为True，表示未经过的格子。通过DFS()迭代操作，进行上下右左四种操作，每移动一格进行isValid（）判断是否符合标准，符合则将 visited[][]该格子改为False。达到终点则路径数counter加一。

#include <cstdio>

const int MAXN = 5;
int n, m, maze[MAXN][MAXN];
bool visited[MAXN][MAXN] = {false};
int counter = 0;

const int MAXD = 4;
int dx[MAXD] = {0, 0, 1, -1};//指出四种移动方式，上下右左
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) {  /*到达边界则将路径+1，通过下面的迭代出
                                                      来的数据反复进行操作*/
        counter++;
        return;
    }
    visited[x][y] = true;             //未被走过为True，走过为Flase
    for (int i = 0; i < MAXD; i++) {  //用dx[]dy[]来实现上下右左移动操作
        int nextX = x + dx[i];
        int nextY = y + dy[i];
        if (isValid(nextX, nextY)) {   /*移动后的位置若合法且可通过，则继续进行移动操作
                                           通过迭代实现*/
            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);                       //执行DFS()，即左上端点为起点
    printf("%d", counter);
    return 0;
}

② 指定步数的迷宫问题

  题目描述

现有一个n∗m大小的迷宫，其中1表示不可通过的墙壁，0表示平地。每次移动只能向上下左右移动一格（不允许移动到曾经经过的位置），且只能移动到平地上。现从迷宫左上角出发，问能否在恰好第k步时到达右下角。

 输入描述

       第一行三个整数n​​​​、m​​​​、k​​（2≤n≤5,2≤m≤5,2≤k≤n∗m​​​​），分别表示迷宫的行数、列数、移动的步数；接下来n​行，每行m​个整数（值为0或1），表示迷宫。

输出描述

   如果可行，那么输出Yes，否则输出No。

输入

3 3 4

0 1 0

0 0 0

0 1 0

输出

Yes

#include <cstdio>

const int MAXN = 5;
int n, m, k, maze[MAXN][MAXN];
bool visited[MAXN][MAXN] = {false};
bool canReach = false;

const int MAXD = 4;
int dx[MAXD] = {0, 0, 1, -1};
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) {
        if (step == k) {
            canReach = true; //通过设置canReach来记录是否为规定步数
        }
        return;
    }
    visited[x][y] = true;
    for (int i = 0; i < MAXD; i++) {
        int nextX = x + dx[i];
        int nextY = y + dy[i];
        if (step < k && isValid(nextX, nextY)) {
            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;
}

 ③矩阵最大权值问题

  题目描述

现有一个n∗m大小的矩阵，矩阵中的每个元素表示该位置的权值。现需要从矩阵左上角出发到达右下角，每次移动只能向上下左右移动一格（不允许移动到曾经经过的位置）。求最后到达右下角时路径上所有位置的权值之和的最大值。

 输入描述

    第一行两个整数n​​​、m​​​（2≤n≤5,2≤m≤5​​​），分别表示矩阵的行数和列数；

接下来n​​​行，每行m​​​个整数（−100≤​​整数≤100​​​），表示矩阵每个位置的权值。

输出描述

 一个整数，表示权值之和的最大值。

输入

2 2

1 2

3 4

输出

8

#include <cstdio>

const int MAXN = 5;
const int INF = 0x3f;
int n, m, maze[MAXN][MAXN];
bool visited[MAXN][MAXN] = {false};
int maxValue = -INF;

const int MAXD = 4;
int dx[MAXD] = {0, 0, 1, -1};
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) {    
        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)) {
            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;
}

 ④矩阵最大权值的路径

  题目描述

现有一个n∗m大小的矩阵，矩阵中的每个元素表示该位置的权值。现需要从矩阵左上角出发到达右下角，每次移动只能向上下左右移动一格（不允许移动到曾经经过的位置）。假设左上角坐标是(1,1)，行数增加的方向为x增长的方向，列数增加的方向为y​增长的方向。求最后到达右下角时路径上所有位置的权值之和最大的路径。

 输入描述

第一行两个整数n​​​、m​​​（2≤n≤5,2≤m≤5​​​），分别表示矩阵的行数和列数；

接下来n​​​行，每行m​​​个整数（−100≤​​整数≤100​​​），表示矩阵每个位置的权值。

输出描述

从左上角的坐标开始，输出若干行（每行两个整数，表示一个坐标），直到右下角的坐标。

数据保证权值之和最大的路径存在且唯一。

输入

2 2

1 2

3 4

输出

1 1 

2 1

2 2

#include <cstdio>
#include <vector>
#include <utility>
using namespace std;

typedef pair<int, int> Position;  //使用pair将某位置的x，y值合为一体，不需要使用struct

const int MAXN = 5;
const int INF = 0x3f;
int n, m, maze[MAXN][MAXN];
bool visited[MAXN][MAXN] = {false};
int maxValue = -INF;
vector<Position> tempPath, optPath;  //分为临时位置和最后位置，vector可理解为可变长数组

const int MAXD = 4;
int dx[MAXD] = {0, 0, 1, -1};
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) {
        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)) {
            int nextValue = nowValue + maze[nextX][nextY];
            tempPath.push_back(Position(nextX, nextY));  //该点存入临时位置
            DFS(nextX, nextY, nextValue);          //临时位置被迭代到新的DFS里
            tempPath.pop_back();                   //将临时位置清空为0，方便存储新位置
        }
    }
    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);//.first为pair使用方法
    }
    return 0;
}

 ⑤迷宫最大权值（此类问题经常出现，迷宫夺宝什么的）

  题目描述

现有一个n∗m​大小的迷宫，其中1表示不可通过的墙壁，0表示平地。现需要从迷宫左上角出发到达右下角，每次移动只能向上下左右移动一格（不允许移动到曾经经过的位置），且只能移动到平地上。假设迷宫中每个位置都有权值，求最后到达右下角时路径上所有位置的权值之和的最大值。

 输入描述

第一行两个整数n​​​、m​​​（2≤n≤5,2≤m≤5​​​），分别表示矩阵的行数和列数；

接下来n行，每行m个整数（值为0或1），表示迷宫。

再接下来n​​​行，每行m​​​个整数（−100≤​​整数≤100​​​），表示迷宫每个位置的权值。

输出描述

一个整数，表示权值之和的最大值。

输入

3 3 

0 0 0

0 1 0

0 0 0

1 2 3

4 5 6

7 8 9

输出

29

 从左上角到右下角的最大权值之和为1+4+7+8+9=29​。

#include <cstdio>

const int MAXN = 5;
const int INF = 0x3f;
int n, m, maze[MAXN][MAXN], isWall[MAXN][MAXN];
bool visited[MAXN][MAXN] = {false};
int maxValue = -INF;

const int MAXD = 4;
int dx[MAXD] = {0, 0, 1, -1};
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) {
        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)) {
            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", &isWall[i][j]);
        }
    }
    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;
}

玛卡巴卡
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【POJ 3984】 迷宫问题 简单DFS + 路径记录
待到山花烂漫时
05-15 472
Description 定义一个二维数组： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 Input 一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。 Output 左上角到右下角的最短路径，格式如样例所示。 Sam
问题 A: 迷宫问题（路径数量）
熬夜的Alan Walker
10-31 1050
时间限制:1 Sec内存限制:128 MB 题目描述 设有一个N*N（2<=N<=10）方格的迷宫，入口和出口分别在左上角和右上角。迷宫格子中分别放0和1，0表示可通，1表示不能通过，入口和出口处肯定是0.迷宫走的规则如下所示：即从某点开始，有八个方向可走，前进方格中数字为0时表示可通过，为1时表示不可以通过，要另找路径。找出所有从入口（左上角）到出口（右上角）的路径（不能重复）,输出路径总数，如果无法到达，则输出0. 输入 第一行方格迷宫的大小n 接着n行，每行n列，数...
DFS递归+递归函数模板+vector的注意事项
Sti1lWater的博客
03-14 176
DFS vector
二分图 【dfs】+【vector】
lzs_lazy
04-04 251
给定一个具有n个顶点的图，要给图上每个顶点 都上色，并且相邻的两个点之间的颜色还要不一样，问是否能最多用2中颜色进行染色？ 题目保证没有重边和自环 。。 思路 ： 就是一个 整个图的遍历问题 ，可以用DFS ；并用邻接表来存储 图 （vector） 代码#include<stdio.h> #include<string.h> #include<algorithm> #include<iostr
迷宫的所有路径（回溯DFS）
最新发布
m0_72121170的博客
08-07 691
【代码】迷宫的所有路径（回溯DFS）
数据结构 迷宫问题
12-21
在IT领域，迷宫问题是一种常见的算法挑战，它涉及到数据结构和搜索算法的应用。在这个问题中，我们通常有一个二维网格代表迷宫，其中每个单元格可能是可通行的空地或障碍物。目标是从起点到达终点，同时避开障碍物。...
AAA.zip_数据结构_Visual_C++_
08-11
在这个案例中，我们可以考虑使用宽度优先搜索（BFS）或者深度优先搜索（DFS）策略，但这里强调的是非递归的BFS实现。 宽度优先搜索是一种从起点开始，逐层遍历所有可能路径的搜索策略。它使用队列来存储待访问的...
迷宫代码C++
06-25
在IT领域，迷宫算法是一种常见的路径搜索问题，它涉及到图论、数据结构以及算法设计。C++作为一款强大的编程语言，常被用于实现这类复杂计算。本篇将深入探讨迷宫算法及其C++实现，同时关注STL（Standard Template ...
c++代码实现走迷宫.rar_C++_c++实现走迷宫_maze_编程走迷宫_走迷宫 C++
09-14
综上所述，"c++代码实现走迷宫"项目涵盖了C++基础、图和数组的使用、深度优先搜索与广度优先搜索算法，以及基本的文件操作。通过学习和实践这个项目，开发者可以提升在解决复杂问题和算法设计方面的能力。
migong.rar_自动生成迷宫
09-21
首先，迷宫生成通常采用深度优先搜索（DFS）或广度优先搜索（BFS）算法。DFS常用于生成迷宫，因为它可以确保迷宫的连通性，避免形成死胡同。在C++中，我们可以通过递归的方式来实现DFS，每次选择一个未访问过的相邻...
深度优先搜索（DFS）（算法笔记）
Arabot_的博客
03-22 8362
深度优先搜索是一种枚举所有完整路径以遍历所有情况的搜索方法，总是以“深度”作为前进的关键词。实现方式是有很多，最常见的是递归。深度优先搜索属于搜索问题的一种，当问题可以被描述为“路径搜索”时，就可以采用搜素问题的所有解的方式来进行解决，所以DFS本质还是暴力。深度搜索具有两个关键词，即“岔道口”和“死胡同”，这两个词来源于迷宫问题，这也是搜索问题最原始的表现。当碰到岔道口时，总是以“深度”作为前进的关键词，不碰到死胡同就不回头，因此被称为“深搜”。
DS图遍历--深度优先搜索
z-k的博客
10-30 1065
给出一个图的邻接矩阵，对图进行深度优先搜索，从顶点0开始 注意：图n个顶点编号从0到n-1 输入   第一行输入t，表示有t个测试实例 第二行输入n，表示第1个图有n个结点 第三行起，每行输入邻接矩阵的一行，以此类推输入n行 第i个结点与其他结点如果相连则为1，无连接则为0，数据之间用空格隔开 以此类推输入下一个示例 输出 每行输出一个图的深度优先搜索结果，结点编号之间用空格隔...
迷宫的最优路径
u010256924的专栏
10-28 1121
对于迷宫最优路径，其中之一方法就是把所有路径都找出来，
[算法与数据结构] 走迷宫问题（广度与深度优先算法）
农家小舍
07-14 828
迷宫问题与图遍历 算法简介 辅助结构 辅助函数 深度优先搜索 广度优先搜索 两种搜索与最短路径 算法简介 我们常遇到的走迷宫问题，其实就是利用图的遍历（Traversing Graph）来求解图的连通性，常见的两种遍历方法： 深度优先搜索（Depth-First Search）：类似于树的先根遍历；从某点出发，遍历‘未被访问的’临节点，然后重复此过程（找到一个未访问的临节点...
数据结构_深度优先搜索(C语言)
小黯
04-03 2369
图的遍历 1. 深度优先搜索图文解析 深度优先搜索(Depth First Search，DBS)，遍历过程如下： （1）在图的任意顶点出发（假设从V1出发），首先访问V1 （2）在刚访问过的顶点（V1）的相邻顶点中，找出第一个未被访问的顶点（V2），并访问该顶点（V2） （3）以V2为新顶点，递归重复（1）（2）步骤。 每当找不到未被访问的顶点时，递归程序都会依次回退，一直到初始顶点V1而后退出程序 例如当访问到V6时，递归程序会回退到V7继续查找未被访问的顶点，从而访问到V8 2. 源代码： #i
（最详细合理代码）C++实现图的深度优先遍历、广度优先遍历和拓扑排序算法
qq_45863239的博客
12-10 972
图的邻接矩阵和邻接表矩阵 void createGraph(vector<vector<int>>& edge, vector<vector<int>>& edge1,int start, int end, vector<int> inDegree) { edge[start][end] = 1; edge1[start].push_back(end); } //打印存储的图 void displayGraph(vector&l
《算法导论》22.3 深度优先搜索（含C++代码）
Toby的博客
09-24 1572
本文为《算法导论》22.3 深度优先搜索（含C++代码），欢迎参考！
解7月4号的那道题，计算迷宫中可行路径的条数
#define Refuse_无聊@代码.COM Roy_Nee
09-06 1112
好长时间没写了，瞎忙活了两个来月，一直没什么心思继续下去，今天下午把之前的那道题想了想，挺简单的方法，直接用递归就可以了.用递归可以算出总数，并且可以输出可能的路径。但是效率不佳，由于可能的数据量庞大的情况下，数据量就会很大，这样效率就会不佳，最好用动态规划的方法来求解，按照反写的L的顺序计算出每个点的可能的条数，然后一个层的反写L按照上一层的反写的L计算，每一层反写L交点处的可能路径数在当层L中
迷宫问题 —— 最短路径条数
Scar_Halo
11-08 1335
&nbsp;&nbsp;&nbsp;&nbsp;求迷宫的最短路径条数有多少条，一般方法会超时，这里记录一下模板 &nbsp;&nbsp;&nbsp;&nbsp;简要思路：用ansansans记录到每个点的条数，当新到达的点的新距离小于就旧的距离时，更新新点的ansansans；若新距离等于旧距离，也就是可能是最短路径的时候，就ans新+=ans旧ans_{新} += ans_{旧}ans新​+=a...
迷宫实验岳宇轩1
08-03
在岳宇轩的迷宫实验中，他运用了深度优先搜索算法来解决老鼠走迷宫的问题。数据结构的核心部分是堆栈（栈）的使用，堆栈minPath被设计用于存储最短路径。实验过程分为以下几个步骤： 1. **路径判断与初始化**： ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

玛卡巴卡

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

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

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

打赏作者

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

抵扣说明：

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

余额充值