迷宫算法的细化（C++）

最新推荐文章于 2021-12-26 14:44:17 发布
最新推荐文章于 2021-12-26 14:44:17 发布
阅读量616 收藏 1
点赞数 2
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoming1430026911/article/details/77429913
版权

在数据结构中，迷宫问题属于中等难度的问题。在这里我讲一下我对于求解迷宫问题的理解（看课本中来，然后再自己好好理解）

首先从起始点出发，对该位置的四个方向（上右下左）进行探索，若某一个位置可以通过并且该位置是第一次走则进入该位置并把该位置进栈，标记该位置已经走过了，重复这个过程。若走进一个死胡同，则一步一步退出来（出栈处理），若退出来的过程栈空了，说明无法从起点位置找到出口。若前进过程中的某一点是出口位置，则表示找到出口了，把走的路径输出并结束。

这里用到一个栈，是用来存储走过的位置的。栈的结构如下：

const int stackIncreament=20;

template<class T>
class Stack
{
public:
    Stack(int sz=50);
    ~Stack()
    {
        delete []elements;
    }
    void Push(const T&x);
    bool Pop(T&x);
    bool getTop(T&x);
    bool IsEmpty()const
    {
        return (top==-1)?true:false;
    }
    bool IsFull()const
    {
        return (top==maxSize-1)?true:false;
    }
    int getSize()const
    {
        return top+1;
    }
    void makeEmpty()
    {
        top=-1;
    }
    friend ostream& operator<<(ostream& os, Stack<T>& s);
    void output()
    {
        for(int i=0; i<=top; i++)cout<<elements[i].x<<" "<<elements[i].y<<endl;
    }
private:
    T *elements;
    int top;
    int maxSize;
    void overflowProcess();//当数组不够存放数据时，对数组容量进行扩充
};

template<class T>
Stack<T>::Stack(int sz):top(-1),maxSize(sz)
{
    elements=new T[maxSize];
    assert(elements!=NULL);
}

template<class T>
void Stack<T>::overflowProcess()
{
    //私有函数，扩充栈的存储空间
    T *newArray = new T[maxSize+stackIncreament];
    if(newArray==NULL)
    {
        cerr<<"存储分配失败!"<<endl;
        exit(1);
    }
    for(int i=0; i<maxSize; i++)newArray[i]=elements[i];
    maxSize=maxSize+stackIncreament;
    delete []elements;
    elements=newArray;
}

template<class T>
void Stack<T>::Push(const T&x)
{
    if(IsFull())overflowProcess();
    elements[++top]=x;
}

template<class T>
bool Stack<T>::Pop(T& x)
{
    if(IsEmpty())return false;
    x=elements[top--];
    return true;
}

template<class T>
bool Stack<T>::getTop(T& x)
{
    if(IsEmpty())return false;
    x=elements[top];
    return true;
}

template<class T>
ostream& operator<<(ostream& os, Stack<T> &s) //重载输出
{
    os<<"top="<<s.top<<endl;
    for(int i=0; i<s.top+3; i++)os<<"第"<<i<<"个元素："<<s.elements[i]<<endl;
    return os;
}
对于迷宫，要用一个二维数组maze[][]来存储它的形状，墙位置用1表示，有路位置用0表示。

还要一个二维数组mark[][]来表示某个有路位置是否已经被走过了。1表示该位置已经被走过或者不可以走了，0表示该位置没被走过可以走。

static int **mark;//用来标记某个位置是否被访问过了
static int **Maze;
用一个结构体items表示当前位置的信息 

struct items
{
    int x, y, dir;
};
用一个结构体表示四个方向（上右下左）： 

struct offsets
{
    int a, b;
};
offsets Move[4];
四个方向的初始化： 

Move[0].a=-1;
    Move[0].b=0;
    Move[1].a=0;
    Move[1].b=1;
    Move[2].a=1;
    Move[2].b=0;
    Move[3].a=0;
    Move[3].b=-1;
先输入迷宫的行和列，再输入迷宫形状，再输入起始点坐标和重点位置坐标： 

cout << "请输入行和列" << endl;
    cin>>row>>col;
    cout<<"请输入迷宫的形状"<<endl;
    Maze=new int*[row];
    mark=new int*[row];

int row, col;
int end_x, end_y;
int begin_x, begin_y;

cout<<"请输入起始点位置:"<<endl;
    cin>>begin_x>>begin_y;
    cout<<"请输入终点位置:"<<endl;
    cin>>end_x>>end_y;
