迷宫问题（进阶版）——深度优先算法

最新推荐文章于 2024-05-01 20:15:53 发布
最新推荐文章于 2024-05-01 20:15:53 发布
阅读量1.3k 收藏 8
点赞数
文章标签： 算法 深度优先 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuwenhao_1/article/details/128650409
版权

之前在学校的刷题网站做了一个元歌找傀儡（迷宫）的题目用的是深度优先算法。

https://mp.csdn.net/mp_blog/creation/editor/128553639

于是乎我找了一个类似的题目（蓝桥杯）来做，进一步练习此算法。当我写完后在leetcode上一看发现还是困难级别的（还好做之前没看，不然我就没信心往下做了）！当然题目有些许不一样，不过稍加修改即可。

下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可以通行的地方。


010000
000100
001001
110000

迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。

对于上面的迷宫，从入口开始，可以按 DRRURRDDDR 的顺序通过迷宫， 一共 101 步。其中 D、U、L、R分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式，其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。

请注意在字典序中 D<L<R<U

然后给出迷宫为：


01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
0100000000101010001101000010100000101010101100101
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

将其转换为：

0,1,0,1,0,1,0,1,0,0,1,0,1,1,0,0,1,0,0,1,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,

0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1,0,1,0,0,1,0,1,

0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,

0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,0,0,1,0,1,1,

0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,

1,1,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,1,0,1,0,1,1,0,0,0,1,1,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,0,1,1,1,

0,0,0,1,1,0,1,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,1,0,0,0,0,0,0,0,

1,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0,

0,0,1,1,1,0,0,0,0,0,1,0,1,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,0,0,0,0,1,0,0,1,

1,1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0,0,1,0,0,0,1,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,

0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,0,1,0,1,

1,1,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,

0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,1,1,0,0,1,1,1,1,0,1,0,0,0,1,1,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,1,1,

1,0,1,0,1,0,1,0,0,1,1,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,1,1,0,0,1,1,1,1,0,1,1,0,1,0,0,0,0,1,0,0,0,

1,0,1,0,1,0,1,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,1,1,0,1,1,1,0,1,0,0,1,

1,0,0,0,0,0,0,0,1,0,1,1,0,0,0,1,0,0,0,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,

1,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,1,1,1,1,0,1,0,1,0,0,1,

0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,0,1,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,1,0,1,1,0,1,1,1,0,0,0,0,1,1,0,1,0,1,

1,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,1,0,

0,0,0,0,1,0,0,0,1,1,0,0,0,0,1,1,0,1,0,1,1,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,

1,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,0,0,0,0,1,

0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,

1,0,1,0,0,0,0,1,0,0,0,1,1,0,0,1,0,0,0,1,0,0,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,0,1,0,

0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,

1,1,0,1,0,0,0,0,0,0,1,0,0,1,1,1,0,1,1,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,0,0,1,0,1,1,0,1,1,1,0,1,0,0,0,

0,0,0,0,0,1,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0,0,0,0,0,0,1,1,0,0,1,1,

1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,1,0,0,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,

1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,1,0,1,1,1,0,1,0,0,0,

0,0,1,1,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,

1,0,0,0,0,0,0,1,1,0,0,1,1,1,0,1,0,1,1,1,0,1,0,0,0,1,0,0,0,1,1,0,1,1,1,0,1,0,1,0,1,1,0,1,1,1,1,0,0,0

对于此类迷宫问题，我最大的体会就是定义全局变量，把该处理的处理好（因为要用到递归，使用全局变量比较方便）于是乎就只剩下深度优先函数的编写，想清楚递归过程，相对而言思路就较为清晰。

