迷宫问题

最新推荐文章于 2023-09-08 15:46:56 发布
最新推荐文章于 2023-09-08 15:46:56 发布
阅读量683 收藏 3
点赞数
分类专栏： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bella_wx/article/details/78352569
版权

迷宫需要解决的问题：
1.如何找到通路?
首先在迷宫的入口点进入迷宫，分别别探测上下左右四个方向是否是通路（四个方向不通为1，通为0），如果是可通的方向将此方向的值改为2，接着再走下一个地方，直至走到四个方向中有一个方向是NULL，也就是走到迷宫的边缘，结束。
2.如何解觉没有通路的问题？
最初我们使用死循环来持续判断通路，但是如果迷宫没有通路，就需要判断条件path.empty()，判空条件来控制循环。

这里写图片描述
这里写图片描述
3.当迷宫中有多条通路存在时候，如何找最优通路？即最短路。
首先需要将有多条通路的迷宫全部的通路走一遍，才能选择一条较短的通路，则使用GetPathR()函数来寻找多条通路迷宫，这里面使用递归的方式，递归可以自动回溯，其内部实现相当于栈。找最短路径，定义了GetShortPathR()函数，

这里写图片描述
通过记录走的路径，存入栈中进行位置个数比较，比较出短的那一条通路，把路径存入shortpath中。

这里写图片描述

这里写图片描述

这里写图片描述

递归回溯：
当四周无路可走的时候，栈销毁回退至上一个栈桢，直至到11所在的位置，再向左走至20的位置，四周无路可走，回退至4所在的位置，因探测条件是当0的时候可以走和当比自己本身大的数可走，所以在4的位置走向20的 位置的那条路径，直至出口，然后因递归再回溯到入口的位置。（两层栈桢）
这里写图片描述
这里写图片描述
这里写图片描述
代码如下：

//1.实现迷宫的递归非递归。
//2.实现迷宫的最优解问题。
//3.实现表达式计算问题。

struct Pos
{
    size_t _row;
    size_t _col;
};

template<size_t M,size_t N>
class Maze
{
public:
    //Maze(int maze[][N])//二维数组传参,指定列数//还有其他方式把数组传进去
    Maze(int*maze)//问题：为什么这里可以这么传参？
    {
        for (size_t i = 0; i < M; ++i)
        {
            for (size_t j = 0; j < N; ++j)
            {
                //_maze[i][j] = maze[i][j];
                _maze[i][j] = maze[i*N + j];//问题：为什么这里可以乘以N来计算？
            }
        }
    }
    void Print()//打印迷宫
    {
        for (size_t i = 0; i < M; ++i)
        {
            for (size_t j = 0; j < N; ++j)
            {
                cout << _maze[i][j] << " ";
            }
            cout << endl;
        }
        cout << endl;

        if (!shortPath.empty())//打印出具体路径
        {
            cout << "最短路径长度" << shortPath.size() << endl;
            cout << "最短路径:出口";
            stack<Pos>tmp = shortPath;//栈支持拷贝构造，是深拷贝
            while (!tmp.empty())
            {
                Pos& top = tmp.top();
                printf("[%d,%d]<-", top._row, top._col);
                tmp.pop();
            }
            cout << "入口" << endl;
        }
    }
    //bool CheckAccess(Pos next)//判断是否可以通
    //{
    //  if (next._row < M && next._col < N
    //      && _maze[next._row][next._col] == 0)
    //  {
    //      return true;
    //  }
    //  return false;
    //}
    bool CheckAccess(Pos cur, Pos next)//判断是否可以通
    {
        if ((next._row < M && next._col < N)   // 检查nxet合不合法
            && (_maze[next._row][next._col] == 0 //检查next是不是通路
            || _maze[next._row][next._col] > _maze[cur._row][cur._col]))//通路---比所在位置的本身大的值得位置
        {
            return true;
        }
        return false;
    }

    //bool GetPath(Pos entry)
    //{
    //  Pos cur, next;
    //  cur = entry;
    //  stack<Pos> path;
    //  path.push(entry);

    //  while (!path.empty())//如果是死循环，当迷宫没有通路的时候就会程序崩溃。
    //  {
    //      cur = path.top();//cur 试探上下左右的方向
    //      _maze[cur._row][cur._col] = 2;//continue上来的
    //      if (cur._row == M - 1)
    //      {
    //          return true;
    //      }
    //      next = cur;
    //      next._row -= 1;//上
    //      if (CheckAccess(next))
    //      {
    //          path.push(next);//假如可通就continue返回之前再探测其他方向  
    //          continue;
    //      }


    //      next = cur;
    //      next._row += 1;//下
    //      if (CheckAccess(next))
    //      {
    //          path.push(next);
    //          continue;
    //      }