以下是完整的代码： 

#include <iostream>
#include <stdlib.h>
#include <assert.h>

using namespace std;
//迷宫问题的求解
const int stackIncreament=20;
int sum=0;
int row, col;
int end_x, end_y;
int begin_x, begin_y;
template<class T>
class Stack
{
public:
    Stack(int sz=50);
    ~Stack()
    {
        delete []elements;
    }
    void Push(const T&x);
    bool Pop(T&x);
    bool getTop(T&x);
    bool IsEmpty()const
    {
        return (top==-1)?true:false;
    }
    bool IsFull()const
    {
        return (top==maxSize-1)?true:false;
    }
    int getSize()const
    {
        return top+1;
    }
    void makeEmpty()
    {
        top=-1;
    }
    friend ostream& operator<<(ostream& os, Stack<T>& s);
    void output()
    {
        for(int i=0; i<=top; i++)
            cout<<"("<<elements[i].x<<","<<elements[i].y<<") ";
    }
private:
    T *elements;
    int top;
    int maxSize;
    void overflowProcess();//当数组不够存放数据时，对数组容量进行扩充
};

template<class T>
Stack<T>::Stack(int sz):top(-1),maxSize(sz)
{
    elements=new T[maxSize];
    assert(elements!=NULL);
}

template<class T>
void Stack<T>::overflowProcess()
{
    //私有函数，扩充栈的存储空间
    T *newArray = new T[maxSize+stackIncreament];
    if(newArray==NULL)
    {
        cerr<<"存储分配失败!"<<endl;
        exit(1);
    }
    for(int i=0; i<maxSize; i++)newArray[i]=elements[i];
    maxSize=maxSize+stackIncreament;
    delete []elements;
    elements=newArray;
}

template<class T>
void Stack<T>::Push(const T&x)
{
    if(IsFull())overflowProcess();
    elements[++top]=x;
}

template<class T>
bool Stack<T>::Pop(T& x)
{
    if(IsEmpty())return false;
    x=elements[top--];
    return true;
}

template<class T>
bool Stack<T>::getTop(T& x)
{
    if(IsEmpty())return false;
    x=elements[top];
    return true;
}

template<class T>
ostream& operator<<(ostream& os, Stack<T> &s) //重载输出
{
    os<<"top="<<s.top<<endl;
    for(int i=0; i<s.top+3; i++)os<<"第"<<i<<"个元素："<<s.elements[i]<<endl;
    return os;
}

static int **mark;//用来标记某个位置是否被访问过了
static int **Maze;

struct items
{
    int x, y, dir;
};
struct offsets
{
    int a, b;
};
offsets Move[4];

void path(int m, int p)
{
    int i, j, d, g, h;//i和j表示实际处在的位置，g和h表示要探测的位置
    mark[1][1]=1;
    Stack<items> st(200);
    items tmp;
    tmp.x=begin_x;
    tmp.y=begin_y;
    tmp.dir=0;
    st.Push(tmp);//入栈
    for(int i=0; i<row; i++)
    {
        for(int j=0; j<col; j++)
            if(Maze[i][j]==0)mark[i][j]=0;
            else mark[i][j]=1;
    }

    bool b=true;
    while(!st.IsEmpty())
    {
        st.Pop(tmp);//当进入死胡同时，这一步可以一直退到有路走的地方
        sum++;
        i=tmp.x;
        j=tmp.y;
        d=tmp.dir;
        b=true;
        while(d<4)
        {
            g=i+Move[d].a;
            h=j+Move[d].b;
            if(g<0||g>=row||h<0||h>=col)
            {
                d++;
                continue;
            }
            if(g==m&&h==p)
            {
                tmp.x=g;
                tmp.y=h;
                st.Push(tmp);
                cout<<"走通了，走的路径如下："<<endl;
                st.output();

                return;
            }

            if(Maze[g][h]==0&&mark[g][h]==0) //表示该位置有路且未被访问过
            {
                if(b==true)
                {
                    st.Push(tmp);
                }
                b=false;
                mark[g][h]=1;
                tmp.x=g;
                tmp.y=h;
                tmp.dir=d;
                st.Push(tmp);
                i=g;
                j=h;
                d=0;//这一步才是真正表示位置的移动
            }
            else d++;//换一个方向走走
        }
    }
    cout<<"迷宫中没有走出去的路"<<endl;
}