思路：

  1. 输入迷宫

  1. 定义到达中点的步数(定义一个很大的值，之后有小于它的值重新赋予它小值）

  1. 到达每一个坐标的步数(定义一个很大的值，之后有小于它的值重新赋予它小值）

以上两点用于实现步数最小的功能

  1. 确定方向---方向的选择无非就是x,y轴坐标的变化

5.为表示出路径，定义一个字符串数组进行存储；

6.进行截枝。（这可以之后在编写递归函数时考虑）

7.便是编写dfs函数，

  1. 值得注意的是 对于x,y 的使用，首先是坐标与方向的对应，如确定方向的截图。

二是迷宫元素的修改；我以x为横坐标，y为纵坐标，则数组的表示为map[y][x];

代码如下：

#include<iostream>
#include<string>
using namespace std;
int map[30][50] =
{
0,1,0,1,0,1,0,1,0,0,1,0,1,1,0,0,1,0,0,1,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,
0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1,0,1,0,0,1,0,1,
0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,
0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,0,0,1,0,1,1,
0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,
1,1,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,1,0,1,0,1,1,0,0,0,1,1,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,0,1,1,1,
0,0,0,1,1,0,1,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,1,0,0,0,0,0,0,0,
1,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0,
0,0,1,1,1,0,0,0,0,0,1,0,1,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,0,0,0,0,1,0,0,1,
1,1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0,0,1,0,0,0,1,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,
0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,0,1,0,1,
1,1,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,
0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,1,1,0,0,1,1,1,1,0,1,0,0,0,1,1,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,1,1,
1,0,1,0,1,0,1,0,0,1,1,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,1,1,0,0,1,1,1,1,0,1,1,0,1,0,0,0,0,1,0,0,0,
1,0,1,0,1,0,1,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,1,1,0,1,1,1,0,1,0,0,1,
1,0,0,0,0,0,0,0,1,0,1,1,0,0,0,1,0,0,0,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,
1,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,1,1,1,1,0,1,0,1,0,0,1,
0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,0,1,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,1,0,1,1,0,1,1,1,0,0,0,0,1,1,0,1,0,1,
1,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,1,0,
0,0,0,0,1,0,0,0,1,1,0,0,0,0,1,1,0,1,0,1,1,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,
1,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,0,0,0,0,1,
0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,
1,0,1,0,0,0,0,1,0,0,0,1,1,0,0,1,0,0,0,1,0,0,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,0,1,0,
0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,
1,1,0,1,0,0,0,0,0,0,1,0,0,1,1,1,0,1,1,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,0,0,1,0,1,1,0,1,1,1,0,1,0,0,0,
0,0,0,0,0,1,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0,0,0,0,0,0,1,1,0,0,1,1,
1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,1,0,0,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,
1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,1,0,1,1,1,0,1,0,0,0,
0,0,1,1,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,
1,0,0,0,0,0,0,1,1,0,0,1,1,1,0,1,0,1,1,1,0,1,0,0,0,1,0,0,0,1,1,0,1,1,1,0,1,0,1,0,1,1,0,1,1,1,1,0,0,0
};
int mins[30][50];//每一个坐标的步数
int best = 999999999;//终点的步数
char a[10000];
string ans;
int dirx[4] = { 1,0,-1,0 };//横坐标为x;
int diry[4] = { 0,-1,0,1 };//纵坐标为y;
char dir[4] = { 'R','U','L','D' };
bool check(int x, int y)
{
    if (x >= 0 && x < 50 && y >= 0 && y < 30)
        return true;
    return false;
}
void dfs(int x, int y, int pos)
{
    if (x == 49 && y == 29)
    {
        string temp;
        for (int i = 1; i < pos; i++)
        {
            temp += a[i];
        }
        if (pos < best)//到达终点后的两种满足情况其一
        {
            best = pos;
            ans = temp;
        }
        else if (pos == best&&temp < ans)其二
        {
            ans = temp;
        }
        return;
    }
    int nextx, nexty;
    for (int i = 0; i < 4; i++)
    {
        nextx = x + dirx[i];
        nexty = y + diry[i];
        if (check(nextx, nexty) && !map[nexty][nextx] && pos + 1 <= mins[nexty][nextx])
        {//pos + 1 <= mins[nexty][nextx]如若步骤数大于该坐标的最小步数直接pass
            map[nexty][nextx] = 1;
            a[pos] = dir[i];
            mins[nexty][nextx]=pos+1;
            dfs(nextx, nexty, pos + 1);
            map[nexty][nextx] = 0;//恢复原坐标供之后使用
        }
    }
}
int main()
{
    for (int i = 0; i < 30; i++)
        for (int j = 0; j < 50; j++)
            mins[i][j] = 999999999;
    map[0][0] = 1;
    dfs(0, 0, 1);
    cout << ans << endl;
    return 0;
}

后记：看到题解使用了

但两种运行时间没有太大区别，意图也一样,但可以减少一些代码(●ˇ∀ˇ●)；

创作不易，点个赞呗；

lwh 98+106
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于深度优先算法和广度优先算法的自动寻路迷宫实现
08-16
在本项目中，我们探索了两种基础但至关重要的图遍历算法——深度优先搜索（DFS，Depth-First Search）和广度优先搜索（BFS，Breadth-First Search），并将其应用于解决自动寻路的迷宫问题。C++的MFC（Microsoft ...
常用算法——深度优先搜索
05-23
深度优先搜索（Depth-First Search, DFS）是一种用于遍历或搜索树或图的算法，其基本思想是从根节点开始，沿着某一条路径一直深入到不能再深入为止，然后回溯到分支点，再选择另一条路径继续深入。DFS通常与回溯法...
迷宫问题详解
最新发布
ccc369639963的博客
05-01 1119
迷宫问题详解 迷宫问题指的是：在给定区域内，找到一条甚至所有从某个位置到另一个位置的移动路线。举个简单的例子，如图 1 所示，在白色区域内找到一条（甚至所有）从起点到终点的路线。 图 1 迷宫问题 迷宫问题就可以采用回溯算法解决，即从起点开始，采用不断“回溯”的方式逐一试探所有的移动路线，最终找到可以到达终点的路线。 回溯算法解决迷宫问题 以图 1 所示的迷宫为例，回溯算法解决此问题的具体思路是： 从当前位置开始，分别判断是否可以向 4 个方向（上、下、左、右）移动： 选择一个方向并移动到下个位置。判断此
C语言——迷宫问题
2301_80185370的博客
04-27 2592
迷宫问题本质上本质上是对数组的一个遍历，向上下左右四个方向进行遍历。当上下左右四个方向都无法行动时，将路径进行回溯，找到另一个可以行动的方向，直到找到出口。
【算法】迷宫问题
chuxinchangcun的博客
09-19 1638
迷宫问题本质就是一个图的遍历问题，从起点开始不断四个方向探索，直到走到出口，走的过程中我们借助栈记录走过路径的坐标。栈记录坐标有两方面的作用，一方面是记录走过的路径，一方面方便走到死路时进行回溯找其他的通路。
回溯算法之迷宫问题（Maze）
YING—country的博客
07-22 1万+
回溯算法之迷宫问题前言算法思路一、回溯算法二、经典问题之迷宫问题（Maze）（一）问题阐述 前言     迷宫问题是回溯算法的经典问题 算法思路 一、回溯算法     回溯算法实际上是一个类似枚举的搜索尝试过程，主要是在搜素尝试过程中寻找问题的解，当发现已满足求解条件时，就“回溯”返回，尝试别的路径。     回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标，但当搜索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种不通就回退再走的技术称为回溯法，而满足回溯条件的某个状态的点称为“回
迷宫问题
qq_25956141的博客
01-05 4205
介绍 迷宫问题一般深度优先遍历或者广度优先遍历解决，辅助数据结构使用栈或者队列。使用栈解决该问题时，将栈顶能达到的一个位置入栈，若发现该路不通，则退栈，通过栈顶元素继续访问其他可达到的位置，直到走完整个迷宫。若使用非循环队列，将队头能到达的所有位置入队，并记录该位置的前驱为队头元素，最后通过队列的元素的前驱记录可得到整个迷宫的路线。 问题描述 ...
K - 迷宫问题
逐梦er的博客
04-17 1745
题目描述 定义一个二维数组： 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的二维数组...
迷宫问题的三种求解方法（递归求解、回溯求解和队列求解）
热门推荐
永远飞翔的鸟
03-25 1万+
目录 一、迷宫问题的三种求解方法 递归求解 回溯求解 队列求解 二、华为迷宫问题 一、迷宫问题的三种求解方法 在迷宫问题中，给定入口和出口，要求找到路径。本文将讨论三种求解方法，递归求解、回溯求解和队列求解。 在介绍具体算法之前，先考虑将迷宫数字化。这里将迷宫用一个二维的list存储（即list嵌套在list里），将不可到达的位置用1表示，可到达的位置用0表示，并将已经到过的位置用...
【C数据结构】迷宫问题
Ahaooooooo的博客
05-19 1万+
文章目录一、迷宫问题的思路二、简单迷宫的代码实现三、地下迷宫问题的思路四、地下迷宫的代码实现 前言:本章记录作者学习中，遇到的两个比较有趣的问题，一个简单和一个较复杂的迷宫问题。     一、迷宫问题的思路 让我们先来看简单的：迷宫问题 它的具体要求： 输入描述： 输入两个整数，分别表示二维数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。 如 5 5 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1
不撞南墙不回头——深度优先搜索.docx
11-22
深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法，它的基本思想是尽可能深地探索树的分支。DFS通常使用栈作为辅助数据结构，遵循“后进先出”（LIFO）的原则，即最后进入栈的节点最先被处理。在遇到无法继续...
算法实例分析罗密欧与朱丽叶迷宫1问题
06-15
本文将深入探讨一个有趣的算法实例——“罗密欧与朱丽叶迷宫问题”。这个问题源于莎士比亚的经典剧作《罗密欧与朱丽叶》，通过抽象为数学模型，它成为了一个经典的路径寻找问题，常常被用来教学和研究各种搜索算法。...
图的应用——深度优先／广度优先搜索遍历
10-26
在“图的应用——深度优先／广度优先搜索遍历”这个实验中，你需要实现两个核心函数：一个是深度优先搜索，另一个是广度优先搜索。你可以通过创建一个布尔型数组来记录节点是否已被访问，然后利用栈或队列来辅助遍历...
算法设计经典练习六——迷宫问题
weixin_44602007的博客
04-09 4090
迷宫问题（maze problem）—— 深度优先与广度优先搜索求解 ...
数据结构例题--迷宫
chihiro1122的博客
11-09 4571
迷宫oj题的思路代码实现
回溯算法（十进制转二进制）
Smile
09-28 4078
【概念】 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。许多复杂的，规模较大的问题都可以使用回溯法，有...
数据结构课设：迷宫问题（c语言版）
qq_45804132的博客
05-07 1万+
迷宫求解问题 题目描述 用一个m×n的矩阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对给定的迷宫，求出找到的第一条从入口到出口的通路，或得到没有通路的结论。 我们指定: 迷宫的入口为矩阵的左上角（1,1），迷宫的出口为右下角（m,n）; 路径的探索顺序依次为"东南西北"（即：右下左上）。 输入 第一行输入两个整数，空格间隔，分别表示矩阵的行数m和列数n； 接下来的连续m...
迷宫求解问题
fazem的博客
05-24 456
从起点出发，先记录当前节点能探索的方向。搜索就是用问题的所有可能去试探，按照一定的顺序、规则，不断去试探，直到找到问题的解，试完了也没有找到解，那就是无解，试探时一定要试探完所有的情况（实际上就是穷举）；不是优先选择最近选中的单元格，而是随机的从所有的列表中的单元格进行选择，新加入的单元格和旧加入的单元格同样概率会被选择，新加入的单元格没有优先权。从列表里随机选一个墙，如果这面墙分隔的两个单元只有一个单元被访问过：那就从列表里移除这面墙，即把墙打通，让未访问的单元成为迷宫的通路把这个单元的墙加入列表；
ACM竞赛：搜索算法基础——广度优先与深度优先探索
本文主要介绍了搜索的基本概念和两种常用搜索算法：广度优先搜索(BFS)和深度优先搜索(DFS)。 首先，让我们理解几个基础概念： 1. **状态**：是问题在某个阶段的具体描述，如在求解过程中数字的当前状态或游戏棋局的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值