迷宫问题

最新推荐文章于 2023-09-08 15:46:56 发布
最新推荐文章于 2023-09-08 15:46:56 发布
阅读量1k 收藏 14
点赞数 4
分类专栏： 数据结构 文章标签： 迷宫问题 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38646470/article/details/79117615
版权

一、迷宫问题
1、打印迷宫。（打印二维数组）
2、简单迷宫，找出其中的通路（①迭代法。②递归法）。
单条通路试探过程
3、多条通路迷宫，找出所有的通路。
多条通路试探过程
4、多条通路和带环通路迷宫，求最短通路。
二、函数代码：
1、打印迷宫地图：

void MazePrint()  //打印迷宫
  {
      size_t i =0,j=0;
      for (i = 0; i<N; i++)
      {
          for (j=0; j<N; j++)
          {
              printf("%d ",maze[i][j]);
          }
          printf("\n");
      }
      printf("\n");
  }

2、简单迷宫，找出其中的通路（①迭代法。②递归法）。
①迭代法

int MazeGetPath(Pos entry) //迭代法找迷宫通路
  {
      Pos cur = entry;
      Pos next = cur;
      Stack s;
      StackInit(&s);
      StackPush(&s,cur);

      while (StackEmpty(&s))
      {
          cur = StackTop(&s); //栈顶为当前位置
          maze[cur.row][cur.col]=2; //注释掉当前坐标
          if (cur.col==N-1)  //迷宫出口
          {
              printf("出口坐标:(%d,%d)\n",cur.row,cur.col);
              return 1;
          }

          next = cur; //next置到当前位置
          next.row+=1;  //向下试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;
          }

          next = cur;//next置到当前位置  
          next.row-=1; //向上试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;
          }

          next = cur;  //next置到当前位置
          next.col+=1;  //向右试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;
          }

          next = cur;   //next置到当前位置
          next.col-=1;  //向左试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;

          }
          StackPop(&s);  //遇到死胡同，回溯
      }
      return 0;  //此迷宫没有出口
  }

②、递归法

void MazeGetPathR(Pos entry)  //递归法解决简单迷宫问题
  {
      Pos cur = entry;
      Pos next = cur;
      if (next.col>N-1)  //递归结束条件
      {
          printf("找到出口:%d,%d \n",next.row,next.col);
          return;
      }
      maze[entry.row][entry.col] = 2;  //标记当前位置

      next = cur;
      next.row+=1;  //下
      if (CheckMazeAssess(next))  
      {
          MazeGetPathR(next);  //子问题
          return;
      }

      next = cur;
      next.col-=1;  //左
      if (CheckMazeAssess(next))
      {
          MazeGetPathR(next);  //子问题
          return;
      }

      next = cur;
      next.col+=1; //右
      if (CheckMazeAssess(next))
      {
          MazeGetPathR(next);  //子问题
          return;
      }
  }

3、多条通路迷宫，找出所有的通路(①迭代法。②递归法)。
①迭代法

 void MazeGetPath(Pos entry) //迭代法找迷宫通路
  {
      Pos cur = entry;
      Pos next = cur;
      Stack s;
      StackInit(&s);
      StackPush(&s,cur);

      while (StackEmpty(&s))
      {
          cur = StackTop(&s); //栈顶为当前位置
          maze[cur.row][cur.col]=2; //注释掉当前坐标
          if (cur.col==N-1)  //迷宫出口
          {
              printf("出口坐标:(%d,%d)\n",cur.row,cur.col);
          }

          next = cur; //next置到当前位置
          next.row+=1;  //向下试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;
          }

          next = cur;//next置到当前位置  
          next.row-=1; //向上试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;
          }

          next = cur;  //next置到当前位置
          next.col+=1;  //向右试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;
          }

          next = cur;   //next置到当前位置
          next.col-=1;  //向左试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;

          }
          StackPop(&s);  //遇到死胡同，回溯
      }
  }

②递归法

void MazeGetPathR(Pos entry)  //递归法解决简单迷宫问题
  {
      Pos cur = entry;
      Pos next = cur;
      if (next.col>N-1)  //递归结束条件
      {
          printf("找到出口:%d,%d \n",next.row,next.col);
          return;
      }
      maze[entry.row][entry.col] = 2;

      next = cur;
      next.row-=1; //上
      if (CheckMazeAssess(next))
      {
          MazeGetPathR(next); //子问题
      }

      next = cur;
      next.row+=1;  //下
      if (CheckMazeAssess(next))  
      {
          MazeGetPathR(next);  //子问题
      }

      next = cur;
      next.col-=1;  //左
      if (CheckMazeAssess(next))
      {
          MazeGetPathR(next);  //子问题
      }

      next = cur;
      next.col+=1; //右
      if (CheckMazeAssess(next))
      {
          MazeGetPathR(next);  //子问题
      }
  }

