迷宫及走迷宫时的最优解

最新推荐文章于 2024-04-27 13:41:46 发布
最新推荐文章于 2024-04-27 13:41:46 发布
阅读量2.9k 收藏 11
点赞数 5
分类专栏： 数据结构 文章标签： 递归 栈 迷宫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34992845/article/details/71307314
版权

下面简单阐述下使用栈（循环）和使用递归来走迷宫的区别：

使用递归：
分为两个部分：
一部分为已走过的路径（通路）
另一问题是：递归的子问题（根据下一个可以通的位置继续查找出口）。
将走过的路径保存在栈帧内。
递归结束时返回上一层栈帧，销毁当前栈帧。

使用栈（保存走过的路径）
分为两个部分：
一部分为已走过的路径（通路），将其保存在栈内
另一部分为：
试探四个方向，沿着某个可以走通的方向一直试探下去，直到走不通时，退出栈顶元素，栈顶元素始终为当前所处的位置。

1.递归走迷宫：
（利用回溯法）

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<cassert>

struct Pos//设置坐标
{
    Pos(int x, int y)
    :_x(x)
    , _y(y)
    {}

    int _x;
    int _y;
};

template<size_t M,size_t N>
class Maze
{
public:
    Maze(int **arr, FILE* fp)//构造迷宫
        :_row(M)
        , _col(N)
        , _maze(arr)
    {
        int ch = 0;
        assert(fp);

        for (size_t i = 0; i < _row; ++i)//从文件中读取迷宫
        {
            for (size_t j = 0; j < _col;)
            {
                char ch = fgetc(fp);
                if (ch == '0' || ch == '1')
                {
                    _maze[i][j] = ch - '0';
                    ++j;
                }
            }
        }
        fclose(fp);
    }

    bool PassMaze(Pos Entry)
    {
        //递归算法
        Pos cur = Entry;
        Pos next = cur;
        _maze[next._x][next._y] = 2;//将走过的路进行标记

        //判断是否为出口
        if (next._x == N - 1)
        {
            return true;
        }

        //向上查探
        next._x -= 1;
        if (_CheckAccess(next))
        {
            if (PassMaze(next))
            {
                return true;
            }
        }
        //向右查探
        next = cur;
        next._y += 1;
        if (_CheckAccess(next))
        {
            if (PassMaze(next))
            {
                return true;
            }
        }

        //向下查探
        next = cur;
        next._x += 1;
        if (_CheckAccess(next))
        {
            if (PassMaze(next))
            {
                return true;
            }
        }

        //向左查探
        next = cur;
        next._y -= 1;
        if (_CheckAccess(next))
        {
            if (PassMaze(next))
            {
                return true;
            }
        }
        //走到死胡同时标记为3
        _maze[cur._x][cur._y] = 3;
        return false;
    }

    ~Maze()
    {
        for (int i = 0; i <_row; ++i)
        {
            delete[] _maze[i];
        }
        delete[] _maze;
    }
    friend ostream& operator<<(ostream& out, Maze& m);

protected:
    bool _CheckAccess(Pos cur)
    {
        if (cur._x >= 0 && cur._x < N && cur._y >= 0 && cur._y < N && _maze[cur._x][cur._y] == 1)
        {
            return true;
        }
        return false;
    }
private:
    int** _maze;
    int _row;
    int _col;
};

 ostream& operator<<(ostream& out, Maze<10,10>& m)
{
     for (int i = 0; i < m._row; ++i)
     {
         for (int j = 0; j < m._col; ++j)
         {
             out << m._maze[i][j] << "  ";
         }
         cout << endl;
     }
     return out;
}

测试代码：

void Test()
{
    FILE* fp = fopen("Maze.txt", "r");
    int row = 0;
    int col = 0;
    fscanf(fp, "%d %d", &row, &col);
    int Start_x = 0;
    int Start_y = 0;
    fscanf(fp, "%d %d", &Start_x, &Start_y);

    //动态开辟二维数组
    int **arr = new int*[row];
    for (int i = 0; i < col; ++i)
    {
        arr[i] = new int[col];
    }

    Maze<10,10> maze(arr,fp);//初始化迷宫
    cout << maze << endl;
    cout << maze.PassMaze(Pos(Start_x, Start_y)) << endl;
    cout << maze << endl;
    fclose(fp);
}

int main()
{
    Test();
    return 0;
}