int main()
{
    Move[0].a=-1;
    Move[0].b=0;
    Move[1].a=0;
    Move[1].b=1;
    Move[2].a=1;
    Move[2].b=0;
    Move[3].a=0;
    Move[3].b=-1;

    cout << "请输入行和列" << endl;
    cin>>row>>col;
    cout<<"请输入迷宫的形状"<<endl;
    Maze=new int*[row];
    mark=new int*[row];
    for(int i=0; i<row; i++)
    {
        Maze[i]=new int[col];
        mark[i]=new int[col];
    }
    for(int i=0; i<row; i++)
        for(int j=0; j<col; j++)cin>>Maze[i][j];

    cout<<"请输入起始点位置:"<<endl;
    cin>>begin_x>>begin_y;
    cout<<"请输入终点位置:"<<endl;
    cin>>end_x>>end_y;

    path(end_x,end_y);
    return 0;
}


我用了三组测试数据:

第1组输入：

5 5

1 1 1 1 1
0 0 0 0 1
1 0 1 1 1
1 0 0 1 1
1 1 0 1 1

1 0

4 2

截图如下：


第2组数据输入：

15 15

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 1 1 1 0 0 0 1
1 0 1 0 0 0 0 0 0 0 1 0 1 0 1
1 0 1 1 1 1 1 0 1 0 1 0 1 0 1
1 0 0 0 1 0 0 0 1 0 1 0 1 0 1
1 1 1 0 1 1 1 0 1 0 1 0 1 0 1
1 0 0 0 1 0 0 0 1 0 1 0 1 0 1
1 0 1 1 1 1 1 0 1 0 1 0 1 0 1
1 0 0 0 1 0 0 0 1 0 0 0 1 0 1
1 1 1 0 1 1 1 0 1 1 1 0 1 0 1
1 0 0 0 1 0 0 0 1 0 0 0 0 1 1
1 0 1 1 1 0 1 0 1 1 1 1 0 0 1
1 0 1 1 1 1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1 1 1 1 0 1

1 0

14 13

截图如下：


第3组数据输入：

20 20

1 1 1 1 1 1 1 1 1 1 0 1 0 1 0 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 1
0 1 1 0 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0
0 0 1 0 1 0 0 0 0 1 0 0 1 0 1 1 1 0 1 1
1 0 1 1 0 1 0 1 0 0 1 0 1 0 0 1 0 0 0 0
1 0 1 1 0 1 1 0 0 1 0 0 1 0 1 1 1 1 0 1
1 0 0 1 0 1 0 0 1 0 1 0 1 1 1 0 0 1 0 0
1 1 0 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 0 1
0 0 0 1 0 0 1 0 0 0 1 1 1 1 1 1 0 1 0 0
0 1 0 1 1 0 1 1 1 0 1 0 0 0 0 1 0 1 0 1
0 1 1 1 0 0 1 0 0 0 1 0 1 0 1 1 0 0 0 0
0 0 0 1 0 1 1 1 1 0 1 0 1 0 1 1 0 1 1 0
1 0 1 1 1 1 0 0 0 0 1 1 0 0 0 0 0 1 1 0
1 0 0 0 0 1 1 1 1 0 1 0 1 1 1 1 0 0 1 0
1 1 1 1 0 1 0 0 0 0 1 0 1 0 0 0 1 0 0 1
1 0 0 1 0 1 1 0 1 0 1 0 1 0 1 0 1 1 0 1
1 1 0 1 0 1 0 0 1 0 1 0 0 0 1 0 0 0 0 1
1 1 0 1 0 1 1 1 1 1 0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 0 1

0 12

18 0

截图如下：

注意事项：

1.栈的大小需要自己控制

2.记住当跳到迷宫数组时要马上换个方向探索：

if(g<0||g>=row||h<0||h>=col)
            {
                d++;
                continue;
            }

