求解迷宫问题(c语言,很详细哦)
用C语言解决迷宫问题
⽤C语⾔解决迷宫问题#include <stdio.h>#include <stdlib.h>#define ROW 10#define COL 10/*迷宫中位置信息*/typedef struct position{int x;int y;}position;/*在迷宫中的当前位置的信息，也是⼊栈的基本元素*/typedef struct SElem{int di;position seat;}SElem;/*链式栈中节点的定义*/typedef struct position_stack{SElem p;struct position_stack *next;}*Stack_pNode,Stack_Node;void InitStack(Stack_pNode *Link){*Link = NULL;}void push(Stack_pNode *Link,SElem e){Stack_pNode new_SElem = (Stack_pNode)calloc(1,sizeof(Stack_Node));new_SElem->p = e;new_SElem->next = NULL;if (*Link == NULL)*Link = new_SElem;else{new_SElem->next = *Link;*Link = new_SElem;}}int pop(Stack_pNode *Link,SElem *e){if (*Link == NULL)return 0;*e = (*Link)->p;Stack_pNode q = *Link;*Link = (*Link)->next;free(q);return 1;}int top(Stack_pNode Link, SElem *e){if (Link == NULL)return 0;*e = Link->p;return 1;}int empty(Stack_pNode Link){if (Link == NULL)return 1;elsereturn 0;}int reverse(Stack_pNode *Link){Stack_pNode p, q, r;if (*Link == NULL || (*Link)->next == NULL)return 0;r = *Link;p = (*Link)->next;q = NULL;while (p){r->next = q;q = r;r = p;p = p->next;}r->next = q;*Link = r;}void print(Stack_pNode Link){Stack_pNode r = Link;while (r){printf("(%d,%d) -> ",r->p.seat.x,r->p.seat.y);r = r->next;}printf("exit\n");}int curstep = 1;/*纪录当前的⾜迹，填写在探索前进的每⼀步正确的路上*//*迷宫地图。
c语言~走迷宫
本程序代码为C语言解决数据结构（严蔚敏）中关于迷宫的问题。
程序不仅实现迷宫路径查找，还实现文字描述路径功能可以直接粘贴到vc6.0中运行【代码如下】# include <stdio.h> # include <malloc.h> # define null 0typedef struct{int (*base)[2];int (*top)[2];int listlen;}sqlist;int topelem[2]; //栈顶元素void creatstack(sqlist *mazepath); //创建一个存储路径的栈void creatmap(int (*mazemap)[10]); //创建迷宫图纸void printmap(int (*mazemap)[10]);void footprint(int x,int y,int k,int (*mazemap)[10]);int position(int x,int y); //判断是否到终点int passroad(int x,int y,int (*mazemap)[10]);void findpath(int (*mazemap)[10],sqlist *mazepath); //在mazemap当中寻找mazepahtvoid printpath(sqlist *mazepath);void roadinwords(sqlist *mazepath); //文字叙述如何走迷宫void push(int x,int y,sqlist *mazepath); //栈操作void pop(sqlist *mazepath);void gettop(sqlist *mazepath);void main(){sqlist mazepath;creatstack(&mazepath); //创建一个存储路径的栈int mazemap[10][10]={1,1,1,1,1,1,1,1,1,1,1,0,0,1,0,0,0,1,0,1,1,0,0,1,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1,1,0,1,1,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,1,1,0,1,0,0,0,1,0,0,1,1,0,1,1,1,0,1,1,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};// creatmap(mazemap); //创建迷宫图纸printf("迷宫原图为：\n");printmap(mazemap);findpath(mazemap,&mazepath); //在mazemap当中寻找mazepaht printf("走出迷宫图纸为：\n");printmap(mazemap);printf("走出迷宫文字叙述为：\n");roadinwords(&mazepath);// printpath(&mazepath);}void findpath(int (*mazemap)[10],sqlist *mazepath){int x,y,flag=0,k=0,next; //位置是否可通，flag=0通，1墙，2通但不可走x=1;y=1; //获取初始位置push(x,y,mazepath); //起点位置进栈footprint(x,y,6,mazemap);while(flag==0 && k!=162) //flag==1到达终点,0未到达终点{if(passroad(x,y+1,mazemap)==0)push(x,y+1,mazepath),y=y+1,footprint(x,y,6,mazemap);else if(passroad(x+1,y,mazemap)==0)push(x+1,y,mazepath),x=x+1,footprint(x,y,6,mazemap);else if(passroad(x,y-1,mazemap)==0)push(x,y-1,mazepath),y=y-1,footprint(x,y,6,mazemap);else if(passroad(x-1,y,mazemap)==0)push(x-1,y,mazepath),x=x-1,footprint(x,y,6,mazemap);elsefootprint(x,y,2,mazemap),pop(mazepath),gettop(mazepath),x=topelem[0],y= topelem[1];// printmap(mazemap);k++;flag=position(x,y); //判断是否到达终点// printf("flag==%d\n",flag);}}void creatstack(sqlist *mazepath){mazepath->base=(int (*)[2])malloc(120*sizeof(int (*)[2]));mazepath->top=mazepath->base;mazepath->listlen=120;}void push(int x,int y,sqlist *mazepath){**(mazepath->top)=x;*(*(mazepath->top)+1)=y;mazepath->top++;}void pop(sqlist *mazepath){if(mazepath->top!=mazepath->base)mazepath->top--;}void printmap(int (*mazemap)[10]){int (*p)[10];p=mazemap;int i,j;printf(" \n\n\n");for(i=0;i<10;i++){for(j=0;j<10;j++){if(j==0)printf(" ");if(*(*(p+i)+j)==0)printf("▇");else if(*(*(p+i)+j)==1)printf("□");else if(*(*(p+i)+j)==6)printf("★");elseprintf("▇");if(j==9)printf("\n");}}printf("\n\n");}void printpath(sqlist *mazepath){int (*p)[2];p=mazepath->base;while(p!=mazepath->top){printf("x=%d,y=%d\n",**p,*(*p+1));p++;}}void gettop(sqlist *mazepath){int (*p)[2];int (*q)[2];p=mazepath->base;while(p!=mazepath->top){q=p;p++;}topelem[0]=**q;topelem[1]=*(*q+1);}void footprint(int x,int y,int k,int (*mazemap)[10]){if(x<10 && y<10)*(*(mazemap+x)+y)=k;}int position(int x,int y){int flag;if(x==8 && y==8)flag=1;elseflag=0;return(flag);}int passroad(int x,int y,int (*mazemap)[10]) {int num=1;if(x<10 && y<10)num=*(*(mazemap+x)+y);return(num);}void roadinwords(sqlist *mazepath){int x=1,y=1,i=0;int (*p)[2];p=mazepath->base;p++;while(p!=mazepath->top){if(x==**p && y+1==*(*p+1))printf("向右走→→"),x=**p,y=*(*p+1);else if(x+1==**p && y==*(*p+1))printf("向下走→→"),x=**p,y=*(*p+1);else if(x==**p && y-1==*(*p+1))printf("向左走→→"),x=**p,y=*(*p+1);else if(x-1==**p && y==*(*p+1))printf("向上走→→"),x=**p,y=*(*p+1);i++;if(i%3==0)printf("\n");p++;}printf("\n");}。
求解迷宫问题 (c语言
求迷宫问题就是求出从入口到出口的路径。
在求解时,通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前试探,若能走通,则继续往前走；否则沿原路退回,换一个方向再继续试探,直至所有可能的通路都试探完为止。
为了保证在任何位置上都能沿原路退回(称为回溯),需要用一个后进先出的栈来保存从入口到当前位置的路径。
首先用如图3.3所示的方块图表示迷宫。
对于图中的每个方块,用空白表示通道,用阴影表示墙。
所求路径必须是简单路径,即在求得的路径上不能重复出现同一通道块。
为了表示迷宫,设置一个数组mg,其中每个元素表示一个方块的状态,为0时表示对应方块是通道,为1时表示对应方块为墙,如图3.3所示的迷宫,对应的迷宫数组mg如下:int mg[M+1][N+1]={ /*M=10,N=10*/{1,1,1,1,1,1,1,1,1,1},{1,0,0,1,0,0,0,1,0,1},{1,0,0,1,0,0,0,1,0,1},/ 1{1,0,0,0,0,1,1,0,0,1}, {1,0,1,1,1,0,0,0,0,1}, {1,0,0,0,1,0,0,0,0,1}, {1,0,1,0,0,0,1,0,0,1}, {1,0,1,1,1,0,1,1,0,1}, {1,1,0,0,0,0,0,0,0,1}, {1,1,1,1,1,1,1,1,1,1} }; 伪代码：c语言描述如下：6/ 2void mgpath() /*路径为:(1,1)->(M-2,N-2)*/{int i,j,di,find,k;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-2 && j==N-2) /*找到了出口,输出路径*/ {瀠楲瑮?迷宫路径如下:\n);for (k=0;k<=top;k++){printf(\ (%d,%d),Stack[k].i,Stack[k].j); if ((k+1)%5==0) printf(\);}6/ 3printf(\);return;}find=0;while (di<4 && find==0) /*找下一个可走方块*/ { di++;switch(di){case 0:i=Stack[top].i-1;j=Stack[top].j;break;case 1:i=Stack[top].i;j=Stack[top].j+1;break;case 2:i=Stack[top].i+1;j=Stack[top].j;break;case 3:i=Stack[top].i;j=Stack[top].j-1;break;}6/ 4if (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;mg[i][j]=-1; /*避免重复走到该方块*/}else /*没有路径可走,则退栈*/{ mg[Stack[top].i][Stack[top].j]=0;/*让该位置变为其他路径可走方块*/top--;}}牰湩晴尨没有可走路径!\n);}6/ 5（范文素材和资料部分来自网络，供参考。
用c语言实现迷宫求解完美源代码
优先队列：用于存储待扩展节点，按照 f(n)值从小到大排序
A*搜索算法的C语言实现
算法流程：包括初始化、搜索、更新父节点等步骤 数据结构：使用优先队列来存储待搜索节点和已访问节点 实现细节：包括如何计算启发式函数、如何选择下一个节点等 性能优化：可以采用多线程、缓存等技术来提高算法的效率
A*搜索算法在迷宫求解中的应用
C语言实现A*搜 索算法
A*搜索算法的基本原理
定义：A*搜索算法是一种启发式搜索 算法，结合了最佳优先搜索和Dijkstra 算法的优点
基本思想：使用启发函数来评估节点的 重要性，优先选择最有希望的节点进行 扩展，从而有效地缩小搜索范围
关键参数：g(n)：从起点经过节点n的 实际代价；h(n)：从n到目标的估计代 价（启发式函数）；f(n)=g(n)+h(n)
最短路径搜索
优化技巧：为了 提高搜索效率和 精度，可以采用 一些优化技巧， 如限制搜索范围、 使用优先队列等
C语言实现 Dijkstra算法
Dijkstra算法的基本原理
Dijkstra算法是一种用于求解最短路径问题的贪心算法 该算法通过不断选择当前最短路径的节点来逼近最短路径 Dijkstra算法适用于带权重的图，其中权重表示节点之间的距离 Dijkstra算法的时间复杂度为O((V+E)logV)，其中V是节点数，E是边数
算法复杂度分析：时间复杂 度和空间复杂度分析
感谢您的观看
汇报人：XX
迷宫求解算法的C语言实现流程
初始化迷宫和路径
定义四个方向的移动方向
遍历迷宫，找到起点和终点
使用深度优先搜索或广度优先 搜索算法求解路径
C语言实现深度 优先搜索算法
深度优先搜索算法的基本原理
c语言走迷宫代码
c语言走迷宫代码以下是一个简单的 C 语言走迷宫代码示例，使用了递归算法: ```c#include <stdio.h>#include <stdlib.h>int main() {int size, row, col, choice, i, j;maze[0][0] = "*";maze[1][0] = "O";maze[0][1] = "O";maze[1][1] = "*";size = 2;row = 2;col = 2;while (1) {printf("Enter row: ");scanf("%d", &row);printf("Enter col: ");scanf("%d", &col);if (row < 0 || row > size || col < 0 || col > size) { printf("Invalid row or col. Try again.");}if (maze[row][col] != "*") {printf("Current cell is free. Try again. ");continue;}maze[row][col] = "X";printf("Enter a choice (1-6): ");scanf("%d", &choice);switch (choice) {case 1:row++;col = 0;break;case 2:row--;col = 0;break;case 3:col++;break;col--;break;case 5:row--;col = 1;break;case 6:row++;col = 1;break;default:printf("Invalid choice. Try again. ");continue;}}printf(" maze: ");for (i = 0; i < size * size; i++) { for (j = 0; j < size; j++) {if (maze[i][j] == "*")printf("*");elseprintf("%c", maze[i][j]);}printf("");}return 0;}```该程序首先初始化了一个 2x2 的迷宫，其中 `maze[0][0]` 和`maze[1][0]` 分别标记为 `"O"` 和 `"*"`,其他地方都为空。
C语言解决迷宫求解问题
迷宫求解
任务：
可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路
径，并将路径输出。
#include<iostream>
//获取栈顶元素
if(!(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y))
p.Push(Temp2);
//如果有新位置入栈，则把上一个探索的位置存入栈 p
for(loop=0;loop<4;loop++) //探索当前位置的 4 个相邻位置
//使栈顶元素出栈
T GetPop();
//取出栈顶元素
void Clear();
//把栈清空
bool empty();
//判断栈是否为空，如果为空则返回 1，否则返回 0
};
Stack::Stack()
//构造函数，置空栈
{
top=NULL;
}
Stack::~Stack()
//析构函数
{
}
void Stack::Push(T e)
//输出路径
{
cout<<"迷宫的路径为\n";
cout<<"括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)\n";
Stack t;
//定义一个栈，按从入口到出口存取路径
int a,b;
T data;
迷宫求解
数据结构实验报告——迷宫求解1、问题描述以一个m x n的长方矩阵表示迷宫，0和1分别表示迷宫中的通路和障碍。
设计一个程序，对任意设定的迷宫，求出从入口到出口的通路，或者没有通路的结论。
2、需求分析1、以二维数组migong[M][N]表示迷宫，其中migong[0][j]和migong[i][0](0<=j,i<=N)为添加的一圈障碍。
数组中以元素0表示通路，1表示障碍，迷宫的大小理论上可以不限制。
2、迷宫数据由程序提供，用户只需要进行选择迷宫就行。
迷宫的入口和出口由程序提供。
3、若设定的迷宫存在通路，则以长方形矩阵的形式将迷宫及其通路输出到标准终端上，其中“0”表示障碍，“2”表示通过的路径，“3”表示死胡同，没有显示的区域表示没有到达过的地方。
4、本程序只求出一条成功的通路。
但是只要对函数进行小量的修改，就可以求出其他全部的路径。
5、程序执行命令为：（1）、创建迷宫；（2）、求解迷宫；（3）、输出迷宫。
3、概要设计a、设定栈的抽象数据类型定义：ADT zhan{数据对象：D={ai|ai属于yanshu，i=1、2…n，n>0}数据关系：R={<ai-1,ai>|ai-1,ai属于D，i=2,3,…n}基本操作：gouzhan(*s,*migong)操作结果：构造一个空栈push（*s，*e）初始条件：栈已经存在操作结果：将e所指向的数据加入到栈s中pop（*s,*e）初始条件：栈已经存在操作结果：若栈不为空，用e返回栈顶元素，并删除栈顶元素getpop（*s，*e）初始条件：栈已经存在操作结果：若栈不为空，用e返回栈顶元素popover(*s)初始条件：栈已经存在操作结果：输出栈中的所有元素，同时清空栈stackempty(*s)初始条件：栈已经存在操作结果：判断栈是否为空。
若栈为空，返回1，否则返回0destroy(*s)初始条件：栈已经存在操作结果：销毁栈s}ADT zhanb、设定迷宫的抽象数据类型定义ADT yanshu{数据对象：D={ai,j|ai,j属于{‘’、‘0’、‘2’、‘3’},0<=i<=M,0<=j<=N}数据关系：R={ROW,COL}ROW={<ai-1,j,ai,j>|ai-1,j,ai,j属于D，i=1,2,…M,j=0,1,…N}COL={<ai,j-1,ai,j>|ai,j-1,ai,j属于D,i=0,1,…M，j=1,2,…N}基本操作：gouzhaomigong(*migong,m,n)初始条件：二维数组migong[m][n]已经存在，其中第1至第m-1行，每行自第1到第n-1列的元素已经值，并以值0表示障碍，值1表示通路。
c语言迷宫代码
c语言迷宫代码C语言迷宫代码是指用C语言编写的程序，用于生成和解决迷宫问题的算法。
迷宫通常由一个矩形网格组成，其中包含墙壁和通道。
目标是找到从迷宫的起点到终点的路径，同时避开墙壁。
下面是一个简单的示例代码，用于生成迷宫：```c#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#define ROWS 10#define COLS 10typedef struct {int x;int y;} Point;void generateMaze(int maze[ROWS][COLS]) {for (int i = 0; i < ROWS; i++) {for (int j = 0; j < COLS; j++) {if (i % 2 == 0 || j % 2 == 0) { maze[i][j] = 1; // 墙壁} else {maze[i][j] = 0; // 通道}}}}void printMaze(int maze[ROWS][COLS]) {for (int i = 0; i < ROWS; i++) {for (int j = 0; j < COLS; j++) {printf('%d ', maze[i][j]);}printf('');}}int main() {int maze[ROWS][COLS];generateMaze(maze);printMaze(maze);return 0;}```在上面的代码中，我们使用一个二维数组来表示迷宫。
数组中的值为1表示墙壁，值为0表示通道。
使用generateMaze函数，我们将迷宫的墙壁和通道初始化为适当的值。
然后使用printMaze函数打印迷宫。
通过运行上面的代码，我们可以得到一个简单的迷宫的表示：```1 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 1```当然，上述代码只是生成了一个简单的迷宫，还没有解决迷宫问题。
数据结构C语言版递归求解迷宫问题
数据结构C语言版_递归求解迷宫问题/*数据结构C语言版递归求解迷宫问题用递归函数求解迷宫问题(求出所有解)编译环境：Dev-C++ 4.9.9.2日期：2011年2月12日*/#include<stdio.h>// 迷宫坐标位置类型struct PosType{int x; // 行值int y; // 列值};#define MAXLENGTH 25 // 设迷宫的最大行列为25typedef int MazeType[MAXLENGTH][MAXLENGTH]; // [行][列]// 全局变量struct PosType end; // 迷宫终点位置MazeType m; // 迷宫数组int x, y; // 迷宫行数，列数// 定义墙元素值为0,可通过路径为-1,通过路径为足迹// 输出解void Print(int x,int y){int i,j;for(i=0;i<x;i++){for(j=0;j<y;j++)printf("%3d",m[i][j]);printf("\n");}printf("\n");}// 由当前位置cur、当前步骤curstep试探下一点void Try(struct PosType cur,int curstep){int i;struct PosType next; // 下一个位置// {行增量,列增量}struct PosType direc[4]={{0,1},{1,0},{0,-1},{-1,0}};// 移动方向,依次为东南西北for(i=0;i<=3;i++) // 依次试探东南西北四个方向{next.x=cur.x+direc[i].x;next.y=cur.y+direc[i].y;if(m[next.x][next.y] == -1) // 是通路{m[next.x][next.y]=++curstep;if(next.x != end.x || next.y != end.y) // 没到终点Try(next,curstep); // 试探下一点(递归调用)elsePrint(x,y); // 输出结果m[next.x][next.y]=-1; // 恢复为通路，试探下一条路curstep--;}}}// 0为墙，-1为通道int main(){struct PosType begin; //起点int i,j,x1,y1;printf("请输入迷宫的行数,列数(包括外墙)：（空格隔开）"); scanf("%d%d",&x,&y);for(i=0;i<x;i++) // 定义周边值为0(同墙){m[0][i]=0; // 迷宫上面行的周边即上边墙m[x-1][i]=0;// 迷宫下面行的周边即下边墙}for(j=1;j<y-1;j++){m[j][0]=0; // 迷宫左边列的周边即左边墙m[j][y-1]=0;// 迷宫右边列的周边即右边墙}for(i=1;i<x-1;i++)for(j=1;j<y-1;j++)m[i][j]=-1; // 定义通道初值为-1printf("请输入迷宫内墙单元数(即墙的个数)：");scanf("%d",&j);if(j)printf("请依次输入迷宫内墙每个单元的行数,列数：（空格隔开）\n"); for(i=1;i<=j;i++){scanf("%d%d",&x1,&y1);m[x1][y1]=0;}printf("迷宫结构如下:\n");Print(x,y);printf("请输入起点的行数,列数：（空格隔开）");scanf("%d%d",&begin.x,&begin.y);printf("请输入终点的行数,列数：（空格隔开）");scanf("%d%d",&end.x,&end.y);m[begin.x][begin.y]=1;Try(begin,1); // 由第一步起点试探起system("pause");return 0;}/*输出效果：请输入迷宫的行数,列数(包括外墙)：（空格隔开）4 4请输入迷宫内墙单元数(即墙的个数)：1请依次输入迷宫内墙每个单元的行数,列数：（空格隔开）1 2迷宫结构如下:0 00 00 -1 0 00 -1 -1 00 0 0 0请输入起点的行数,列数：（空格隔开）1 1 请输入终点的行数,列数：（空格隔开）2 2 0 0 0 00 1 0 00 2 3 00 0 0 0请按任意键继续. . .*/。
C语言实现走迷宫
C语⾔实现⾛迷宫本⽂实例为⼤家分享了C语⾔实现⾛迷宫的具体代码，供⼤家参考，具体内容如下描述给⼀张个迷宫，问能否从起点⾛到终点，只能往上下左右⾛，不能斜着⾛输⼊多组测试数据，每组第⼀⾏两个正整数，分别为n和m表⽰n这个迷宫有n⾏m列(0<n,m<10)接着是n⾏m列，'#'表⽰路‘*'表⽰墙‘S'表⽰起点‘T'表⽰终点输出每组测试数据输出⼀个结果，如果能从S⾛到T，输出“YES”,否则输出“NO”输⼊样例：2 2S*#T3 3S*##T##输出样例：YESNO有两种⽅法可以解决这个问题第⼀种深度优先搜索：站在⼊⼝，考虑⾃⼰下⼀步可以⾛哪⾥，⾛到下⼀个位置后，再考虑下⼀步怎么⾛，⼀直⾛下去，直到没有路，然后再返回最近的⼀个岔路⼝，选其它任⼀条没试过的路，如果不能⾛，再尝试其他的路，直到这个岔路⼝的路全部试完，再回到上⼀个路⼝，看是否能⾛到出⼝，相当于⼀条路⾛到⿊#include<bits/stdc++.h>using namespace std;char a[20][20]; //存储迷宫字符数组int flag,m,n;int sdep_x[4]={-1,1,0,0},sdep_y[4]={0,0,-1,1};//控制上下左右⽅向int vis[20][20]; //标记⾛过的路void dfs(int x,int y){vis[x][y]=1; //代表被标记过了if(a[x][y]=='T') //找到出⼝{flag=1;return;}for(int i=0;i<4;i++) //搜索路径{int h=x+sdep_x[i];int l=y+sdep_y[i];if(a[h][l]!='*'&&!vis[h][l]&&h>=0&&h<n&&l>=0&&l<m)//搜索路径的条件{dfs(h,l);}}}int main(){while(cin>>n>>m){memset(vis,0,sizeof(vis));//初始化数组flag=0;int f,g;for(int i=0;i<n;i++)for(int j=0;j<m;j++)cin>>a[i][j];for(int i=0;i<n;i++)for(int j=0;j<m;j++){if(a[i][j]=='S')//先找到路⼝{f=i;g=j;}}dfs(f,g);if(flag)cout<<"YES"<<endl;elsecout<<"NO"<<endl;}return 0;}第⼆种⽅法⼴度优先搜索：这⼀步之后，把接下来⼀步的所有路都列出来，在之后的所有扩展之中，在以⼀个为下⼀步，再将所有的该步可以到达的下⼀步，全部列举出来，再将第⼆步的其他选择中的每⼀步，都⼀⼀做扩展，每次扩展，都要检查所扩展的地⽅有没有到达搜索的要求。
(完整word版)c语言迷宫最完整做法
＃include〈stdio。
h〉＃include〈stdlib。
h>＃include〈time.h>#define stack_init_size 200#define stack_increment 10#define ERROE 0#define TRUE 1#define FALSE 0#define OVERFLOW 0＃define OK 1typedef int Status;typedef struct{int x;int y；}PosType;typedef struct {int ord; // 通道块在路径上的“序号”PosType seat; //通道块在迷宫中的“坐标位置”int di; //从此通道块走向下一通道块的“方向”}SElemType；typedef struct｛SElemType ＊base;SElemType ＊top；int stacksize；}SqStack;int mg［20］[20]；/*随机生成迷宫的函数/＊为了能够让尽量能通过,将能通过的块和不能通过的块数量比大致为2:1*/void Random()｛int i，j,k;srand(time（NULL)）；mg［1][0]=mg［1]［1]=mg[18］[19]=0; //将入口、出口设置为“0"即可通过for(j=0;j〈20;j++）mg[0][j］=mg［19］[j]=1；/*设置迷宫外围“不可走”,保证只有一个出口和入口＊/ for（i=2；i〈19；i++）mg[i］[0]=mg［i—1][19］=1; /＊设置迷宫外围“不可走”，保证只有一个出口和入口＊/ for(i=1;i〈19；i++）for（j=1；j<19；j++)｛k=rand（)％3; //随机生成0、1、2三个数if（k）mg[i]［j］=0；else｛if（（i==1&&j==1)|｜(i==18＆＆j==18)) /＊因为距入口或出口一步的路是必经之路，故设该通道块为“0”加大迷宫能通行的概率＊/mg[i][j］=0;elsemg[i］［j]=1；}｝｝//构造一个空栈Status InitStack(SqStack &s）{s。
(完整word版)迷宫(C语言版)--数据结构课程设计
一．迷宫问题求解1.问题描述迷宫问题是实验心理学的一个经典问题，心理学家把一只老鼠从一个无顶盖的大盒子的入口出赶迷宫。
迷宫中设置了很多隔壁，对前进方向形成了多出障碍，心理学家在迷宫的唯一出口处放置了一块奶酪，吸引老鼠在迷宫中寻找路径以到达出口。
然而，用计机模拟迷宫问题，即划好迷宫的隔壁的设置，让计算机从入口处进入迷宫探究出一条通路。
2.设计思路回溯法是一种不断试探且及时纠正错误的探索方法。
下面的求解过程既是使用回溯法。
从入口出发，按某一个方向向前探索，若能走通并且未走过，即某处可以到达，则到达新点，否则试探下一个方向；若所有的方向均没有通路，则沿原路返回前一个点，换下一个方向继续探索，直到找到一条通路，或无路可走又返回到入口点。
在求解过程中，为了保证在到达某一点后不能向前继续行走（无路）时，能正确返回前一个点以便继续从下一个方向向前试探，则需要用一个栈保存所有到达点的下标。
另外，求解该问题的一个重要问题是如何防止回溯时走重复节点，以避免发生死循环。
这里，我们采用对走过的结点，修改其结点信息。
如在设计之初，我们设置保存迷宫结构的二维数组中0值代表该节点可走，1值代表其不可走，那么我们可以把走过的结点值改为非0，已使其不能被再次探索。
3．数据结构设计由上面的设计思路知，若想正确的使用回溯法求解迷宫问题，必须要借助一个栈以保存走过的结点信息。
而这里我活用了栈，只把其数据结构抽象为了一个结构体数组，具体设计如下：typedef struct{}pos;pos Pos[100]; /*结构体数组以保存走过的结点信息*/4．功能函数介绍（1）判断是否找到出口函数Isover（）；该函数的参数是当前结点的x、y坐标与出口结点的x、y坐标，通过比较其值来判断是否找到出口结点，从而控制程序结束。
（2）对程序相关信息的简单介绍函数introduce()；该函数主要是在进行绘制迷宫的图形化界面之前开发者搞的一点小插曲，以介绍跟该程序的相关的部分信息。
用栈求解迷宫问题所有路径及最短路径程序c语言
用栈求解迷宫问题所有路径及最短路径程序c语言
摘要：
1.迷宫问题的背景和意义
2.栈的基本概念和原理
3.用栈解决迷宫问题的方法
4.C 语言编程实现步骤
5.程序示例及运行结果
正文：
【1.迷宫问题的背景和意义】
迷宫问题是计算机科学中的一个经典问题，它涉及到图论、数据结构和算法等多个领域。
在迷宫问题中，给定一个有向图，目标是找到从起点到终点的所有路径以及最短路径。
这个问题在现实生活中也有很多应用，例如地图导航、物流路径规划等。
【2.栈的基本概念和原理】
栈是一种线性数据结构，它遵循后进先出（LIFO）的原则。
栈可以用来存储序列中的元素，也可以用来表示函数调用关系。
栈的操作通常包括入栈、出栈、获取栈顶元素等。
【3.用栈解决迷宫问题的方法】
为了解决迷宫问题，我们可以使用栈来记录遍历过程中的路径。
具体步骤如下：
1.创建一个栈，用于存储遍历过程中的路径；
2.从起点开始，将当前节点的编号入栈；
3.遍历当前节点的所有相邻节点，如果相邻节点未被访问过，则将其入栈；
4.当栈不为空时，继续执行步骤3；否则，说明已到达终点，开始回溯，找到最短路径；
5.从栈顶弹出节点，将其添加到结果路径列表中；
6.如果栈为空，说明没有找到从起点到终点的路径；否则，返回结果路径列表。
c语言——迷宫求解
/*人民邮电大学——迷宫求解*/#include <stdio.h>#include <stdlib.h>#define MAX 100/* 栈中最大元素个数 */#define NLENGTH 11 /*地图的第一维长度*/typedef struct{int x;/* 行下标 */int y;/* 列下标 */int d;/* 运动方向 */}DataType;struct SeqStack{ /* 顺序栈类型定义 */int t; /* 指示栈顶位置 */DataType s[MAX];};typedef struct SeqStack *PSeqStack; /* 顺序栈类型的指针类型 */ PSeqStack pastack;PSeqStack createEmptyStack_seq( void ){PSeqStack pastack;pastack = (PSeqStack)malloc(sizeof(struct SeqStack));if (pastack == NULL)printf("内存申请失败!! \n");elsepastack->t = -1;return pastack;}/*空栈吗？*/int isEmptyStack_seq( PSeqStack pastack ){return pastack->t == -1;}/*入栈操作：一个参数*/void Push_seq( PSeqStack pastack, DataType x ){if( pastack->t > MAX)printf( "堆栈溢出错误!\n" );else{pastack->t++;pastack->s[pastack->t] = x;}}/*出栈操作 */void Pop_seq( PSeqStack pastack ){if (pastack->t == -1 )printf( "堆栈溢出错误!\n" );elsepastack->t--;}/*取栈顶元素*/DataType Top_seq( PSeqStack pastack ){return (pastack->s[pastack->t]);}/*入栈操作：四个参数*/void Push_Stack(PSeqStack st, int x, int y, int d){DataType element;element.x = x;element.y = y;element.d = d;Push_seq(st, element);}/*输出路径*/void OutputPath(PSeqStack st){DataType element;printf("\n\n出迷宫的路径是:\n");while(!isEmptyStack_seq(st)){element = Top_seq(st);Pop_seq(st);printf("\n路过的节点坐标是: 第%d行第%d列 ", element.x, element.y); /* 打印路径上的每一点 */}}/*迷宫求解主函数*/void Maze_Path(int Maze[][NLENGTH], int direction[][2], int x1, int y1, int x2, int y2){int i, j, k, g, h;PSeqStack st;DataType element;st = createEmptyStack_seq( );Maze[x1][y1] = 2; /* 从入口开始进入,作标记 */Push_Stack(st, x1, y1, -1); /* 入口点进栈 */while ( !isEmptyStack_seq(st)){ /* 回退 */Pop_seq(st);element = Top_seq(st);if(isEmptyStack_seq(st)){element.x=x1;element.y=y1;element.d=-1;}i = element.x;j = element.y;for (k = element.d + 1; k <= 3; k++){ /* 依次试探每个方向 */g = i + direction[k][0];h = j + direction[k][1];if (g == x2 && h == y2 && Maze[g][h] == 0){ /* 走到出口点 */Push_Stack(st, x2, y2, -1); /* 出口点进栈 */OutputPath(st); /* 输出路径 */return;}if (Maze[g][h] == 0){ /*道路通畅，未免重复对走到没走过的点作标记 */Maze[g][h] = 2;Push_Stack(st, g, h, k); /* 进栈 */i = g; j = h; k = -1; /* 下一点转换成当前点 */}}}printf("\n未找到路径.\n");/* 栈退完未找到路径 */}/*迷宫数据*/int Maze[][11] ={1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,1,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};int direction[][2]={0,1,/*x不变，Y+1*/1,0,/*X+1，Y不变*/0,-1,/*X不变，Y-1*/-1,0 /*X-1，Y不变*/}; /*向四面运动时，X，Y的增减量,即方向*/int main(){int x1,x2,y1,y2,i,j;/*入口，出口，循环变量声明*/x1 =1;y1 =1;x2 = 9;y2 = 9;for(i = 0;i<11;i++){for(j=0;j<11;j++){printf("%d ",Maze[i][j]);}printf("\n\r");}printf("从结点:第%d行,第%d列到达结点:第%d行,第%d列",x2,y2,x1,y1);Maze_Path(Maze,direction,x1,y1,x2,y2);return 0;}//QQ交流群248936001。
(完整word版)数据结构C语言迷宫求解问题(有要求和源代码)
1、迷宫求解设计一个迷宫求解程序，要求如下：✓以M × N表示长方阵表示迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。
✓能任意设定的迷宫✓（选作）如果有通路，列出所有通路提示：✓以一个二维数组来表示迷宫，0和1分别表示迷宫中的通路和障碍，如下图迷宫数据为：1111111111 Array 100100010110010001011000011001101110000110001000011010001001101110110111000000011111111111入口位置：1 1出口位置：8 8✓探索过程可采用如下算法，设定当前位置的初值为入口位置；do {若当前位置可通，则｛将当前位置插入栈顶；若该位置是出口位置，则结束；否则切换当前位置的东邻方块为新的当前位置；｝否则，｛若栈不空且栈顶位置尚有其他方向未经探索，则设定新的当前位置为沿顺时针方向旋转找到的栈顶位置的下一相邻块；若栈不空但栈顶位置的四周均不可通，则｛删去栈顶位置；//从路径中删去该通道块若栈不空，则重新测试新的栈顶位置，直至找到一个可通的相邻块出栈至栈空；｝｝｝while (栈不空)；#include<stdio.h>#include<string.h>#define MaxSize 32int a[30][30];int b[30][30];int m,n;typedef struct{int i;int j;int di;}Box;typedef struct{Box data[MaxSize];int top;}StackType;bool sereach(int X,int Y,int X1,int Y1);void main(){int X,Y,Y1,X1;memset(a,0,sizeof(a));memset(b,0,sizeof(b));// for()printf("请输入迷宫的长度和宽度\n");while(~scanf("%d%d",&m,&n)){printf("请输入迷宫（0表示空地，1表示围墙）\n");for(int i=0;i<n;i++){for(int j=0;j<m;j++){scanf("%d",&a[i][j]);if(a[i][j]==1)b[i][j]=-1;}}printf("请输入迷宫起点的行号和列号\n");scanf("%d%d",&X,&Y);printf("请输入迷宫终点的行号和列号\n");scanf("%d%d",&X1,&Y1);if(!sereach(X,Y,X1,Y1))printf("该迷宫没有解!\n");printf("请输入迷宫的长度和宽度\n");}// return 0;}bool sereach(int X,int Y,int X1,int Y1){StackType st;int i,j,di,find;st.top=-1;while(a[X][Y]!=0){printf("迷宫起点的行号和列号有错，请重新输入\n");scanf("%d%d",&X,&Y);}if(a[X][Y]==0)b[X][Y]=-1;while(a[X1][Y1]!=0){printf("迷宫终点的行号和列号有错，请重新输入\n");scanf("%d%d",&X1,&Y1);}st.top++;st.data[st.top].i=X;st.data[st.top].j=Y;st.data[st.top].di=-1;do{find=0;i=st.data[st.top].i;j=st.data[st.top].j;di=st.data[st.top].di;while(di<4&&find==0){di++;switch(di){case 0:i=st.data[st.top].i-1;j=st.data[st.top].j;break;case 1:i=st.data[st.top].i;j=st.data[st.top].j+1;break;case 2:i=st.data[st.top].i+1;j=st.data[st.top].j;break;case 3:i=st.data[st.top].i;j=st.data[st.top].j-1;break;}if(b[i][j]==0&&i>=0&&i<n&&j>=0&&j<m)find=1;}if(find == 1){st.data[st.top].di=di;st.top++;st.data[st.top].i=i;s t.data[st.top].j=j;st.data[st.top].di=-1;b[i][j]=-1;find=0;}else{b[st.data[st.top].i][st.data[st.top].j]=0;st.top--;}if(i==X1&&j==Y1){printf("迷宫路径如下:\n");for(int k=0;k<=st.top;k++){printf("%d,%d\t",st.data[k].i,st.data[k].j);if((k+1)%6==0)printf("\n");}printf("\n");。
c语言实现迷宫问题
数据结构试验——迷宫问题一基本问题1.问题描述这是心理学中的一个经典问题..心理学家把一只老鼠从一个无顶盖的大盒子的入口处放入;让老鼠自行找到出口出来..迷宫中设置很多障碍阻止老鼠前行;迷宫唯一的出口处放有一块奶酪;吸引老鼠找到出口..简而言之;迷宫问题是解决从布置了许多障碍的通道中寻找出路的问题..本题设置的迷宫如图1所示..图1 迷宫示意图迷宫四周设为墙；无填充处;为可通处..设每个点有四个可通方向;分别为东、南、西、北为了清晰;以下称“上下左右”..左上角为入口..右下角为出口..迷宫有一个入口;一个出口..设计程序求解迷宫的一条通路..2.数据结构设计以一个m×n的数组mg表示迷宫;每个元素表示一个方块状态;数组元素0和1分别表示迷宫中的通路和障碍..迷宫四周为墙;对应的迷宫数组的边界元素均为1..根据题目中的数据;设置一个数组mg如下int mgM+2N+2={{1;1;1;1;1;1;1;1};{1;0;0;1;0;0;0;1};{1;1;0;0;0;1;1;1};{1;0;0;1;0;0;0;1};{1;0;0;0;0;0;0;1};{1;1;1;1;1;1;1;1}};在算法中用到的栈采用顺序存储结构;将栈定义为Struct{ int i; //当前方块的行号int j; //当前方块的列号int di; //di是下一个相邻的可走的方位号}stMaxSize;// 定义栈int top=-1 //初始化栈3设计运算算法要寻找一条通过迷宫的路径;就必须进行试探性搜索;只要有路可走就前进一步;无路可进;换一个方向进行尝试；当所有方向均不可走时;则沿原路退回一步称为回溯;重新选择未走过可走的路;如此继续;直至到达出口或返回入口没有通路..在探索前进路径时;需要将搜索的踪迹记录下来;以便走不通时;可沿原路返回到前一个点换一个方向再进行新的探索..后退的尝试路径与前进路径正好相反;因此可以借用一个栈来记录前进路径..方向：每一个可通点有4个可尝试的方向;向不同的方向前进时;目的地的坐标不同..预先把4个方向上的位移存在一个数组中..如把上、右、下、左即顺时针方向依次编号为0、1、2、3.其增量数组move4如图3所示..move4x y0-110121030-1图2数组move4方位示意图如下：通路：通路上的每一个点有3个属性：一个横坐标属性i、一个列坐标属性j和一个方向属性di;表示其下一点的位置..如果约定尝试的顺序为上、右、下、左即顺时针方向;则每尝试一个方向不通时;di值增1;当d 增至4时;表示此位置一定不是通路上的点;从栈中去除..在找到出口时;栈中保存的就是一条迷宫通路..1下面介绍求解迷宫xi;yj到终点xe;ye的路径的函数：先将入口进栈其初始位置设置为—1;在栈不空时循环——取栈顶方块不退栈①若该方块为出口;输出所有的方块即为路径;其代码和相应解释如下：int mgpathint xi;int yi;int xe;int ye //求解路径为:xi;yi->xe;ye {struct{int i; //当前方块的行号int j; //当前方块的列号int di; //di是下一可走方位的方位号} stMaxSize; //定义栈int top=-1; //初始化栈指针int i;j;k;di;find;top++; //初始方块进栈sttop.i=xi;sttop.j=yi;sttop.di=-1;mg11=-1;while top>-1 //栈不空时循环{i=sttop.i;j=sttop.j;di=sttop.di; //取栈顶方块if i==xe && j==ye //找到了出口;输出路径{printf"迷宫路径如下:\n";for k=0;k<=top;k++{printf"\t%d;%d";stk.i;stk.j;if k+1%5==0 //每输出每5个方块后换一行printf"\n";}printf"\n";return1; //找到一条路径后返回1}②否则;找下一个可走的相邻方块若不存在这样的路径;说明当前的路径不可能走通;也就是恢复当前方块为0后退栈..若存在这样的方块;则其方位保存在栈顶元素中;并将这个可走的相邻方块进栈其初始位置设置为-1求迷宫回溯过程如图4所示从前一个方块找到相邻可走方块之后;再从当前方块找在、相邻可走方块;若没有这样的方快;说明当前方块不可能是从入口路径到出口路径的一个方块;则从当前方块回溯到前一个方块;继续从前一个方块找可走的方块..为了保证试探的可走的相邻方块不是已走路径上的方块;如i;j已经进栈;在试探i+1;j的下一方块时;又试探道i;j;这样会很悲剧的引起死循环;为此;在一个方块进栈后;将对应的mg数组元素的值改为-1变为不可走的相邻方块;当退栈时表示该方块没有相邻的可走方块;将其值恢复0;其算法代码和相应的解释如下：find=0;while di<4 && find==0 //找下一个可走方块{di++;switchdi{case 0:i=sttop.i-1;j=sttop.j;break;case 1:i=sttop.i;j=sttop.j+1;break;case 2:i=sttop.i+1;j=sttop.j;break;case 3:i=sttop.i;j=sttop.j-1;break;}if mgij==0 find=1;//找到下一个可走相邻方块}if find==1 //找到了下一个可走方块{sttop.di=di; //修改原栈顶元素的di值top++; //下一个可走方块进栈sttop.i=i;sttop.j=j;sttop.di=-1;mgij=-1; //避免重复走到该方块}else //没有路径可走;则退栈{mgsttop.isttop.j=0;//让该位置变为其他路径可走方块top--; //将该方块退栈}}return0; //表示没有可走路径;返回02求解主程序建立主函数调用上面的算法;将mg和st栈指针定义为全局变量void main{mgpath1;1;M;N;}3界面设计设计很简单的界面;输出路径4运行结果图5..基本运行结果二8个方向的问题1.设计思想1设置一个迷宫节点的数据结构..2建立迷宫图形..3对迷宫进行处理找出一条从入口点到出口点的路径..4输出该路径..5打印通路迷宫图..图6功能结构图当迷宫采用二维数组表示时;老鼠在迷宫任一时刻的位置可由数组的行列序号i;j来表示..而从 i;j位置出发可能进行的方向见下图7.如果i;j周围的位置均为0值;则老鼠可以选择这8个位置中的任一个作为它的下一位置..将这8个方向分别记作：E东、SE东南、S南SW西南W西、NW 西北、N北和NE东北..但是并非每一个位置都有8个相邻位置..如果i;j 位于边界上;即i=1;或i=m;或j=1;或j=n;则相邻位置可能是3个或5个为了避免检查边界条件;将数组四周围用值为1的边框包围起来;这样二维数组maze应该声明为mazem+2;n+2在迷宫行进时;可能有多个行进方向可选;我们可以规定方向搜索的次序是从东E沿顺时针方向进行..为了简化问题;规定i;j的下一步位置的坐标是x;y;并将这8个方位伤的x和y坐标的增量预先放在一个结构数组move8中见图8..该数组的每个分量有两个域dx和dy..例如要向东走;只要在j值上加上dy;就可以得到下一步位置的x;y值为i;j+dy..于是搜索方向的变化只要令方向值dir从0增至7;便可以从move数组中得到从i;j点出发搜索到的每一个相邻点x;y..x=i+movedir.dxy=j+movedir.dydx dy图7 方向位移图图8向量差图为了防止重走原路;我们规定对已经走过的位置;将原值为0改为-1;这既可以区别该位置是否已经走到过;又可以与边界值1相区别..当整个搜索过程结束后可以将所有的-1改回到0;从而恢复迷宫原样..这样计算机走迷宫的方法是：采取一步一步试探的方法..每一步都从E开始;按顺时针对8个方向进行探测;若某个方位上的mazex;y=0;表示可以通行;则走一步；若mazex;y=1;表示此方向不可通行须换方向再试..直至8个方向都试过;mazex;y均为1;说明此步已无路可走;需退回一步;在上一步的下一个方向重新开始探测..为此需要设置一个栈;用来记录所走过的位置和方向i;j;dir..当退回一步时;就从栈中退出一个元素;以便在上一个位置的下一个方向上探测;如又找到一个行进方向;则把当前位置和新的方向重新进栈;并走到新的位置..如果探测到x=m;y=n;则已经到达迷宫的出口;可以停止检测;输出存在栈中的路径；若在某一位置的8个方向上都堵塞;则退回一步;继续探测;如果已经退到迷宫的入口栈中无元素;则表示此迷宫无路径可通行..2系统算法伪代码描述：1建立迷宫节点的结构类型stack..2入迷宫图形0表示可以通1表示不可以通.. 用二维数组mazem+2n+2进行存储..数组四周用1表示墙壁;其中入口点1;1与出口点m;n固定..3函数path对迷宫进行处理;从入口开始：Whiles->top==-1&&dir>=7||x==M&&y==N&&mazexy==-1{For扫描八个可以走的方向{If找到一个可以走的方向{进入栈标志在当前点可以找到一个可以走的方向避免重复选择mazexy=-1不再对当前节点扫描}If八个方向已经被全部扫描过;无可以通的路{标志当前节点没有往前的路后退一个节点搜索}}If找到了目的地{输出路径退出循环}}未找到路径4输出从入口点到出口点的一条路径..5输出标有通路的迷宫图..3.算法流程图：图9 算法流4.程序代码：define M2 12 /M2N2为实际使用迷宫数组的大小/ define N2 11define maxlen M2 // 栈长度include <stdio.h>include<iostream.h>include <malloc.h>int M=M2-2;N=N2-2;//MN迷宫的大小typedef struct //定义栈元素的类型{int x;y;dir;}elemtype;typedef struct // 定义顺序栈{elemtype stack maxlen;int top;}sqstktp;struct moved//定义方向位移数组的元素类型对于存储坐标增量的方向位移数组move{ int dx;dy;};/////////////////////////////////////////////////////////////// /////////////////////////////////////void inimazeint mazeN2////初始化迷宫{int i;j;num;fori=0;j=0;i<=M+1;i++//设置迷宫边界mazeij=1;fori=0;j=0;j<=N+1;j++mazeij=1;fori=M+1;j=0;j<=N+1;j++mazeij=1;cout<<"原始迷宫为："<<endl;fori=1;i<=M;i++{for j=1;j<=N;j++{num=800i+j+1500 % 327;//根据MN的值产生迷宫if num<150&&i=M||j=Nmazeij=1;elsemazeij=0;cout<<mazeij<<" ";//显示迷宫}cout<<endl;}cout<<endl;}//inimaze/////////////////////////////////////////////////////////////// ////////////////////////////////////////////////void inimovestruct moved move//初始化方向位移数组{//依次为East;Southeast;south;southwest;west;northwest;north;northeast move0.dx=0;move0.dy=1;move1.dx=1;move1.dy=1;move2.dx=1;move2.dy=0;move3.dx=1;move3.dy=-1;move4.dx=0;move4.dy=-1;move5.dx=-1;move5.dy-=1;move6.dx=-1;move6.dy=0;move7.dx=-1;move7.dy=1;}//void inistacksqstktp s /初始化栈/{s->top=-1;} /inistack/int pushsqstktps;elemtype x{ifs->top==maxlen-1returnfalse;else{s->stack++s->top=x;/栈不满;执行入栈操作/returntrue;}}/push/elemtype popsqstktp s/栈顶元素出栈/{elemtype elem;ifs->top<0 //如果栈空;返回空值{elem.x=NULL;elem.y=NULL;elem.dir=NULL;returnelem;}else{s->top--;returns->stacks->top+1; //栈不空;返回栈顶元素}} //pop/////////////////////////////////////////////////////////////// /////////////////////void pathint mazeN2;struct moved move;sqstktp s //寻找迷宫中的一条通路{int i;j;dir;x;y;f;elemtype elem;i=1;j=1;dir=0;maze11=-1; //设11为入口处do{x=i+movedir.dx;//球下一步可行的到达点的坐标y=j+movedir.dy;ifmazexy==0{elem.x=i;elem.y=j;elem.dir=dir;f=pushs;elem;//如果可行将数据入栈iff==false//如果返回假;说明栈容量不足cout<<"栈长不足";i=x;j=y;dir=0;mazexy=-1;}elseif dir < 7dir++;else{elem=pops; //8个方向都不行;回退ifelem.x=NULL{i=elem.x;j=elem.y;dir=elem.dir+1;}}}whiles->top==-1&&dir>=7||x==M&&y==N&&mazexy==-1; //循环ifs->top==-1//若是入口;则无通路cout<<"此迷宫不通";else{elem.x=x; elem.y=y; elem.dir=dir;//将出口坐标入栈f=pushs;elem;cout<<"迷宫通路是："<<endl;i=0;while i <= s->top{cout<<""<<s->stacki.x<<";"<<s->stacki.y<<"";//显示迷宫通路ifi=s->topcout<<"-->";ifi+1%4==0cout<<endl;i++;}}}/////////////////////////////////////////////////////////////// ///////////////void drawint mazeN2;sqstktp s //在迷宫中绘制出通路{cout<<"逃逸路线为："<<endl;int i;j;elemtype elem;fori=1;i<=M;i++ //将迷宫中全部的-1值回复为0值{forj=1;j<=N;j++{ifmazeij==-1mazeij=0;whiles->top>-1 //根据栈中元素的坐标;将通路的各个点的值改为8{elem=pops;i=elem.x;j=elem.y;mazeij=8;}fori=1;i<=M;i++{forj=1;j<=N;j++{printf"%3d";mazeij; //显示已标记通路的迷宫}cout<<endl;}}}}void main //寻找迷宫通路程序{sqstktp s;int mazeM2N2;struct moved move8;inimazemaze; //初始化迷宫数组s=sqstktp mallocsizeofsqstktp;inistacks; //初始化栈inimovemove; //初始化方向位移数组pathmaze;move;s; //寻找迷宫通路cout<<endl;drawmaze;s; //绘制作出通路标记的迷宫}5.运行结果三求所有通路和最短路径的算法1.源代码用原题的数据include <stdio.h>define M 5 /行数/define N 7 /列数/define MaxSize 100 /栈最多元素个数/int mgM+1N+1={ /一个迷宫;其四周要加上均为1的外框/ {1;1;1;1;1;1;1;1};{1;0;0;1;0;0;0;1};{1;1;0;0;0;1;1;1};{1;0;0;1;0;0;0;1};{1;0;0;0;0;0;0;1};{1;1;1;1;1;1;1;1}};struct{int i;int j;int di;} StackMaxSize;PathMaxSize; /定义栈和存放最短路径的数组/ int top=-1; /栈指针/int count=1; /路径数计数/int minlen=MaxSize; /最短路径长度/void mgpath /路径为:1;1->M-2;N-2/{int i;j;di;find;k;top++; /进栈/Stacktop.i=1;Stacktop.j=1;Stacktop.di=-1;mg11=-1; /初始结点进栈/while top>-1 /栈不空时循环/{i=Stacktop.i;j=Stacktop.j;di=Stacktop.di;if i==M-2 && j==N-2 /找到了出口;输出路径/{printf"%4d: ";count++;for k=0;k<=top;k++{printf"%d;%d ";Stackk.i;Stackk.j;if k+1%5==0 printf"\n\t"; /输出时每5个结点换一行/ }printf"\n";if top+1<minlen /比较找最短路径/{for k=0;k<=top;k++Pathk=Stackk;minlen=top+1;}mgStacktop.iStacktop.j=0; /让该位置变为其他路径可走结点/top--;i=Stacktop.i;j=Stacktop.j;di=Stacktop.di;}find=0;while di<4 && find==0 /找下一个可走结点/{ di++;switchdi{case 0:i=Stacktop.i-1;j=Stacktop.j;break;case 1:i=Stacktop.i;j=Stacktop.j+1;break;case 2:i=Stacktop.i+1;j=Stacktop.j;break;case 3:i=Stacktop.i;j=Stacktop.j-1;break;}if mgij==0 find=1;}if find==1 /找到了下一个可走结点/{ Stacktop.di=di; /修改原栈顶元素的di值/top++;Stacktop.i=i;Stacktop.j=j;Stacktop.di=-1;/下一个可走结点进栈/mgij=-1; /避免重复走到该结点/}else /没有路径可走;则退栈/{mgStacktop.iStacktop.j=0; /让该位置变为其他路径可走结点/top--;}}printf"最短路径如下:\n";printf"长度: %d\n";minlen;printf"路径: ";for k=0;k<minlen;k++{printf"%d;%d ";Pathk.i;Pathk.j;if k+1%5==0 printf"\n\t"; /输出时每5个结点换一行/ }printf"\n";}void main{printf"迷宫所有路径如下:\n";mgpath;}2求解结果6.实验收获及思考这次试验总体来说还是比较简单的;因为几个思考问题都是在基本问题的源代码上进行改进和补充..有了第一次数据结构编程和测试的经验;这次试验减少了很多困难;相对来说容易多了..附录基本问题换代码思考问题源代码在上文中已经全部给出define M 4define N 6define MaxSize 100include <stdio.h>int mgM+2N+2={{1;1;1;1;1;1;1;1};{1;0;0;1;0;0;0;1};{1;1;0;0;0;1;1;1};{1;0;0;1;0;0;0;1};{1;0;0;0;0;0;0;1};{1;1;1;1;1;1;1;1}};int mgpathint xi;int yi;int xe;int ye //求解路径为:xi;yi->xe;ye {struct{int i; //当前方块的行号int j; //当前方块的列号int di; //di是下一可走方位的方位号} stMaxSize; //定义栈int top=-1; //初始化栈指针int i;j;k;di;find;top++; //初始方块进栈sttop.i=xi;sttop.j=yi;sttop.di=-1;mg11=-1;while top>-1 //栈不空时循环{i=sttop.i;j=sttop.j;di=sttop.di; //取栈顶方块if i==xe && j==ye //找到了出口;输出路径{printf"迷宫路径如下:\n";for k=0;k<=top;k++{printf"\t%d;%d";stk.i;stk.j;if k+1%5==0 //每输出每5个方块后换一行printf"\n";}printf"\n";return1; //找到一条路径后返回1}find=0;while di<4 && find==0 //找下一个可走方块{di++;switchdi{case 0:i=sttop.i-1;j=sttop.j;break;case 1:i=sttop.i;j=sttop.j+1;break;case 2:i=sttop.i+1;j=sttop.j;break;case 3:i=sttop.i;j=sttop.j-1;break;}if mgij==0 find=1;//找到下一个可走相邻方块}if find==1 //找到了下一个可走方块{sttop.di=di; //修改原栈顶元素的di值top++; //下一个可走方块进栈sttop.i=i;sttop.j=j;sttop.di=-1;mgij=-1; //避免重复走到该方块}else //没有路径可走;则退栈{mgsttop.isttop.j=0;//让该位置变为其他路径可走方块top--; //将该方块退栈}}return0; //表示没有可走路径;返回0}void main{mgpath1;1;M;N;}。
迷宫求解问题解答(C语言)
迷宫求解问题解答：#include<stdio.h>#include<stdlib.h>#include<stack>#include <iostream>#define STACK_INIT_SIZE 30000#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2using namespace std;typedef int Status;char maze[20][20];typedef struct{int r;int c;}PosType;typedef struct{PosType seat;int di;}SElemType;typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;SElemType e;Status Pass(PosType pos){if(maze[pos.r][pos.c]=='0')return OK;else return ERROR;}void FootPrint(PosType pos){maze[pos.r][pos.c]='*';}void MarkPrint(PosType pos){maze[pos.r][pos.c]='@';}PosType NextPos(PosType pos,int di){PosType dire[5]={{0,0},{0,1},{1,0},{0,-1},{-1,0}};pos.r+=dire[di].r;pos.c+=dire[di].c;return pos;}stack<SElemType> s;Status MazePath(PosType start, PosType end){PosType curpos=start;do{if(Pass(curpos)){FootPrint(curpos);e.seat=curpos;e.di=1;s.push(e);if((curpos.r==end.r)&&(curpos.c==end.c))return(TRUE);curpos=NextPos(curpos,1);}else{if(!s.empty()){e=s.top();s.pop();while((e.di==4)&&(!s.empty())){MarkPrint(e.seat);e=s.top();s.pop();}if(e.di<4){e.di++;s.push(e);curpos=NextPos(e.seat,e.di);}}}}while(!s.empty());return(FALSE);}int main(){int i,j,m,n,d;PosType start,end;FILE *fp=fopen("in.txt","r");fscanf(fp,"%d%d%d%d%d%d",&m,&n,&start.r,&start.c,&end.r,&end.c); for(i=1;i<=m;i++){for(j=1;j<=n;j++){fscanf(fp,"%d",&d);maze[i][j]=d+'0';}}fclose(fp);for(i=0;i<m+1;i++){maze[i][0]='1';maze[i][n+1]='1';}for(j=0;j<=n+1;j++){maze[0][j]='1';maze[m+1][j]='1';}for(i=0;i<=m+1;i++){for(j=0;j<=n+1;j++){if(j==n+1)printf("%c\n",maze[i][j]);else printf("%c ",maze[i][j]); }}printf("\n");MazePath(start,end);{for(i=0;i<=m+1;i++){for(j=0;j<=n+1;j++){if(maze[i][j]=='1')maze[i][j]='#';if(maze[i][j]=='0')maze[i][j]=' ';printf("%c",maze[i][j]);if(j<n+1)printf(" ");}printf("\n");}}return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
求迷宫问题就是求出从入口到出口的路径。
在求解时,通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前试探,若能走通,则继续往前走；否则沿原路退回,换一个方向再继续试探,直至所有可能的通路都试探完为止。
为了保证在任何位置上都能沿原路退回(称为回溯),需要用一个后进先出的栈来保存从入口到当前位置的路径。
首先用如图所示的方块图表示迷宫。
对于图中的每个方块,用空白表示通道,用阴影表示墙。
所求路径必须是简单路径,即在求得的路径上不能重复出现同一通道块。
为了表示迷宫,设置一个数组mg,其中每个元素表示一个方块的状态,为0时表示对应方块是通道,为1时表示对应方块为墙,如图所示的迷宫,对应的迷宫数组mg如下:
int mg[M+1][N+1]={ /*M=10,N=10*/
{1,1,1,1,1,1,1,1,1,1},
{1,0,0,1,0,0,0,1,0,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,0,0,1,1,0,0,1}, {1,0,1,1,1,0,0,0,0,1}, {1,0,0,0,1,0,0,0,0,1}, {1,0,1,0,0,0,1,0,0,1}, {1,0,1,1,1,0,1,1,0,1}, {1,1,0,0,0,0,0,0,0,1}, {1,1,1,1,1,1,1,1,1,1} }; 伪代码：
c语言描述如下：
void mgpath() /*路径为:(1,1)->(M-2,N-2)*/ {
int i,j,di,find,k;
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-2 && j==N-2) /*找到了出口,输出路径*/
{
printf("迷宫路径如下:\n");
for (k=0;k<=top;k++)
{
printf("\t(%d,%d)",Stack[k].i,Stack[ k].j);
if ((k+1)%5==0) printf("\n");
}
printf("\n");
return;
}
find=0;
while (di<4 && find==0) /*找下一个可走方块*/
{ di++;
switch(di)
{
case 0:i=Stack[top].i-1;
j=Stack[top].j ;
break;
case 1:i=Stack[top].i;
j=Stack[top].j +1;
break;
case 2:i=Stack[top].i+1;
j=Stack[top].j ;
break;
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;
mg[i][j]=-1; /*避免重复走到该方块*/ }
else /*没有路径可走,则退栈*/
{ mg[Stack[top].i][Stack[top].j]=0;
/*让该位置变为其他路径可走方块*/
top--;
}
}
printf("没有可走路径!\n");
}。