迷宫问题

最新推荐文章于 2022-02-25 14:02:33 发布
原创 最新推荐文章于 2022-02-25 14:02:33 发布 · 249 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

迷宫最优解问题：

迷宫地形我们可以通过读文件的形式，通过已知入口逐个遍历坐标寻找通路。

文件如图：

wKiom1cSCnTB8pO4AAAZiAM5LuE146.png

每个坐标的位置用结构体来记录：

  1. struct Pos    //位置坐标  
  2. {  
  3.    int  _row;  
  4.    int _col;  
  5. };  

定义行列范围

  1. #define M 10   //行  
  2. #define N 10   //列  

初始化迷宫数组：
将通过读文件的方式获取的字符转成整型数据，保存在M行N列的数组中。

[cpp] view plain copy
  1. void InitMaze(int* maze)  
  2. {     
  3.     struct WavHeadhWAV;  
  4.     FILE* fout = fopen("MazeMap.txt", "r");   // .txt文件要放在当前目录下  
  5.     if (fout == NULL)                       // 这里一定要检查读文件是否成功  
  6.     {  
  7.         cout << "can't find MazeMap.txt !" << endl<<endl;  
  8.         return;  
  9.     }  
  10.     for (int i = 0; i < M; i++)  
  11.     {  
  12.         for (int j = 0; j < N;)  
  13.         {  
  14.             char ch = fgetc(fout);  
  15.             if (ch=='1'||ch=='0')  
  16.             {  
  17.                 maze[i*N + j] = ch - '0';  
  18.                 j++;  
  19.             }  
  20.         }  
  21.     }  
  22.     fclose(fout);  
  23. }  

回溯查找通路：

利用栈来存储通路，通过上下左右四个方向依次遍历，如果该位置满足条件，就将它入栈，并将该位置的数据置为2；如果四个方向都不满足条件就执行出栈操作，回溯查找满足条件的位置（这时候如果栈为空了，说明查找通路失败），继续循环遍历，直到找到出口为止。

这里建立一个最小栈，如果找到出路，就将该栈赋给最小栈，并将出口置为1，继续回溯查找通路，如果又一次找到通路，就将该栈的长度与最小栈进行比较，如果该栈长度比最小栈还要小，就将它再一次赋给最小栈（保证最小栈是最短的通路），继续回溯，直到整个栈为空，回到了入口，程序结束。

[cpp] view plain copy
  1. bool SearchMazePath(int *maze, Pos entry, stack<Pos>& paths)   // 利用栈回溯查找通路,并实现迷宫的最优解  
  2. {  
  3.     assert(maze);  
  4.     stack<Pos>min;  
  5.     paths.push(entry);  
  6.     while (!paths.empty())  
  7.     {  
  8.         Pos cur = paths.top();  
  9.         maze[cur._row*N+cur._col] = 2;  
  10.         if (cur._row==M-1)  
  11.         {  
  12.             if (paths.size()< min.size() || min.size() == 0)  
  13.             {  
  14.                 min = paths;  
  15.             }  
  16.             paths.pop();  
  17.             maze[min.top()._row*N + min.top()._col] = 1;  
  18.         }     
  19.         Pos next = cur;  
  20.         next._col--;  //左  
  21.         if (CheckIsAccess(maze, next))  
  22.         {  
  23.             paths.push(next);  
  24.             maze[next._row*N + next._col] = 2;  
  25.             continue;  
  26.         }  
  27.         next = cur;  
  28.         next._col++; //右  
  29.         if (CheckIsAccess(maze, next))  
  30.         {  
  31.             paths.push(next);  
  32.             maze[next._row*N + next._col] = 2;  
  33.             continue;  
  34.         }  
  35.         next = cur;  
  36.         next._row--; //上  
  37.         if (CheckIsAccess(maze, next))  
  38.         {  
  39.             paths.push(next);  
  40.             maze[next._row*N + next._col] = 2;  
  41.             continue;  
  42.         }  
  43.         next = cur;  
  44.         next._row++; //下  
  45.         if (CheckIsAccess(maze, next))  
  46.         {  
  47.             paths.push(next);  
  48.             maze[next._row*N + next._col] = 2;  
  49.             continue;  
  50.         }  
  51.         paths.pop();  
  52.     }  
  53.     if (paths.empty()&&!min.empty())  
  54.     {  
  55.             maze[min.top()._row*N + min.top()._col] = 2;  
  56.             return true;  
  57.     }  
  58.     return false;  
  59. }  

检查该位置是否合法：（坐标在行列范围之内）

  1. bool CheckIsAccess(int* maze, const Pos& next)    // 检查该位置是否合法  
  2. {  
  3.     assert(maze);  
  4.     if ((next._row >= 0 && next._row <= N) && (next._col >= 0 && next._col < M) && maze[next._row*N + next._col] == 0)  
  5.     {  
  6.         return true;  
  7.     }  
  8.     return false;  
  9. }  

打印迷宫：

  1. void PrintMaze(int *maze)   // 打印迷宫  
  2. {  
  3.     assert(maze);  
  4.     for (int i = 0; i < M; i++)  
  5.     {   
  6.         for (int j = 0; j < N; j++)  
  7.         {  
  8.             cout << maze[i*N + j] <<" " ;  
  9.         }  
  10.         cout << endl;  
  11.     }  
  12.     cout << endl;    
  13. }  

wKioL1cSXnWRU9roAAAG8lMrhuE483.png


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

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

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