2.非递归走迷宫（利用栈来保存迷宫的路径）

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<cassert>
#include<stack>

struct Pos//设置坐标
{
    Pos(int x, int y)
    :_x(x)
    , _y(y)
    {}

    int _x;
    int _y;
};

template<size_t M,size_t N>
class Maze
{
public:
    Maze(int **arr, FILE* fp)//构造迷宫
        :_row(M)
        , _col(N)
        , _maze(arr)
    {
        int ch = 0;
        assert(fp);

        for (size_t i = 0; i < _row; ++i)//从文件中读取迷宫
        {
            for (size_t j = 0; j < _col;)
            {
                char ch = fgetc(fp);
                if (ch == '0' || ch == '1')
                {
                    _maze[i][j] = ch - '0';
                    ++j;
                }
            }
        }
        fclose(fp);
    }

    //使用循环
    bool PassMaze(Pos Entry)
    {
        stack<Pos > s;
        s.push(Entry);
        _maze[Entry._x][Entry._y] = 2;

        while (!s.empty())
        {
            Pos cur = s.top();
            _maze[cur._x][cur._y] = 2;
            if (cur._x == N - 1)
            {
                return true;
            }
            //向上查探
            Pos next = cur;
            next._x -= 1;
            if (_CheckAccess(next))
            {
                s.push(next);
                continue;
            }

            //向右查探
            next = cur;
            next._y += 1;
            if (_CheckAccess(next))
            {
                s.push(next);
                continue;
            }

            //向下查探
            next = cur;
            next._x += 1;
            if (_CheckAccess(next))
            {
                s.push(next);
                continue;
            }

            //向左查探
            next = cur;
            next._y -= 1;
            if (_CheckAccess(next))
            {
                s.push(next);
                continue;
            }
            s.pop();
            _maze[cur._x][cur._y] = 3;
        }
        return false;
    }


    ~Maze()
    {
        for (int i = 0; i <_row; ++i)
        {
            delete[] _maze[i];
        }
        delete[] _maze;
    }
    friend ostream& operator<<(ostream& out, Maze& m);

protected:
    bool _CheckAccess(Pos cur)
    {
        if (cur._x >= 0 && cur._x < N && cur._y >= 0 && cur._y < N && _maze[cur._x][cur._y] == 1)
        {
            return true;
        }
        return false;
    }
private:
    int** _maze;
    int _row;
    int _col;
};

 ostream& operator<<(ostream& out, Maze<10,10>& m)
{
     for (int i = 0; i < m._row; ++i)
     {
         for (int j = 0; j < m._col; ++j)
         {
             out << m._maze[i][j] << "  ";
         }
         cout << endl;
     }
     return out;
}

测试代码如下：

void Test()
{
    FILE* fp = fopen("Maze.txt", "r");
    int row = 0;
    int col = 0;
    fscanf(fp, "%d %d", &row, &col);
    int Start_x = 0;
    int Start_y = 0;
    fscanf(fp, "%d %d", &Start_x, &Start_y);

    //动态开辟二维数组
    int **arr = new int*[row];
    for (int i = 0; i < col; ++i)
    {
        arr[i] = new int[col];
    }

    Maze<10,10> maze(arr,fp);//初始化迷宫
    cout << maze << endl;
    cout << maze.PassMaze(Pos(Start_x, Start_y)) << endl;
    cout << maze << endl;
    fclose(fp);
}

int main()
{
    Test();
    return 0;
}

迷宫中有多条路径时，查找最短路径：

第一种方法：(有缺陷)

先走一条路，走到出口时不返回而是将出口封住，从而利用回溯查找第二条路，这种方法只有在特定情况下（当每条路径的出口都不相同时）才会成功，而当遇到下面的情况（有多条路径是一个出口时），就有可能找不到最优路径。

迷宫（0代表墙，1代表通路，2代表入口）：

0020000000
0011100000
0000100000
1000100000
0000011110
0011100000
0010000000
0011000000
0001111000
0000001000

方法二、（有缺陷）

利用递归，当找到一条路时，并不进行返回，即就是获取迷宫路径的函数没有返回值，
当找到一条路径时，会进行回溯至下一条路径，直到最终走完迷宫中所有的通路。

这里需要借助两个栈，一个path栈保存每次走的路径，另一个shortpath保存最短路径。