xiaoming1430026911
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 迷宫算法（迷宫老鼠）
02-20 4732
     题目：   迷宫是一个矩形区域，它有一个入口和一个出口。在迷宫的内部包含不能穿越的墙或障碍。在图5 - 8所示的迷宫中，障碍物沿着行和列放置，它们与迷宫的矩形边界平行。迷宫的入口在左上角，出口在右下角    以下是自己根据题目要求写的算法： 功能有：1 自动生成10*10迷宫图             2 判断是否有迷宫出口，并且画出路线图   /**********
C++迷宫程序代码
04-21
C++编写的白色光点迷宫程序，可以直接复制代码运行。如果需要同类型程序可以留言，用空我就回复
迷宫问题的C++算法实现
04-25
迷宫问题的C++算法实现
C/C++小游戏 自动迷宫完整版
04-15
简单完整的C/C++迷宫小游戏，实现只要鼠标点击入口就可以自动走出迷宫的功能，算法简单且有注释，不明白的话自己走一次就清楚了。在VC下编译通过，但前提是要装有EasyX哦
迷宫生成算法（三）（C++)
nanfang0的博客
12-26 1450
三、最小生成树算法之Kruskal算法 迷宫算法中由于所有边的权相等，且需要随机性，所以与数据结构中的Kruskal算法有较大的不同： 将每个顶点视为一棵树，将所有边加入集合，从边的集合中随机选择一条边，如果该边两端的顶点属于不同的树，将两棵树合并，将这条边移除集合，如果属于相同树，直接舍弃这条边，直到边的集合为空，即所有边都被访问过，结束构造
C++算法实现走迷宫游戏，10分钟学会迷宫算法！
05-24 6350
本文实例为大家分享了C++实现走迷宫的具体代码，供大家参考，具体内容如下 用n*n个小方格代表迷宫，每个方格上有一个字符0或1，0代表这个格子不能走，1代表这个格子可以走。只能一个格子一个走，而且只能从一个格子向它的上、下、左、右四个方向走，且不能重复。迷宫的入口和出口分别位于左上角和右下角，存在唯一的一条路径能够从入口到达出口，试着找出这条路径。 例如，下图是一个迷宫，红...
C++实现迷宫算法实例解析
09-04
C++ 实现迷宫算法是一个典型的路径搜索问题，通常采用深度优先搜索（DFS）或广度优先搜索（BFS）策略。在这个实例中，作者使用了深度优先搜索方法来寻找迷宫的出口。以下是关于这个实例的详细解释： 首先，迷宫被...
C++随机生成迷宫算法
08-19
C++随机生成迷宫算法 C++随机生成迷宫算法是指使用C++语言生成随机迷宫的算法，迷宫是一种常见的游戏元素，广泛应用于游戏开发、人工智能、机器学习等领域。该算法主要通过随机生成迷宫的路径来实现迷宫的生成。 ...
迷宫生成算法C++实现文件
07-10
该资源由C++实现，算法实现较为简单，放到WIN环境下可直接运行使用，在Mac下也可以正常运行。代码中设计部分递归知识，若无此知识者，请慎重考虑是否需要购买。
OpenCV c++细化算法
08-12
普通的OpenCV C++细化算法. 已封装成C++函数，可直接调用使用。也可用于参考, 根据需要也可自行修改源码。
C++迷宫问题的求解算法
12-20
《C++迷宫问题的求解算法》 在编程领域，迷宫问题是一个经典的问题，主要涉及路径寻找和图遍历。本实例将探讨如何使用C++语言，结合链栈来解决这一问题，以非递归的方式寻找从起点到终点的路径。 实验目标主要分为...
C++ DFS算法实现走迷宫自动寻路
qq_46239972的博客
07-16 2388
C++ DFS算法实现走迷宫自动寻路 深度优先搜索百度百科解释： 事实上，深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次. 运行效果： 说明： 深度优先搜索算法是在我在图的部分接触到的，后来才发现它也可以不用在图的遍历上，它是一个独立的算法，它也可以直接用在一个二维数组上。 其算法原理和实现步骤在代码中已经有了很好的体现了，这里就不再赘述。 在程序中实现了手动操控走迷宫和自动走迷
编程题走迷宫_C++程序算法题----迷宫（一）
weixin_39724748的博客
12-19 807
题目：一天蒜头君掉进了一个迷宫里面，蒜头君想逃出去，可怜的蒜头君连迷宫是否有能逃出去的路都不知道。看在蒜头君这么可怜的份上，就请聪明的你告诉蒜头君是否有可以逃出去的路。输入格式第一行输入两个整数 n和 m，表示这是一个 n×m的迷宫。接下来的输入一个 n行 m列的迷宫。其中 'S' 表示蒜头君的位置，'*'表示墙，蒜头君无法通过，'.'表示路，蒜头君可以通过'.'移动，'T'表示迷宫的出口(蒜头君...
C++迷宫问题 深度优先算法
Laborious_Bee的博客
03-28 1291
迷宫问题 问题：用一个二维数组来存储迷宫，数组中的每个元素的值只取0或1，其中0表示此路可通，1表示此路不通。对于上例的迷宫可存储如图。 假定迷宫入口坐标为（1，1） 输出为路径 实现代码如下 /* 迷宫问题 作者：Lumao 版本：2021/3/28 0.0版 方法：C++ 队列 数组 结构体 递归 深度优先 目标：找到地图中的所有走法并输出 要点：记录路径 恢复现场 深搜 小结：拎出一个位置来分析，往哪走，出去了做什么，要回来怎么做 */ #include&l
C++算法精准实现走迷宫游戏，手把手教你编写（附源码）
python学习+VX：YYQX2209
07-21 906
很多人都喜欢玩走迷宫，那就说明它身上有种吸引人的地方，那么，经常玩走迷宫可以有什么好处呢。 1、能提高空间能力 简言之，如果经常玩走迷宫游戏，能锻炼人体大脑在空间定位方面的能力。那些经常玩迷宫的人，会发现他们在图形或空间旋转的测试题方面有更优秀的表现。 2、能帮助提高专注力 当人沉浸于如何找到出路，会把注意力集中在路上的细节，比如树木的形态、路上的小草或地上的石头甚至沙子……这些...
C++实现迷宫生成（基于算法：随机prim)
热门推荐
CODER的博客
04-06 2万+
只用到了c++中的vector，其余的和纯C差别不大，纯C可能需要手动弄一个vector太繁琐了不太想弄 看了迷宫的一些算法，prim还是比较好看的，网上的代码python c#居多，而且不太容易搞懂，那我在这里用C++（大部分C）实现了这个目的 prim算法：随机Prim算法生成的迷宫岔路较多，整体上较为自然而又复杂，算法核心为（根据维基百科）。 1.让迷宫全是墙. 2.选一个单元格作为迷...
回溯法之迷宫最短路径，c++实现
ta_huang的博客
06-18 1万+
迷宫最短路径 迷宫的算法很多，但是解释原理的却很少，在这里我利用自己的亲身经历来讲解一下求解迷宫的原理，迷宫求解可以利用栈结构，即深度优先，探索一个位置就标记，通则走，不同则后退寻找下一个位置，可以求出通路，简单但是不一定是最短路径，这里求最短路径利用的是广度优先的思想，什么是广度优先，利用队列实现，一个元素出对，然后访问这个元素相邻的所有元素，原理是，一个二维数组，0表示墙，1表示路，这里我利用......
简单的迷宫问题(递归函数)（c++）
qq_51297987的博客
04-03 3068
简单的迷宫问题(递归函数)（c++） 当初做这个题时，上网找了又找，大多数是用栈啊，链表啊，又臭又长。后来呢，稍微变通了一下，简便了一点。 题目如下： 迷宫是一个n*m的矩阵，玩家需要迷宫入口（坐标1,1）出发，寻找路径走到出口（n,m）。 请判断玩家能否从迷宫中走出。 输入格式 第一行两个整数n和m，代表n行m列。(1<=n,m<=10) 下面n行每行m个字符,0代表可以通行，1代表不可以通行。 输出格式 如果能从迷宫走出，输出yes，否则输出no。 输入样例 8 8 00100010 00
c++回溯走迷宫算法
最新发布
02-07
回溯走迷宫算法是一种常见的解决迷宫问题的方法。这种算法的基本思路是从起点开始，按照某一方向前进，如果遇到障碍物或者已经走过的路径，就退回上一步选择其他方向继续前进，直到找到出口为止。 具体来说，算法可以通过递归的方式来实现。首先，我们需要定义一个二维数组来表示迷宫地图，1表示墙壁，0表示可以通行的路径。然后，从起点开始，按照某个方向前进，比如先向右走，如果能够走通就继续前进，否则就退回上一步。递归地尝试上、下、左、右四个方向，直到找到出口或者所有方向都尝试过了为止。 在实现过程中，需要注意标记已经走过的路径，避免重复走同样的路。同时，还需要判断是否越界或者遇到墙壁，避免出现错误的路径。 通过这种算法，我们可以逐步探索迷宫的所有可能路径，最终找到通向出口的路径。需要注意的是，迷宫的大小对算法的效率会有一定影响，大的迷宫可能需要更长的时间来找到出口。因此，在实际应用中，需要根据具体情况进行优化。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值