4、多条通路和带环通路迷宫，求最短通路。

 void MazeGetShortPath(Pos entry,Stack* path)  //求取最短路径
  {
      Pos cur = entry;
      Pos next = cur;
      if (0==StackEmpty(path)) //入口处
      {
          maze[next.row][next.col] = 2; 
      }
      else  //从入口以后，每次标记的数加一。
      {
          Pos prev = StackTop(path);
          maze[next.row][next.col]=maze[prev.row][prev.col]+1; 
      }

      StackPush(path,next);  
      if (next.col==N-1)
      {
          printf("找到出口:%d,%d \n",next.row,next.col);  
          if(!StackEmpty(&shortPath) || StackSize(path)<StackSize(&shortPath))  //始终保持最短路径在shortPath栈中
          {
              if(shortPath.data)
                 free(shortPath.data);

              shortPath.data = (DataType *)malloc(sizeof(DataType)*path->top);
              memcpy(shortPath.data,path->data,sizeof(DataType)*path->top);
              shortPath.top = path->top;
              shortPath.end = path->top;
          }
      }
      next = entry;
      next.row-=1; //上
      if (CheckMazeShortAssess(next,cur))
      {
          MazeGetShortPath(next,path);
      }

      next = entry;
      next.row+=1;  //下
      if (CheckMazeShortAssess(next,cur))
      {
          MazeGetShortPath(next,path);
      }

      next = entry;
      next.col-=1;  //左
      if (CheckMazeShortAssess(next,cur))
      {
          MazeGetShortPath(next,path);
      }

      next = entry;
      next.col+=1; //右
      if (CheckMazeShortAssess(next,cur))
      {
          MazeGetShortPath(next,path);
      }

      StackPop(path);
  }

三、整体代码及测试结果
1、maze.h

void MazePrint();   //打印迷宫
void MazeGetPath(Pos entry);  //迭代寻找迷宫通路
void MazeGetPathR(Pos entry);  //递归寻找迷宫通路
Stack shortPath; 
void MazeGetShortPath(Pos entry,Stack* path);  //求取最短路径

2、maze.c

void MazePrint()  //打印迷宫
  {
      size_t i =0,j=0;
      for (i = 0; i<N; i++)
      {
          for (j=0; j<N; j++)
          {
              printf("%d ",maze[i][j]);
          }
          printf("\n");
      }
      printf("\n");
  }

  int CheckMazeAssess(Pos pos)  //检测该坐标是否可通
  {
      if (pos.row>=0 && pos.row<N 
          && pos.col>=0 && pos.col<N
          && maze[pos.row][pos.col]==1)
      {
          return 1;
      }
      return 0;
  }

  void MazeGetPath(Pos entry) //迭代法找迷宫通路
  {
      Pos cur = entry;
      Pos next = cur;
      Stack s;
      StackInit(&s);
      StackPush(&s,cur);

      while (StackEmpty(&s))
      {
          cur = StackTop(&s); //栈顶为当前位置
          maze[cur.row][cur.col]=2; //注释掉当前坐标
          if (cur.col==N-1)  //迷宫出口
          {
              printf("出口坐标:(%d,%d)\n",cur.row,cur.col);
              //return 1;
          }

          next = cur; //next置到当前位置
          next.row+=1;  //向下试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;
          }

          next = cur;//next置到当前位置  
          next.row-=1; //向上试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;
          }

          next = cur;  //next置到当前位置
          next.col+=1;  //向右试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;
          }

          next = cur;   //next置到当前位置
          next.col-=1;  //向左试探
          if(CheckMazeAssess(next))
          {
              StackPush(&s,next);
              continue;

          }
          StackPop(&s);  //遇到死胡同，回溯
      }
      return 0;  //此迷宫没有出口
  }

 void MazeGetPathR(Pos entry)  //递归法解决简单迷宫问题
  {
      Pos cur = entry;
      Pos next = cur;
      if (next.col>N-1)  //递归结束条件
      {
          printf("找到出口:%d,%d \n",next.row,next.col);
          return;
      }
      maze[entry.row][entry.col] = 2;

      next = cur;
      next.row-=1; //上
      if (CheckMazeAssess(next))
      {
          MazeGetPathR(next); //子问题
      }

      next = cur;
      next.row+=1;  //下
      if (CheckMazeAssess(next))  
      {
          MazeGetPathR(next);  //子问题
      }

      next = cur;
      next.col-=1;  //左
      if (CheckMazeAssess(next))
      {
          MazeGetPathR(next);  //子问题
      }

      next = cur;
      next.col+=1; //右
      if (CheckMazeAssess(next))
      {
          MazeGetPathR(next);  //子问题
      }
  }

  int CheckMazeShortAssess(Pos next,Pos cur)  //检测该坐标是否可通
  {
      if (next.row>=0 && next.row<N 
          && next.col>=0 && next.col<N
          && (maze[next.row][next.col]==1 || 
          maze[next.row][next.col]>maze[cur.row][cur.col]))
      {
          return 1;
      }
      else
      {
          return 0;
      }
  }

  void MazeGetShortPath(Pos entry,Stack* path)  //求取最短路径
  {
      Pos cur = entry;
      Pos next = cur;
      if (0==StackEmpty(path)) //入口处
      {
          maze[next.row][next.col] = 2; 
      }
      else  //从入口以后，每次标记的数加一。
      {
          Pos prev = StackTop(path);
          maze[next.row][next.col]=maze[prev.row][prev.col]+1; 
      }

      StackPush(path,next);  
      if (next.col==N-1)
      {
          printf("找到出口:%d,%d \n",next.row,next.col);  
          if(!StackEmpty(&shortPath) || StackSize(path)<StackSize(&shortPath))  //始终保持最短路径在shortPath栈中
          {
              if(shortPath.data)
                 free(shortPath.data);

              shortPath.data = (DataType *)malloc(sizeof(DataType)*path->top);
              memcpy(shortPath.data,path->data,sizeof(DataType)*path->top);
              shortPath.top = path->top;
              shortPath.end = path->top;
          }
      }
      next = entry;
      next.row-=1; //上
      if (CheckMazeShortAssess(next,cur))
      {
          MazeGetShortPath(next,path);
      }

      next = entry;
      next.row+=1;  //下
      if (CheckMazeShortAssess(next,cur))
      {
          MazeGetShortPath(next,path);
      }

      next = entry;
      next.col-=1;  //左
      if (CheckMazeShortAssess(next,cur))
      {
          MazeGetShortPath(next,path);
      }

      next = entry;
      next.col+=1; //右
      if (CheckMazeShortAssess(next,cur))
      {
          MazeGetShortPath(next,path);
      }

      StackPop(path);
  }