缺陷：标记方式的问题：走过的通路标记为2，而不通的路标记为3.
那么走过的路径就不会再走，那么当有几条路径的出口相同时，查找的最优解就可能不是我们想要的结果。

方法三、(最终可以适用任何场景)

和上述方式大致相同，只是改变了标记方式：使得走过的路径还可以再走。
将入口设置为2，每走一步将此位置的值设置为上个位置值加1.
利用某种条件，就可以找到所有的路径。

求迷宫的最优解需要注意的问题是：
1.必须保证所有的路径都可以走一遍；（使用递归，找到一条路径并不返回）
2.必须保证走过的路径还可以再走（该标记方式）

代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<cassert>
#include<stack>
struct Pos//设置坐标
{
    Pos(int x, int y)
    :_x(x)
    , _y(y)
    {}
    int _x;
    int _y;
};
template<size_t M,size_t N>
class Maze
{
public:
    Maze(int **arr, FILE* fp)//构造迷宫
        :_row(M)
        , _col(N)
        , _maze(arr)
    {
        int ch = 0;
        assert(fp);
        for (size_t i = 0; i < _row; ++i)//从文件中读取迷宫
        {
            for (size_t j = 0; j < _col;)
            {
                char ch = fgetc(fp);
                if (ch == '0' || ch == '1' || ch == '2')
                {
                    _maze[i][j] = ch - '0';
                    ++j;
                }
            }
        }
        fclose(fp);
    }
    //递归算法走迷宫
    bool PassMaze(Pos Entry)
    {
        Pos cur = Entry;
        Pos next = cur;
        _maze[next._x][next._y] = 2;//将走过的路进行标记
        //判断是否为出口
        if (next._x == N - 1)
        {
            return true;
        }
        //向上查探
        next._x -= 1;
        if (_CheckAccess(next))
        {
            if (PassMaze(next))
            {
                return true;
            }
        }
        //向右查探
        next = cur;
        next._y += 1;
        if (_CheckAccess(next))
        {
            if (PassMaze(next))
            {
                return true;
            }
        }
        //向下查探
        next = cur;
        next._x += 1;
        if (_CheckAccess(next))
        {
            if (PassMaze(next))
            {
                return true;
            }
        }
        //向左查探
        next = cur;
        next._y -= 1;
        if (_CheckAccess(next))
        {
            if (PassMaze(next))
            {
                return true;
            }
        }
        //走到死胡同时标记为3
        _maze[cur._x][cur._y] = 3;
        return false;
    }
//获取迷宫的最优解
void GetShortPath(Pos Entry, stack<Pos>& path, stack<Pos>& shortPath)
{
    //递归算法
    Pos cur = Entry;
    Pos next = cur;
    path.push(cur);
    //_maze[next._x][next._y] = 2;//将走过的路进行标记
    //判断是否为出口
    if (next._x == N - 1)
    {
        Print();
        if (shortPath.empty() || path.size() < shortPath.size())
        {
            shortPath = path;
        }
    }
    //向上查探
    next._x -= 1;
    if (_CheckAccess(next, cur))
    {
        _maze[next._x][next._y] = _maze[cur._x][cur._y] + 1;
        GetShortPath(next, path, shortPath);
    }
    //向右查探
    next = cur;
    next._y += 1;
    if (_CheckAccess(next, cur))
    {
        _maze[next._x][next._y] = _maze[cur._x][cur._y] + 1;
        GetShortPath(next, path, shortPath);
    }
    //向下查探
    next = cur;
    next._x += 1;
    if (_CheckAccess(next,cur))
    {
        _maze[next._x][next._y] = _maze[cur._x][cur._y] + 1;
        GetShortPath(next, path, shortPath);
    }
    //向左查探
    next = cur;
    next._y -= 1;
    if (_CheckAccess(next,cur))
    {
        _maze[next._x][next._y] = _maze[cur._x][cur._y] + 1;
        GetShortPath(next, path, shortPath);
    }
    path.pop();
}
    ~Maze()
    {
        for (int i = 0; i <_row; ++i)
        {
            delete[] _maze[i];
        }
        delete[] _maze;
    }
    //friend ostream& operator<<(ostream& out, Maze& m);
    void Print()
    {
        if (_maze)
        {
            for (size_t i = 0; i < N; ++i)
            {
                for (size_t j = 0; j < N; ++j)
                {
                    cout << _maze[i][j] << " ";
                }
                cout << endl;
            }
            cout << endl;
        }
    }
protected:
    bool _CheckAccess(Pos cur)
    {
        if (cur._x >= 0 && cur._x < N && cur._y >= 0 && cur._y < N && _maze[cur._x][cur._y] == 1)
        {
            return true;
        }
        return false;
    }
    bool _CheckAccess(Pos& next,Pos& cur)
    {
        if (next._x >= 0 && next._x < N && next._y >= 0 && next._y < N )
        {

            if (_maze[next._x][next._y] == 1)
            {
                return true;
            }
            else if (_maze[next._x][next._y] == 0)
            {
                return false;
            }
            else
            {
                if (_maze[cur._x][cur._y] + 1 < _maze[next._x][next._y])
                {
                    return true;
                }
            }
        }
        return false;
    }
private:
    int** _maze;
    int _row;
    int _col;
};
void Test()
{
    FILE* fp = fopen("Maze.txt", "r");
    int row = 0;
    int col = 0;
    fscanf(fp, "%d %d", &row, &col);
    int Start_x = 0;
    int Start_y = 0;
    fscanf(fp, "%d %d", &Start_x, &Start_y);
    //动态开辟二维数组
    int **arr = new int*[row];
    for (int i = 0; i < col; ++i)
    {
        arr[i] = new int[col];
    }
    Maze<10,10> maze(arr,fp);//初始化迷宫
    maze.Print();
    //cout << maze << endl;
    stack<Pos > path, shortPath;
    maze.GetShortPath(Pos(Start_x, Start_y),path,shortPath);
    //maze.Print();
    fclose(fp);
}
int main()
{
    Test();
    return 0;
}