#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;
}



迷宫问题的三种实现算法
Zju_ycj的博客
04-08 1万+
2.走迷宫2.1 问题描述给定一个迷宫Maze，并给定迷宫的路口和出口，用递归的方式搜索一条从入口到出口的可行路径（其中红色为围墙，蓝色为可行路），若存在这条路径，则打印出路径，若不存在路径，则输出信息，表示没有路径。  2.2 问题解决思路和关键点2.2.1 迷宫在程序中如何表示因为迷宫中每一个点的信息都只有两种可能（要么能走，要么不能走），我们可以以二维数组Maze[i][j]=value来存...
数据结构实验迷宫问题实验报告
11-18
数据结构实验迷宫问题实验报告 本实验报告主要是关于数据结构实验中的迷宫问题，通过设计数据结构存储迷宫、设计存储结构保存从入口到出口的通路、设计算法完成迷宫问题的求解，并分析算法的时间复杂度。 首先，...
迷宫问题，迷宫问题.doc
06-10
迷宫问题的实验报告 迷宫问题，作为一个经典的数据结构与算法的实验主题，不仅能够帮助学生熟悉栈的用法，还能锻炼他们的试探法程序设计技能。在本实验报告中，我们将通过C++语言编写程序来解决迷宫问题，实现对...
人工智能大作业基于强化学习求解迷宫问题python实现源码+项目说明+实验报告+可执行文件.zip
最新发布
08-09
人工智能大作业-基于强化学习求解迷宫问题python实现源码+项目说明+实验报告+可执行文件 【项目介绍】 该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 本项目适合计算机相关专业...
C语言 数据结构中求解迷宫问题实现方法
12-31
C语言 数据结构中求解迷宫问题实现方法  在学习数据结构栈的这一节遇到了求迷宫这个问题，拿来分享一下~  首先求迷宫问题通常用的是“穷举求解” 即从入口出发，顺某一方向试探，若能走通，则继续往前走，否则...
迷宫算法——验证迷宫的可通性
weixin_30505043的博客
11-22 148
【Qboy原创】 记得在大学学习数据结构时就学过采用迭代方式可以判断一个迷宫是否有解无解甚至可以查找出所有的可能的出口。目前公司开发一个游戏需要玩家去搭建迷宫让其他玩家去闯迷宫的游戏，游戏其实很简单。但是有一个重点就是要验证玩家所搭建的迷宫是否可到达。好吧这就是我们接下去算法的需求。写下此文只是为了Mark过程。 　　首先先创建必须的结构体 　　（1）迷宫中所有的节点类型　　 ...
迷宫问题(C语言)
APP_xinyonghu_li的博客
02-25 2087
迷宫求解C语言 栈实现
数据结构：各类迷宫问题详解(c语言版)
Ferlan的博客
04-01 3万+
第一类 简单迷宫（不含多条出路，不带环）（0代表墙，1代表通路） 思路分析： 1.以入口为起点，寻找出口（除了起点以外的边缘上的点） 2.判定当前点坐标是否可以走。（坐标合法且不为0） 3.如果合法则将当前点标记成走过的并入栈（维护一个栈可以记录走过的路径，栈的长度就是路径的长度） 4.判断当前点是否是出口，是出口就return（该迷宫不存在别的出口），如果不是出口，...
迷宫问题解法汇总
basycai的博客
08-28 1万+
from：http://www.cnblogs.com/rollenholt/archive/2011/08/23/2151202.html java写的回溯法求迷宫问题 问题描述： [实验目的] 综合运用数组、递归等数据结构知识，掌握、提高分析、设计、实现及测试程序的综合能力。 [实验内容及要求] 以一个M×N的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程
迷宫问题（maze problem）—— 深度优先与广度优先搜索求解
热门推荐
Dablelv 的博客专栏。
05-02 6万+
1.问题简介给定一个迷宫，指明起点和终点，找出从起点出发到终点的有效可行路径，就是迷宫问题（maze problem）。迷宫可以以二维数组来存储表示。0表示通路，1表示障碍。注意这里规定移动可以从上、下、左、右四方方向移动。坐标以行和列表示，均从0开始，给定起点（0,0）和终点（4,4），迷宫表示如下：int maze[5][5]={ {0,0,0,0,0}, {0,1,0,1,0}
迷宫搜索问题最短路_算法分析与设计 查找迷宫的最短路径(深度算法).docx
weixin_34365336的博客
12-24 496
算法分析与设计查找迷宫的最短路径(深度算法)计算机科学与技术12级16班2012/12/16【摘要】：迷宫求解是一个古老的游戏，要在迷宫中找到出口，需要经过一连串的错误尝试才能找到正确的路径，有的时候甚至找不到路径。类似于给定一个m*n的矩形网格，设其左上角为起点S。一辆汽车从起点出发驶向右下角终点T。在若干网格处设置了障碍，表示该网格不可到达。设计一个算法，求汽车从起点S出发到达终点T的一条路线...
判断迷宫是否可到达目的地的程序
wingahi的专栏
04-07 1690
在写本程序之前，本人已经
使用BFS解决迷宫问题
"本文介绍了一种解决迷宫问题的方法，通过广度优先搜索（BFS）算法寻找从起点到终点的最短路径。代码详细易懂，适合初学者学习。" 在计算机科学中，迷宫问题是一个经典的路径搜索问题，通常涉及到在一个二维网格中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值