3、test.c

void test()
 {
    Pos entry = {5,2};
    Stack path;
    StackInit(&path);
    StackInit(&shortPath);
    MazePrint();
    MazeGetPath(entry);  //迭代法
    MazeGetPathR(entry);   //递归法
    MazeGetShortPath(entry,&path);
    MazePrint();
    while (StackEmpty(&shortPath))
    {
        printf("%d,%d<-", StackTop(&shortPath).row,StackTop(&shortPath).col);

        StackPop(&shortPath);
    }
    printf("entry\n");
 }

四、涉及到栈的相关操作请戳栈的基本操作

龙跃十二
关注
  • 4
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
迷宫问题总结（算法）
Infor_learning的博客
09-17 3695
1、常见迷宫问题 dfs 走出迷宫的最短路径： BFS class Node { int x, y; //int len; //有时需要记录深度 //Node pre; //有事需要记录路劲 } public static int BFS(char[][] m, boolean[][] vis, Node start, Node end,) { Queue<Node> q = new LinkedList<>();
迷宫问题详解
最新发布
ccc369639963的博客
05-01 1115
迷宫问题详解 迷宫问题指的是：在给定区域内，找到一条甚至所有从某个位置到另一个位置的移动路线。举个简单的例子，如图 1 所示，在白色区域内找到一条（甚至所有）从起点到终点的路线。 图 1 迷宫问题 迷宫问题就可以采用回溯算法解决，即从起点开始，采用不断“回溯”的方式逐一试探所有的移动路线，最终找到可以到达终点的路线。 回溯算法解决迷宫问题 以图 1 所示的迷宫为例，回溯算法解决此问题的具体思路是： 从当前位置开始，分别判断是否可以向 4 个方向（上、下、左、右）移动： 选择一个方向并移动到下个位置。判断此
回溯算法之迷宫问题（Maze）
YING—country的博客
07-22 1万+
回溯算法之迷宫问题前言算法思路一、回溯算法二、经典问题之迷宫问题（Maze）（一）问题阐述 前言     迷宫问题是回溯算法的经典问题 算法思路 一、回溯算法     回溯算法实际上是一个类似枚举的搜索尝试过程，主要是在搜素尝试过程中寻找问题的解，当发现已满足求解条件时，就“回溯”返回，尝试别的路径。     回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标，但当搜索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种不通就回退再走的技术称为回溯法，而满足回溯条件的某个状态的点称为“回
迷宫问题（规范格式且有大量注释）
CAKE_CAT的博客
09-08 1709
随机路径生成+回溯求解迷宫通路+可视化。(文档中文章重要信息作者已给出，需要完整文档可以私聊作者！)
百度面试题——迷宫问题(超详细解析)
qq_62939852的博客
09-16 8023
迷宫问题的本质是图的遍历问题，从起点开始不断四个方向探索，直到走到出口，走的过程借助栈记录走过的路径，栈记录坐标有两个作用，一方面是记录走过的路径，一方面方便走到死路时进行回溯其他的道路。它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。此时的顺序为 (0,0),(1,0),(1,1),(1,2),(2,2)3.在下标为(1,0)时上面为1不能走，下面为0可以走。6.注意此时的下标(1,0) 只能走左，右两个方向，
广度优先搜索解决迷宫问题_迷宫问题_
09-29
迷宫问题是一个经典的图论问题，常常用于计算机科学和算法设计的教学中。在这个问题中，我们通常有一个二维网格，其中的每个单元格要么是通路（通常标记为0），要么是障碍物（标记为1）。目标是找到从起点到终点的一...
迷宫问题，迷宫问题.doc
06-10
迷宫问题实验报告 迷宫问题是数据结构与算法实验报告的一部分，该实验的目的是熟悉栈的用法和掌握试探法程序设计技能。实验的内容是设计一个迷宫问题的解决方案，使用 C++ 语言编写程序来实现迷宫问题的解决。 ...
数据结构实验迷宫问题实验报告
11-18
数据结构实验迷宫问题实验报告 本实验报告主要是关于数据结构实验中的迷宫问题，通过设计数据结构存储迷宫、设计存储结构保存从入口到出口的通路、设计算法完成迷宫问题的求解，并分析算法的时间复杂度。 首先，...
迷宫问题求解
10-17
迷宫的问题，代码解释的比较详细，当时写了好久才写出来的，基础要求低
C语言实现迷宫问题
04-14
C语言编写的一个简单迷宫问题。其中用到了数据结构，相对简单
一个迷宫问题完整程序
06-21
一座迷宫，在一点可能有八个方位移动，设计算法从一点（i，j）到终点（m，n）。
数据结构——迷宫问题
weixin_45823684的博客
01-13 1万+
一.题意说明 求迷宫问题（见实验4-17）的所有路径。分别使用栈、队列、递归算法等实现（至少三种方法）。要求迷宫地图大小可自定义，障碍物可随机生成。 题意分析：用二维数组定义迷宫大小，确定迷宫方向。迷宫通路为1，不通为0，随机分配0和1，构造迷宫。分别用栈、队列、递归方法求解迷宫路径。采用链表存储迷宫内数据。 二.算法设计与分析 首先确定迷宫的大小，用二维数组构造迷宫，并且规定方向0—3代表上下左右。Path方法存放路径。随机使用0和1填充迷宫，0为不可通过点，1为可通过点。记录好起点和终点。1.栈
数据结构基础系列(3)：栈和队列
09-08
数据结构课程是计算机类专业的专业基础课程，在IT人才培养中，起着重要的作用。课程按照大学计算机类专业课程大纲的要求，安排教学内容，满足需要系统学习数据结构的人。系列课程包含11个部分，本课为第3部分栈和队列，介绍在系统软件和应用软件开发中大有用途的两种特殊线性表——栈和队列的构组成、存储结构的选择，以及基本运算的实现，通过相关的应用案例介绍了这些数据结构的应用方法。
回溯算法（十进制转二进制）
Smile
09-28 4078
【概念】 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。许多复杂的，规模较大的问题都可以使用回溯法，有...
迷宫问题的三种求解方法（递归求解、回溯求解和队列求解）
热门推荐
永远飞翔的鸟
03-25 1万+
目录 一、迷宫问题的三种求解方法 递归求解 回溯求解 队列求解 二、华为迷宫问题 一、迷宫问题的三种求解方法 在迷宫问题中，给定入口和出口，要求找到路径。本文将讨论三种求解方法，递归求解、回溯求解和队列求解。 在介绍具体算法之前，先考虑将迷宫数字化。这里将迷宫用一个二维的list存储（即list嵌套在list里），将不可到达的位置用1表示，可到达的位置用0表示，并将已经到过的位置用...
迷宫问题（进阶版）——深度优先算法
liuwenhao_1的博客
01-11 1375
迷宫问题（进阶版）——深度优先算法
python迷宫问题：
04-19
Python迷宫问题是一个经典的算法问题，目标是找到从迷宫的起点到达终点的路径。迷宫通常由一个二维数组表示，其中0表示可通行的路径，1表示墙壁或障碍物。以下是解决迷宫问题的一种常见方法： 1. 使用深度优先搜索...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

龙跃十二

写的不错，给点鼓励

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值