结果显示（打印的太难看，表示一下意思就好，笑脸）：

这里写图片描述

小葱1024
关注
  • 5
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单迷宫最优解问题
燚淼的博客
10-07 1405
简单迷宫最优解问题
迷宫的最优路径
u010256924的专栏
10-28 1117
对于迷宫最优路径，其中之一方法就是把所有路径都找出来，
迷宫最优解问题
junkeal的博客
09-10 871
最近看到一个比较有意思的题目，讲已知一个迷宫求最优解。这里就要提一下什么是迷宫了。                   如上图所示，其实迷宫就是一个二维数组，其中‘1’代表墙，不能拖过，而'0'代表通路，是可以走的，给定一个入口和这个迷宫 求出最优（路径最短）的解。         求解大体算法是这样的 使用递归，从入口进入迷宫，从入口的上下左右四个方向探测，探测到可以走时，将来时的路做'标
C语言——迷宫问题
最新发布
2301_80185370的博客
04-27 2406
迷宫问题本质上本质上是对数组的一个遍历，向上下左右四个方向进行遍历。当上下左右四个方向都无法行动时，将路径进行回溯，找到另一个可以行动的方向，直到找到出口。
对于“迷宫类问题”最优解的总结！
weixin_45988242的博客
02-08 1037
记住这种模板！！！ 问题① 1330：【例8.3】最少步数 （ps这个题之前写过） 【题目描述】 在各种棋中，棋子的走法总是一定的，如中国象棋中马走“日”。有一位小学生就想如果马能有两种走法将增加其趣味性，因此，他规定马既能按“日”走，也能如象一样走“田”字。他的同桌平时喜欢下围棋，知道这件事后觉得很有趣，就想试一试，在一个（100×100）的围棋盘上任选两点A、B，A点放上黑子，B点放上白...
关于迷宫求解及其最优解的问题
pigff的博客
10-08 3742
关于迷宫问题，求解它的最优解的问题可以使用栈的概念来实现。简单的迷宫如下图 其中0表示可以走，1表示不能走，显然可见，若是以（3,1）点为入口，则有两个出口分别是（10，3）和（10, 8）。而两个出口的路径长度是不同的。这就产生了迷宫最优解的问题。 下面附上代码，我们寻找下一个位置是否可走的顺序是顺时针顺序，即上右下左。#pragma once #include<iostream> usi
迷宫问题的A*算法(python实现)
07-05
附件中A_star.py为算法实现，有两个txt文件作为测试样例，mediumMaze是一个封闭的迷宫，openmaze是一个开放的迷宫
A星算法求解迷宫问题实验
04-29
1. 不需要遍历所有节点，只是利用包含问题启发式信息的评价函数对节点进行排序，使搜索方向朝着最有可能找到目标并产生最优解的方向。 2. 引入了全局信息，对当前节点距终点的距离做出估计，并作为评价节点处于最短...
A*算法实现迷宫问题
12-13
用人工智能中的A*算法解决迷宫的路径寻找问题
迷宫最短路径算法（dfs）
02-26
然后分别从这些相邻单元格出发依次访问它们的邻接格，并使“先被访问的单元格的邻接格‘先于’后被访问的单元格的邻接格”被访问，直至访问到迷宫出口，则找到了迷宫问题的最优解，即迷宫最短路径。该算法的显著特点...
实验四：A星算法求解迷宫问题实验.doc
10-11
A*算法是人工智能中的一种搜索算法，是一种启发式搜索算法，它不需遍历所有节点，只是利用包含问题启发式信息的评价函数对节点进行排序，使搜索方向朝着最有可能找到目标并产生最优解的方向。它的独特之处是检查最短...
函数递归走迷宫详解及代码
10-15
详细描述了怎样用递归函数走出迷宫以及建造迷宫的程序。还带有详细的解题报告,程序简单不复杂，适合新手。
走迷宫以及求迷宫最优解
tttjp的博客
05-19 610
走迷宫以及求迷宫最优解
递归算法解决“迷宫”问题
m0_46405589的博客
11-26 1180
递归-迷宫问题 代码思路 使用二维数组 map[][] 模拟迷宫 约定： 当 map[i][j] 为 0 表示该点没有走过 ；当为 1 表示墙；2 表示通路可以走 ；3 表示该点已经走过，但是走不通 setWay() 方法用于找路，true 表示该路可以走通，false 表示该路走不通 在走迷宫时，需要确定一个策略(方法) 下->右->上->左 , 一步一步向前试探，如果该点走不通，再回溯 每当走到一个点时，将该点置为 2 ，暂时假设该路能走通，至于到底走不走得通，得看后面有没有找
最优解问题
青鱼入云的博客
05-16 4281
最短路径（shortest path） 游商问题（traveling salesperson problem TSP） 装箱问题（bin packing） 序列对比（sequence alignment） 背包问题（knapsacks） 贪婪算法（greedy algorithm）：在每一个步骤都最大化你的价值 穷举法（brute force）：罗列每一种可能的结果，再对比出最优解 动态...
Maze迷宫问题（最优解）
weixin_34279184的博客
04-16 295
迷宫地形我们可以通过读文件的形式，通过已知入口逐个遍历坐标寻找通路。文件如图：每个坐标的位置用结构体来记录：structPos//位置坐标 { int_row; int_col; };定义行列范围#defineM10//行 #defineN10//列初始化迷宫数组：将通过读文件的方式获取的字符转成整型数据，保存在M行N列的数组中...
顺序队列求解迷宫（最优解）
youth_shouting的博客
07-12 6378
【问题描述】 以一个mXn的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 【任务要求】 实现队列求解迷宫从入口到出口的最短通路。 【测试数据】 迷宫的测试数据如下：左上角（0，1）为入口，右下角（8，9）为出口。 代码：这里写代码片 #include <stdio.h> #include <std
递归实现走迷宫
qq_40511157的博客
06-28 931
一、题目 题目很简单，在迷宫内，给定起始点和终点，根据一定的行走策略，使用递归操作，找出一条可以行走的路径。 二、源代码 package recursion; import java.util.Stack; public class Maze { public static void main(String[] args) { int width = 8, height = 8; int startX = 1, startY = 1,endX = 6, endY = 6; //按照数组索引来书
BFS+优先队列——迷宫最短路径——两种最优方法比较及详细图解
qq_36523667的博客
11-30 7742
http://blog.csdn.net/qq_36523667/article/details/78638354 这个链接里是一道迷宫题。用到了BFS+优先队列。 我一直百思不得其解优先队列到底优先在哪了？我感觉和直接bfs没啥区别？后来证明做法不一样，思路也不一样。 所以这里引出另一种最优的做法。 正常的bfs 黑色是当前的点，黄色是即将探索的点，把黄色的依次
走迷宫综合程序设计方法
03-25
4. 遗传算法：将迷宫问题看作一个优化问题，用遗传算法来寻找最优解。通过不断变异、交叉等操作，逐渐优化路径，找到最短路径。 5. 蚁群算法：将蚂蚁看作搜索的节点，通过释放信息素来寻找最优路径。不断迭代，逐渐...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值