    //      next = cur;
    //      next._col -= 1;//左
    //      if (CheckAccess(next))
    //      {
    //          path.push(next);
    //          continue;
    //      }


    //      next = cur;
    //      next._col += 1;//右
    //      if (CheckAccess(next))
    //      {
    //          path.push(next);
    //          continue;
    //      }

    //      //回溯
    //      path.pop();//四个方向都不通则把这个栈点pop出去
    //  }
    //  return false;
    //}

    //找多条通路（递归）
    void GetPathR(Pos entry)
    {

        _maze[entry._row][entry._col] = 2;//标记走过的位置
        if (entry._row == M - 1)
        {
            cout << "找到一个出口" << "[" << entry._row << "," << entry._col << "]" << endl;
            return;//这里的return不是直接回到最开始，而是返回上一个位置
        }
        Pos next;
        next = entry;
        next._row -= 1;//上
        if (CheckAccess(next))
        {
            GetPathR(next);//如果找一条通路，这里的返回值是true
        }

        next = entry;
        next._row += 1;//下
        if (CheckAccess(next))
        {
            GetPathR(next);
        }

        next = entry;
        next._col += 1;//右
        if (CheckAccess(next))
        {
            GetPathR(next);
        }

        next = entry;
        next._col -= 1;//左
        if (CheckAccess(next))
        {
            GetPathR(next);
        }
        path.pop()
    }

    找出最短路径
    //void GetShortPath(Pos entry,stack<Pos>&path)
    //{
    //  path.push(entry);
    //  
    //  _maze[entry._row][entry._col] = 2;//标记走过的位置为2
    //  if (entry._row == M-1)
    //  {
    //      if (shortPath.empty() || path.size() < shortPath.size())
    //      {
    //          shortPath = path;//shortPath存的就是最短路径
    //      }
    //      cout << "找到一个出口" << "[" << entry._row << "," << entry._col << "]" << endl;
    //      //return;//这里的return不是直接回到最开始，而是返回上一个位置
    //  }
    //  Pos next;
    //  next = entry;
    //  next._row -= 1;//上
    //  if (CheckAccess(entry, next))
    //  {
    //      GetShortPath(next, path);//如果找一条通路，这里的返回值是true
    //  }

    //  next = entry;
    //  next._row += 1;//下
    //  if (CheckAccess(entry, next))
    //  {
    //      GetShortPath(next, path);
    //  }

    //  next = entry;
    //  next._col -= 1;//左
    //  if (CheckAccess(entry, next))
    //  {
    //      GetShortPath(next, path);
    //  }

    //  next = entry;
    //  next._col += 1;//右
    //  if (CheckAccess(entry, next))
    //  {
    //      GetShortPath(next, path);
    //  }
    //  path.pop();
    //}



    void GetShortPathR(Pos entry, stack<Pos>&path)
    {
        path.push(entry);

        if (entry._row == M - 1)
        {
            if (shortPath.empty() || path.size() < shortPath.size())
            {
                shortPath = path;//shortPath存的就是最短路径
            }
            cout << "找到一个出口" << "[" << entry._row << "," << entry._col << "]" << endl;
            //return;//这里的return不是直接回到最开始，而是返回上一个位置
        }
        //需要顺时针走
        Pos next;
        next = entry;
        next._row -= 1;//上
        if (CheckAccess(entry, next))
        {
            _maze[next._row][next._col] = _maze[entry._row][entry._col] + 1;//标记走过的位置分别是2，3，4，5...
            GetShortPathR(next, path);//如果找一条通路，这里的返回值是true
        }

        next = entry;
        next._col += 1;//右
        if (CheckAccess(entry, next))
        {
            _maze[next._row][next._col] = _maze[entry._row][entry._col] + 1;//标记走过的位置分别是2，3，4，5...
            GetShortPathR(next, path);
        }

        next = entry;
        next._row += 1;//下
        if (CheckAccess(entry, next))
        {
            _maze[next._row][next._col] = _maze[entry._row][entry._col] + 1;//标记走过的位置分别是2，3，4，5...
            GetShortPathR(next, path);
        }

        next = entry;
        next._col -= 1;//左
        if (CheckAccess(entry, next))
        {
            _maze[next._row][next._col] = _maze[entry._row][entry._col] + 1;//标记走过的位置分别是2，3，4，5...
            GetShortPathR(next, path);
        }
        path.pop();
    }

protected:
    int _maze[M][N];
    stack<Pos>shortPath;
};



