迷宫问题的求解
数据结构课程设计迷宫问题求解
数据结构课程设计迷宫问题求解正文：一、引言在数据结构课程设计中，迷宫问题求解是一个经典且常见的问题。
迷宫问题求解是指通过编程实现在迷宫中找到一条从起点到终点的路径。
本文将详细介绍如何用数据结构来解决迷宫问题。
二、问题分析1.迷宫定义：迷宫是由多个格子组成的矩形区域，其中包括起点和终点。
迷宫中的格子可以是墙壁（无法通过）或者通道（可以通过）。
2.求解目标：在给定的迷宫中，找到从起点到终点的一条路径。
3.输入：迷宫的大小、起点坐标、终点坐标以及墙壁的位置。
4.输出：从起点到终点的路径，或者提示无解。
三、算法设计1.基础概念a) 迷宫的表示：可以使用二维数组来表示迷宫，数组的元素可以是墙壁、通道或者路径上的点。
b) 坐标系统：可以使用(x, y)来表示迷宫中各个点的坐标。
c) 方向定义：可以用上、下、左、右等四个方向来表示移动的方向。
2.深度优先搜索算法（DFS）a) 算法思想：从起点开始，沿着一个方向一直走到无法继续为止，然后回退到上一个点，再选择其他方向继续探索。
b) 算法步骤：i) 标记当前点为已访问。
ii) 判断当前点是否为终点，如果是则返回路径；否则继续。
iii) 遍历四个方向：1.如果该方向的下一个点是通道且未访问，则继续向该方向前进。
2.如果该方向的下一个点是墙壁或已访问，则尝试下一个方向。
iv) 如果四个方向都无法前进，则回退到上一个点，继续向其他方向探索。
3.广度优先搜索算法（BFS）a) 算法思想：从起点开始，逐层向外探索，直到找到终点或者所有点都被访问。
b) 算法步骤：i) 标记起点为已访问，加入队列。
ii) 循环以下步骤直到队列为空：1.取出队首元素。
2.判断当前点是否为终点，如果是则返回路径；否则继续。
3.遍历四个方向：a.如果该方向的下一个点是通道且未访问，则标记为已访问，加入队列。
iii) 如果队列为空仍未找到终点，则提示无解。
四、算法实现1.选择合适的编程语言和开发环境。
迷宫问题算法
迷宫问题算法一、引言迷宫问题是一个经典的算法问题，对于寻找路径的算法有着广泛的应用。
迷宫是一个由通路和墙壁组成的结构，从起点出发，要找到通往终点的路径。
迷宫问题算法主要解决的是如何找到一条从起点到终点的最短路径。
二、DFS（深度优先搜索）算法深度优先搜索算法是迷宫问题求解中最常用的算法之一。
其基本思想是从起点开始，沿着一个方向不断向前走，当走到无法继续前进的位置时，回退到上一个位置，选择另一个方向继续前进，直到找到终点或者无路可走为止。
1. 算法步骤1.初始化一个空栈，并将起点入栈。
2.当栈不为空时，取出栈顶元素作为当前位置。
3.如果当前位置是终点，则返回找到的路径。
4.如果当前位置是墙壁或者已经访问过的位置，则回退到上一个位置。
5.如果当前位置是通路且未访问过，则将其加入路径中，并将其邻居位置入栈。
6.重复步骤2-5，直到找到终点或者栈为空。
2. 算法实现伪代码以下为DFS算法的实现伪代码：procedure DFS(maze, start, end):stack := empty stackpath := empty listvisited := empty setstack.push(start)while stack is not empty docurrent := stack.pop()if current == end thenreturn pathif current is wall or visited.contains(current) thencontinuepath.append(current)visited.add(current)for each neighbor in getNeighbors(current) dostack.push(neighbor)return "No path found"三、BFS（广度优先搜索）算法广度优先搜索算法也是解决迷宫问题的常用算法之一。
y迷宫计算公式
y迷宫计算公式迷宫计算公式是指用于求解迷宫路径的数学模型或算法。
迷宫是由通道和阻塞区域构成的一种图形结构，求解迷宫路径即是要找到从起点到终点的通行路径。
迷宫计算公式有很多种，下面是其中几种常见的算法。
1. 深度优先搜索算法（DFS）：深度优先搜索算法是一种经典的求解迷宫路径的算法。
它通过递归的方式深入搜索迷宫中的每一个可能的路径，直到找到终点或者无法继续深入为止。
算法步骤：（1）选择起点，并将其标记为已访问。
（2）按照上、右、下、左的顺序依次尝试访问相邻的格子，如果格子是通道且未访问过，则继续递归地进行搜索。
（3）如果找到终点，则输出路径；否则，回退到上一步。
（4）重复上述步骤，直到找到终点或者无法继续搜索。
2. 广度优先搜索算法（BFS）：广度优先搜索算法是一种另外一种常用的求解迷宫路径的算法。
它是通过逐层地扩展搜索范围来寻找终点的方法。
算法步骤：（1）选择起点，并将其标记为已访问。
（2）将起点加入队列。
（3）重复以下步骤直到找到终点或者队列为空：- 从队列中取出一个格子；- 按照上、右、下、左的顺序依次尝试访问相邻的格子；- 如果格子是通道且未访问过，则将其标记为已访问，并将其加入队列。
（4）如果找到终点，则输出路径；否则，说明没有可行的路径。
3. A*算法：A*算法是一种启发式搜索算法，它使用一个估计函数来评估每个格子的优先级，从而选择下一个扩展的格子。
算法步骤：（1）初始化起点，并将其加入开放列表（open list）。
（2）重复以下步骤直到找到终点或者开放列表为空：- 从开放列表中选择优先级最高的格子，并将其从开放列表中移除。
- 如果选择的格子是终点，则输出路径。
- 否则，对其所有相邻的可通行格子进行以下操作：* 如果格子不在开放列表中，则将其加入开放列表，并计算该格子的估计值和移动代价。
* 如果格子已经在开放列表中，并且新的移动路径更短，则更新该格子的估计值和移动代价。
（3）如果开放列表为空，说明没有可行的路径。
迷宫的方案
迷宫的方案迷宫的方案引言迷宫，作为一种充满挑战和悬疑的游戏，一直以来都吸引着人们的目光。
找到迷宫中的出口，往往需要耐心和智慧。
本文将介绍一些常见的解迷宫的方案，希望能够帮助读者更好地解决迷宫难题。
1. 暴力搜索法暴力搜索法是最简单直接的解迷宫的方法之一。
它的思想是从迷宫的起点开始，通过尝试不同的路径，直到找到出口为止。
这种方法的缺点是可能需要尝试大量的路径，耗费较多的时间和计算资源。
使用暴力搜索法解迷宫可以采用递归的方式。
首先，将当前位置标记为已访问，然后尝试向四个方向移动。
如果某个方向可以移动且未被访问过，则递归调用该方法。
如果找到了出口，则返回成功；如果四个方向都无法移动，则返回失败。
```markdownfunction solveMaze(x, y):if (x, y) 是出口:返回成功如果 (x, y) 不是通路或已访问:返回失败将 (x, y) 标记为已访问尝试向上移动如果 solveMaze(x-1, y) 返回成功:返回成功尝试向右移动如果 solveMaze(x, y+1) 返回成功:返回成功尝试向下移动如果 solveMaze(x+1, y) 返回成功:返回成功尝试向左移动如果 solveMaze(x, y-1) 返回成功:返回成功返回失败```暴力搜索法的时间复杂度为O(N^2)，其中N为迷宫的大小。
2. 广度优先搜索法广度优先搜索法是另一种有效的解迷宫的方法。
它的思想是从起点开始，逐层地向外扩展，直到找到出口为止。
这种方法保证了找到的路径是最短的。
广度优先搜索法需要借助队列来实现。
首先，将起点加入队列，并标记为已访问。
然后，从队列中取出一个位置，尝试在四个方向上移动，并将可移动的位置加入队列中。
重复此过程，直到找到出口或队列为空为止。
```markdownfunction solveMaze(x, y):创建一个空队列将 (x, y) 加入队列将 (x, y) 标记为已访问while 队列不为空:取出队列中的第一个位置 (x, y)如果 (x, y) 是出口:返回成功尝试向上移动如果 (x-1, y) 是通路且未访问过: 将 (x-1, y) 加入队列将 (x-1, y) 标记为已访问尝试向右移动如果 (x, y+1) 是通路且未访问过: 将 (x, y+1) 加入队列将 (x, y+1) 标记为已访问尝试向下移动如果 (x+1, y) 是通路且未访问过: 将 (x+1, y) 加入队列将 (x+1, y) 标记为已访问尝试向左移动如果 (x, y-1) 是通路且未访问过:将 (x, y-1) 加入队列将 (x, y-1) 标记为已访问返回失败```广度优先搜索法的时间复杂度也为O(N^2)，与迷宫的大小相关。
迷宫问题求解算法设计实验报告
迷宫问题求解算法设计实验报告一、引言迷宫问题一直是计算机科学中的一个经典问题，其解决方法也一直是研究者们探讨的重点之一。
本实验旨在通过设计不同的算法，对迷宫问题进行求解，并对比不同算法的效率和优缺点。
二、算法设计1. 暴力搜索算法暴力搜索算法是最简单直接的求解迷宫问题的方法。
其基本思路是从起点开始，按照某种规则依次尝试所有可能的路径，直到找到终点或所有路径都被尝试过为止。
2. 广度优先搜索算法广度优先搜索算法也称为BFS（Breadth First Search），其基本思路是从起点开始，按照层次依次遍历每个节点，并将其相邻节点加入队列中。
当找到终点时，即可得到最短路径。
3. 深度优先搜索算法深度优先搜索算法也称为DFS（Depth First Search），其基本思路是从起点开始，沿着某一个方向走到底，再回溯到上一个节点继续向其他方向探索。
当找到终点时，即可得到一条路径。
4. A* 算法A* 算法是一种启发式搜索算法，其基本思路是综合考虑节点到起点的距离和节点到终点的距离，选择最优的路径。
具体实现中，可以使用估价函数来计算每个节点到终点的距离，并将其加入优先队列中。
三、实验过程本实验使用 Python 语言编写程序，在不同算法下对迷宫问题进行求解。
1. 数据准备首先需要准备迷宫数据，可以手动输入或从文件中读取。
本实验使用二维数组表示迷宫，其中 0 表示墙壁，1 表示路径。
起点和终点分别用 S 和 E 表示。
2. 暴力搜索算法暴力搜索算法比较简单直接，只需要按照某种规则遍历所有可能的路径即可。
具体实现中，可以使用递归函数来实现深度遍历。
3. 广度优先搜索算法广度优先搜索算法需要使用队列来存储待遍历的节点。
具体实现中，每次从队列中取出一个节点，并将其相邻节点加入队列中。
4. 深度优先搜索算法深度优先搜索算法也需要使用递归函数来实现深度遍历。
具体实现中，在回溯时需要将已经访问过的节点标记为已访问，防止重复访问。
数据结构迷宫问题求解
学号专业计算机科学与技术姓名实验日期2017.6.20教师签字成绩实验报告【实验名称】迷宫问题的求解【实验目的】（1）通过本课程的学习，能熟练掌握几种基本数据结构的基本操作。
（2）能针对给定题目，选择相应的数据结构，分析并设计算法，进而给出问题的正确求解过程并编写代码实现。
（3）用递归和非递归两种方式完成迷宫问题的求解。
【实验原理】迷宫问题通常是用“穷举求解”方法解决，即从入口出发，顺着某一个方向进行探索，若能走通，则继续往前走；否则沿着原路退回，换一个方向继续探索，直至出口位置，求得一条通路。
假如所有可能的通路都探索到而未能到达出口，则所设定的迷宫没有通路。
栈是一个后进先出的结构，可以用来保存从入口到当前位置的路径。
【实验内容】1 需求分析1.基本要求：（1）首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。
求得的通路以三元组（i，j，d）的形式输出。
其中：（i，j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。
如，对于教材第50页图3.4所示的迷宫，输出一条通路为：（1，1，1），（1，2，2），（2，2，2），（3，2，3），（3，1，2），…（2）编写递归形式的算法，求得迷宫中所有可能的通路。
（3）以方阵形式输出迷宫和其通路。
（4）按照题意要求独立进行设计，设计结束后按要求写出设计报告。
2.输入输出的要求：(i) 求得的通路以三元组（i，j，d）的形式输出，其中：（i，j）指示迷宫中的一个坐标，d表示走到下一个坐标的方向。
（ii）输出迷宫示意图3.程序所能达到的功能：(i) 实现一个以链表作存储结构的栈类型，以非递归算法求出通路(ii)以一个递归算法，对任意输入的迷宫矩阵求出所有通路。
2 概要设计1.①构建一个二维数组maze[M][N]用于存储迷宫矩阵②手动生成迷宫，即为二维数组maze[M][N]赋值③构建一个栈用于存储迷宫路径④建立迷宫节点用于存储迷宫中每个节点的访问情况；非递归本程序包含6个函数：(1)主函数 main()(2)生成迷宫 create_maze()(4)打印迷宫 print_maze()(5)搜索迷宫路径并用三元组输出路径 mgpath()(6)用图来输出路径print_tu();递归本程序包含3个函数：（1）主函数main();（2）打印迷宫printmaze()；（3）搜索迷宫路径pass(int x,int y)；3. 详细设计1.非递归起点和终点的结构类型 typedef struct{int h;int l;}T;栈节点类型 typedef struct cell{int row;int col;int dir;}TCell;1.生成迷宫void creat_maze(int a,int b){定义i,j为循环变量for(i<a)for(j<b)输入maze[i][j]的值}2.打印迷宫void print_maze(int m,int n){用i,j循环变量，将maze[i][j]输出}3.搜索迷宫路径void mazepath(int maze[][],T s,T e) //参数传递迷宫和起点与终点{TCell S[N1*N2];top=0; //建立栈S[top].row=s.h;S[top].col=s.l;S[top].dir=-1; //起点入栈while(top>=0) //判栈是否空{ i,j为当前访问点的位置if(i,j是终点坐标)用循环输出栈里的元素；else 将(i,j),即访问点入栈，然后向四周寻找是否有通路，若有通路，将原访问点标记（赋值-1），选一条通路作为新访问点，入栈。
数据结构迷宫求解
数据结构迷宫求解迷宫问题是一种常见的求解问题，通过在迷宫中找到从起点到终点的路径。
在计算机科学中，使用数据结构来解决迷宫问题非常方便。
本文将介绍迷宫问题的基本原理、常见的求解方法以及使用不同数据结构的优缺点。
首先，我们需要明确迷宫的基本定义。
迷宫可以看作是一个二维的网格，其中包含一些墙壁和通路。
起点是迷宫的入口，终点则是迷宫的出口。
我们的目标是找到从起点到终点的一条路径。
迷宫问题可以使用多种算法求解，包括深度优先（DFS）、广度优先（BFS）、最短路径算法等。
以下将详细介绍这些算法以及它们在迷宫问题中的应用。
同时，我们还会讨论不同数据结构在求解迷宫问题中的优缺点。
首先，深度优先（DFS）是一种常用的求解迷宫问题的算法。
该算法从起点开始，一直到终点，期间遇到墙壁或已经访问过的点则回溯到上一个节点。
DFS可以使用递归实现，也可以使用栈来保存需要回溯的节点。
DFS的优点是简单易懂，易于实现。
然而，它可能会陷入死循环或者找到一条较长的路径而不是最短路径。
另一种常见的算法是广度优先（BFS），它从起点开始，逐层扩展，直到找到终点为止。
BFS可以使用队列来保存每一层的节点。
与DFS相比，BFS能够找到最短路径，但它需要维护一个较大的队列，从而增加了空间复杂度。
除了DFS和BFS，还有一些其他算法可以应用于迷宫问题。
例如，迪杰斯特拉算法和A*算法可以找到最短路径。
这些算法使用了图的概念，将迷宫中的通道表示为图的边，将各个节点之间的距离表示为图的权重。
然后，通过计算最短路径的权重，找到从起点到终点的最短路径。
迪杰斯特拉算法和A*算法的优点是能够找到最短路径，但它们的实现较为复杂。
在使用这些算法求解迷宫问题时，我们需要选择适合的数据结构来存储迷宫和过程中的状态。
以下是几种常见的数据结构以及它们的优缺点：1.数组：数组是一种常见的数据结构，它可以用来表示迷宫。
可以使用二维数组来表示迷宫的网格，并使用特定的值表示墙壁和通路。
迷宫问题算法
迷宫问题算法随着计算机技术的发展，我们能够利用计算机的能力来解决一些复杂的问题。
其中一个有意思的问题就是迷宫问题，也就是如何从一个迷宫的入口走到出口。
本文将向大家介绍迷宫问题的算法及其实现。
一、迷宫问题的形式化定义一个迷宫可以被看做是一个有向图，其中每个节点表示一个房间，边表示房间之间的通路。
我们假设每个房间有四个方向，上下左右，故有向图的每个节点最多有四个邻居节点。
假设起点为S，终点为T，每个节点的代价为1，表示每个走过的房间代价都是一样的。
我们的目标是找到一条S到T的最短路径。
如果这条路径不存在，则说明从S无法到达T。
二、基于深度优先搜索的解法深度优先搜索是一种基于回溯的搜索方法，其思路是从起点开始，递归地遍历每个节点，在遍历过程中标记已访问过的节点，直到找到终点或者所有节点都被遍历过。
对于迷宫问题，深度优先搜索的具体实现可以作为如下所示：```pythondef dfs(maze, visited, x, y, endX, endY, steps):if x == endX and y == endY:return stepsif visited[x][y]:return float('inf')visited[x][y] = TrueminSteps = float('inf')for dx, dy in ((0, 1), (1, 0), (0, -1), (-1, 0)):nx, ny = x + dx, y + dyif 0 <= nx < len(maze) and 0 <= ny < len(maze[0]) and maze[nx][ny] == 0:newSteps = dfs(maze, visited, nx, ny, endX, endY, steps + 1)minSteps = min(minSteps, newSteps)visited[x][y] = Falsereturn minSteps```在这个实现中，我们使用了一个visited数组来记录每个节点是否被访问过，1表示被访问过，0表示未被访问过。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
5、 总结 这次的项目，加强了我动手、思考和解决问题的能力。巩固和加深了对 数据结构的理解，提高综合运用本课程所学知识的能力。培养了我选用
hing at a time and All things in their being are good for somethin
参考书，查阅手册及文献资料的能力。培养独立思考，深入研究，分析 问题、解决问题的能力。通过实际编译系统的分析设计、编程调试，掌 握应用软件的分析方法和工程设计方法。
栈中元素是一个由行、列、方向组成的三元组，栈元素的设计如下：
typedef struct{ int x , y , d ;/* 横纵坐标及方向*/
}datatype ; 栈的定义为： SeqStack s ; iv、达某点，以避免发生死循环： 一种方法是另外设置一个标志数组 mark[m][n]，它的所有元素都初始化为 0，一旦到达了某一点 ( i , j )之后，使 mark[ i ][ j ] 置 1，下次再试探 这个位置时就不能再走了。另一种方法是当到达某点（i , j）后使 maze[ i ] [ j ] 置 -1，以便区别未到达过的点，同样也能起到防止走重复点的目的，此 处采用后一方法，算法结束前可恢复原迷宫。 3、 详细设计
）
mgpath（）：求解迷宫问题，即输出从（1，1）到（M，N）的全部路径和最短 路径（包含最短路径长度）。当找到一条路径时，不使用 return 语句退出，而 是出栈一次，重新回溯走另一条路径，并用 minlen 记录最短路径长度，Path 数组记录最短路径。
ii）程序的数据结构和数据库结构分析 设迷宫为 m 行 n 列，利用 maze[m][n]来表示一个迷宫，maze[i][j]=0 或 1;
3,3,0
栈中每一组数据是所到 哪个方向向下走的，对于图
3,2,1 2,2,0 达的每点的坐标及从该点沿 2,1,1
1,1,0
hing at a time and All things in their being are good for somethin
3 迷宫，走的路线为：(1,1)0(2,1)1(2,2)0(3,2)1(3,3)0(3,4)0（下 脚标表示方向），当无路可走，则应回溯，对应的操作是出栈，沿下一个方向即 方向继续试探。
//找到了出口,输出路径
{
printf("%4d: ",count++);
for (k=0;k<=top;k++)
{
//以三元组输出路径
printf("(%d,%d,%d) ",Stack[k].i,Stack[k].j,Stack[k].di);
if ((k+1)%5==0) printf("\n\t&;move[d].y ; if ( maze[i][j]= =0 ) {
temp={x, y, d} ; Push_SeqStack ( s, temp ) ; x=i ; y=j ; maze[x][y]= -1 ; if (x= =m&&y= =n) return 1 ; /*迷宫有路*/ else d=0 ; } else d++ ; } /*while (d<4)*/ } /*while (! Empty_SeqStack (s ) )*/ return 0 ;/*迷宫无路*/ } 栈中保存的就是一条迷宫的通路。 4、 测试与分析
while (! Empty_SeqStack (s ) ) { Pop_SeqStack (s,＆temp) ;
hing at a time and All things in their being are good for somethin
x=temp.x ; y=temp.y ; d=temp.d+1 ; while (d<4) {
{1,1,1,1,1,1,1,1,1,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,1,1,0,0,0,1,0,1},
{1,0,0,0,0,1,1,0,1,1},
{1,0,1,1,1,0,0,1,0,1},
{1,0,0,0,1,0,0,0,0,1},
{1,0,1,0,0,0,1,0,1,1},
走结点进栈
mg[i][j]=-1;
//避免重复走到该结点
}
else
//没有路径可走,则退栈
{
mg[Stack[top].i][Stack[top].j]=0;
//让该位置变为其他路
径可走结点
top--;
}
}
printf("最短路径如下:\n");
printf("长度: %d\n",minlen);
top++;
//进栈
Stack[top].i=1;
Stack[top].j=1;
Stack[top].di=-1;mg[1][1]=-1; //初始结点进栈
while (top>-1)
//栈不空时循环
{
i=Stack[top].i;j=Stack[top].j;di=Stack[top].di;
if (i==M && j==N)
case 3:i=Stack[top].i,j=Stack[top].j-1;break;
}
if (mg[i][j]==0) find=1;
}
if (find==1)
//找到了下一个可走结点
{ Stack[top].di=di; //修改原栈顶元素的 di 值
top++;Stack[top].i=i;Stack[top].j=j;Stack[top].di=-1;//下一个可
hing at a time and All things in their being are good for somethin
程序设计与算法综合训练》设计报告 1
学号：E11514064 姓名：汪泓章 年级： 大一 专 业：计科
项目名称：迷宫问题的求解 完成日期：2016 年 6 月 28 日
2、 概要设计 i）设计中非递归程序的模块结构图 图中方框表示函数，方框中指出函数名，箭头方向表示函数间的调用关系，虚 线方框表示文件的组成
hing at a time and All things in their being are good for somethin
main（）
mapath（
hing at a time and All things in their being are good for somethin
case 1:i=Stack[top].i;j=Stack[top].j+1;break;
case 2:i=Stack[top].i+1;j=Stack[top].j;break;
iii、栈的设计 当到达了某点而无路可走时需返回前一点，再从前图 一3 点增量开数始组向mo下ve一个方向 继续试探。因此，压入栈中的不仅是顺序到达的各点的坐标，而且还要有从前 一点到达本点的方向，即每走一步栈中记下的内容为(行，列，来的方向)。对 于图 1 所示迷宫，依次入栈为：
top — >
3,4, 0
int top=-1;
//栈顶指针
int count=1;
//路径数计数
int minlen=MaxSize;
//最短路径长度
void mgpath()
//路径为:(1,1)->(M,N)
{
int i,j,di,find,k;
hing at a time and All things in their being are good for somethin
其中：0 表示通路，1 表示不通，当从某点向下试探时，中间点有 4 个方向可以 试探，（见图）而四个角点有 2 个方向，其它边缘点有 3 个方向，为使问题简单 化我们用 maze[m+2][n+2]来表示迷宫，而迷宫的四周的值全部为 1。这样做使 问题简单了，每个点的试探方向全部为 4，不用再判断当前点的试探方向有几 个，同时与迷宫周围是墙壁这一实际问题相一致。
//输出时每 5 个结
点换一行
}
printf("\n");
if (top+1<minlen)
//比较找最短路径
{
for (k=0;k<=top;k++)
Path[k]=Stack[k];
minlen=top+1;
}
mg[Stack[top].i][Stack[top].j]=0; //让该位置变为其他路
迷宫的测试数据如下：左上角（1,1）为入口，右下角（8,9）为出 口。
00100010 00100010 00001101 01110010 00010000 01000101 01111001 11000101 11000000
hing at a time and All things in their being are good for somethin
1、 需求分析
(1)问题描述：以一个 m*n 的长方阵表示迷宫，0 和 1 分别表示迷宫中的通路和障碍。设计 一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。
（2）基本要求： 1）首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。 求得的通路以三元组（i，j，d）的形式输出。其中：（i，j）指示迷宫中的一个坐标， d 表示走到下一坐标的方向。如，对于教材第 50 页图 3.4 所示的迷宫，输出一条通路 为：（1，1，1），（1，2，2），（2，2，2），（3，2，3），（3，1，2），…。 2）编写递归形式的算法，求得迷宫中所有可能的通路。 3）以方阵形式输出迷宫及其通路。 4）按照题意要求独立进行设计，设计结束后按要求写出设计报告。