void TestMaze()
{
    //int mazeArray[10][10] =                //无环迷宫
    //{
    //  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
    //  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
    //  { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 },
    //  { 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
    //  { 1, 1, 0, 0, 0, 0, 1, 1, 1, 1 },
    //  { 1, 1, 0, 1, 1, 0, 1, 1, 1, 1 },
    //  { 1, 1, 0, 1, 1, 0, 1, 1, 1, 1 },
    //  { 1, 1, 0, 1, 1, 0, 1, 1, 1, 1 },
    //  { 1, 1, 0, 1, 1, 0, 1, 1, 1, 1 },
    //  { 1, 1, 0, 1, 1, 0, 1, 1, 1, 1 }
    //};
        int mazeArray[10][10] =                 //有环迷宫
        {
            { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
            { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
            { 2, 0, 0, 0, 0, 0, 0, 1, 1, 1 },
            { 1, 1, 0, 1, 1, 1, 0, 1, 1, 1 },
            { 1, 1, 0, 0, 0, 0, 0, 1, 1, 1 },
            { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 },
            { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 },
            { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 },
            { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 },
            { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 }
        };
    /*Maze<10, 10> maze(mazeArray);*/  //接收int maze[][N]的传参方式
    Maze<10, 10>maze((int*)mazeArray);  //接收int* maze的传参方式
    maze.Print();
    Pos entry = { 2, 0 };
    //if (maze.GetPath(entry))
    //{
    //  cout << "找到通路了" << endl;
    //}
    //else
    //{
    //  cout << "没有找到通路" << endl;
    //}
    //maze.GetPathR(entry);
    stack<Pos> path;
    maze.GetShortPathR(entry,path);
    maze.Print();
}

测试如下：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
#include<stack>
using namespace std;
#include"Maze.h"
#include"Calculate.h"


//int main()
//{
//  TestMaze();
//  system("pause");
//  return 0;
//}

int main() 
{ 
    vector<Cell> exp;
    //exp.push_back(Cell(OP_NUM, 2));
    //exp.push_back(Cell(OP_NUM, 3));
    //exp.push_back(Cell(OP_NUM, 4));
    //exp.push_back(Cell(OP_SYMBOL, '*'));
    //exp.push_back(Cell(OP_SYMBOL, '-'));
    //exp.push_back(Cell(OP_NUM, 5));
    //exp.push_back(Cell(OP_SYMBOL, '+'));

    exp.push_back(Cell(OP_NUM, 2));
    exp.push_back(Cell(OP_SYMBOL, OP_SUB));
    exp.push_back(Cell(OP_NUM, 3));
    exp.push_back(Cell(OP_SYMBOL, OP_MUL));
    exp.push_back(Cell(OP_NUM, 4));
    exp.push_back(Cell(OP_SYMBOL, OP_ADD));
    exp.push_back(Cell(OP_NUM, 5));


    //Calculator ec(exp);
    //cout << "计算结果是：" << ec.Count() << endl;


/*  Cell exp[] = 
    { 
    {OP_NUM, 2}, 
    {OP_NUM, 3}, 
    {OP_NUM, 4}, 
    {OP_SYMBOL, OP_MUL}, 
    {OP_SYMBOL, OP_SUB}, 
    {OP_NUM, 5}, 
    {OP_ADD, OP_ADD}, 
    };*/ 

    //
    Calculator cal(exp);

    cout << "计算结果:" << cal.Count() << endl;  // 
    system("pause");
    return 0; 
}
Bella_wx
关注
专栏目录
回溯算法之迷宫问题（Maze）
YING—country的博客
07-22 1万+
回溯算法之迷宫问题前言算法思路一、回溯算法二、经典问题之迷宫问题（Maze）（一）问题阐述 前言     迷宫问题是回溯算法的经典问题 算法思路 一、回溯算法     回溯算法实际上是一个类似枚举的搜索尝试过程，主要是在搜素尝试过程中寻找问题的解，当发现已满足求解条件时，就“回溯”返回，尝试别的路径。     回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标，但当搜索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种不通就回退再走的技术称为回溯法，而满足回溯条件的某个状态的点称为“回
迷宫问题的三种求解方法（递归求解、回溯求解和队列求解）
热门推荐
永远飞翔的鸟
03-25 1万+
目录 一、迷宫问题的三种求解方法 递归求解 回溯求解 队列求解 二、华为迷宫问题 一、迷宫问题的三种求解方法 在迷宫问题中，给定入口和出口，要求找到路径。本文将讨论三种求解方法，递归求解、回溯求解和队列求解。 在介绍具体算法之前，先考虑将迷宫数字化。这里将迷宫用一个二维的list存储（即list嵌套在list里），将不可到达的位置用1表示，可到达的位置用0表示，并将已经到过的位置用...
K - 迷宫问题
逐梦er的博客
04-17 1761
题目描述 定义一个二维数组： 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的二维数组...
【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
广度优先搜索解决迷宫问题_迷宫问题_
09-29
迷宫问题是一个经典的图论问题，常常用于计算机科学和算法设计的教学中。在这个问题中，我们通常有一个二维网格，其中的每个单元格要么是通路（通常标记为0），要么是障碍物（标记为1）。目标是找到从起点到终点的一...
迷宫问题，迷宫问题.doc
06-10
迷宫问题实验报告 迷宫问题是数据结构与算法实验报告的一部分，该实验的目的是熟悉栈的用法和掌握试探法程序设计技能。实验的内容是设计一个迷宫问题的解决方案，使用 C++ 语言编写程序来实现迷宫问题的解决。 ...
数据结构实验迷宫问题实验报告
11-18
数据结构实验迷宫问题实验报告 本实验报告主要是关于数据结构实验中的迷宫问题，通过设计数据结构存储迷宫、设计存储结构保存从入口到出口的通路、设计算法完成迷宫问题的求解，并分析算法的时间复杂度。 首先，...
算法设计经典练习六——迷宫问题
weixin_44602007的博客
04-09 4287
迷宫问题（maze problem）—— 深度优先与广度优先搜索求解 ...
迷宫问题（进阶版）——深度优先算法
liuwenhao_1的博客
01-11 1413
迷宫问题（进阶版）——深度优先算法
数据结构例题--迷宫
chihiro1122的博客
11-09 4630
迷宫oj题的思路代码实现
回溯算法（十进制转二进制）
Smile
09-28 4107
【概念】 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。许多复杂的，规模较大的问题都可以使用回溯法，有...
数据结构课设：迷宫问题（c语言版）
qq_45804132的博客
05-07 1万+
迷宫求解问题 题目描述 用一个m×n的矩阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对给定的迷宫，求出找到的第一条从入口到出口的通路，或得到没有通路的结论。 我们指定: 迷宫的入口为矩阵的左上角（1,1），迷宫的出口为右下角（m,n）; 路径的探索顺序依次为"东南西北"（即：右下左上）。 输入 第一行输入两个整数，空格间隔，分别表示矩阵的行数m和列数n； 接下来的连续m...
迷宫求解问题
fazem的博客
05-24 472
从起点出发，先记录当前节点能探索的方向。搜索就是用问题的所有可能去试探，按照一定的顺序、规则，不断去试探，直到找到问题的解，试完了也没有找到解，那就是无解，试探时一定要试探完所有的情况（实际上就是穷举）；不是优先选择最近选中的单元格，而是随机的从所有的列表中的单元格进行选择，新加入的单元格和旧加入的单元格同样概率会被选择，新加入的单元格没有优先权。从列表里随机选一个墙，如果这面墙分隔的两个单元只有一个单元被访问过：那就从列表里移除这面墙，即把墙打通，让未访问的单元成为迷宫的通路把这个单元的墙加入列表；
迷宫问题（规范格式且有大量注释）
最新发布
CAKE_CAT的博客
09-08 1760
随机路径生成+回溯求解迷宫通路+可视化。(文档中文章重要信息作者已给出，需要完整文档可以私聊作者！)
百度面试题——迷宫问题(超详细解析)
qq_62939852的博客
09-16 8366
迷宫问题的本质是图的遍历问题，从起点开始不断四个方向探索，直到走到出口，走的过程借助栈记录走过的路径，栈记录坐标有两个作用，一方面是记录走过的路径，一方面方便走到死路时进行回溯其他的道路。它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。此时的顺序为 (0,0),(1,0),(1,1),(1,2),(2,2)3.在下标为(1,0)时上面为1不能走，下面为0可以走。6.注意此时的下标(1,0) 只能走左，右两个方向，
【数据结构与算法 8】递归之迷宫问题
学Java，找哪吒
05-20 5483
一、简介 递归就是方法自己调用自己，每次调用时传入不同的参数，递归有利于编程者解决复杂的问题，同时可以让代码变得简洁。 二、用一个例子引出递归概念 public static void test(int n){ if(n>2){ test(n-1); } System.out.println("n="+n); } 打眼一看，很low，很简单，4,3,2无疑。 为了验证我的聪明才智，输出一把吧 三、递归调用规则（很重要） 1、执行一个方法时
7-7 求解迷宫从入口到出口的路径 (15 分) java
qq_53369749的博客
11-14 1922
求解迷宫从入口到出口的路径。输入一个迷宫，求从入口通向出口的可行路径。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n（3<n<=10），则该迷宫横向或纵向尺寸都是n，规定迷宫最外面的一圈是障碍物，迷宫的入口是maze[1][1]，出口是maze[n-2][n-2], 若maze[i][j] = 1代表该位置是障碍物，若maze[i][j] = 0代表该位置是可以行走的空位（0&lt
使用BFS解决迷宫问题
"本文介绍了一种解决迷宫问题的方法，通过广度优先搜索（BFS）算法寻找从起点到终点的最短路径。代码详细易懂，适合初学者学习。" 在计算机科学中，迷宫问题是一个经典的路径搜索问题，通常涉及到在一个二维网格中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值