求解迷宫问题 (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语言,很详细哦)

求迷宫问题就是求出从入口到出口的路径。
在求解时,通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前试探,若能走通,则继续往前走;否则沿原路退回,换一个方向再继续试探,直至所有可能的通路都试探完为止。
为了保证在任何位置上都能沿原路退回(称为回溯),需要用一个后进先出的栈来保存从入口到当前位置的路径。
首先用如图所示的方块图表示迷宫。
对于图中的每个方块,用空白表示通道,用阴影表示墙。
所求路径必须是简单路径,即在求得的路径上不能重复出现同一通道块。
为了表示迷宫,设置一个数组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");}。
用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语言解决迷宫求解问题

迷宫求解
任务:
可以输入一个任意大小的迷宫数据,用非递归的方法求出一条走出迷宫的路
径,并将路径输出。
#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语言)

迷宫问题【问题描述】以一个m*n的长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍。
设计一个程序,对任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。
【基本要求】首先实现一个以链表作存储结构的栈类型,然后编写一个求解迷宫的非递归程序。
求得的通路以三元组(i,j,d)的形式输出,其中(i,j)指示迷宫中的一个坐标,d表示走到下一坐标的方向。
如:对于下列教据的迷宫,输出的一条通路为:(1,1,1 ),(l , 2,2),(2,2,2),(3 ,2,3),(3 ,l,2),…。
【测试数据】迷宫的测试数据如下:左上角(l,l)为入口.右下角(8, 9)为出口。
【实现提示】计算机解迷宫通常用的是“穷举求解”方法,即从入口出发,顺着某一个方向进行探索,若能走通,则继续往前进;否则沿着原路退回,换一个方向继续探索,直至出口位置,求得一条通路。
假如所有可能的通路都探索到而未能到达出口,则所设定的迷宫没有通路。
可以二维数组存储迷宫数据,通常设定入口点的下标为(1,1),出口点的下标为(n,n)。
为处理方便起见,可在迷宫的四周加一圈障碍。
对于迷宫中任一位置,均可约定有东、南、西、北(编号分别为1,2,3,4)四个方向可通。
#include <stdio.h>#include <stdlib.h>#define stackinitsize 200#define stackincrement 10typedef struct{int x;int y;}locat;typedef struct{locat seat;int direct;}SET;typedef struct{SET *base;SET *top;int stacksize;}stack;int mg[11][10];void initstack(stack &s){s.base=(SET *)malloc(stackinitsize*sizeof(SET));if(!s.base) exit(0);s.top=s.base;s.stacksize=stackinitsize;}int empty(stack s){if(s.base==s.top) return 1;else return 0;}int pass(locat e){if(mg[e.x][e.y]==0) return 1;else return 0;}void printpass(locat e){mg[e.x][e.y]=7;}void push(stack &s,SET e){if(s.top-s.base>=s.stacksize){s.base=(SET *)realloc(s.base,(stackinitsize+stackincrement)*sizeof(SET));if(!s.base) exit(0);s.top=s.base+s.stacksize;s.stacksize+=stackincrement;}*s.top=e;s.top++;}locat next(locat e,int n){locat E;switch(n){case 2:E.x=e.x+1; E.y=e.y; break;case 1:E.x=e.x; E.y=e.y+1; break;case 4:E.x=e.x-1; E.y=e.y; break;case 3:E.x=e.x; E.y=e.y-1; break;}return E;}int down(stack &s,SET &e){if(s.base==s.top)return 0;else{s.top--;e=*s.top;return 1;}}void printunpass(locat e){mg[e.x][e.y]=3;}int maze(){stack s;initstack(s);locat curpos,start,end;start.x=1; start.y=1;end.x=9; end.y=8;SET e;curpos=start;do{if(pass(curpos)){printpass(curpos);e.seat=curpos;e.direct=1;push(s,e);if(curpos.x==end.x&&curpos.y==end.y)return 0;curpos=next(e.seat,e.direct);}else{if(!empty(s)){down(s,e);while(e.direct==4&&!empty(s)){printunpass(e.seat);down(s,e);}}if(e.direct<4){e.direct++;push(s,e);curpos=next(e.seat,e.direct);}}}while(!empty(s));printf("No Way!!\n");return 0;}void print(){int i,j;printf("***************************************\n");for(i=0;i<11;i++){for(j=0;j<10;j++){switch(mg[i][j]){case 0:printf(" "); break;case 1:printf("■"); break;case 3:printf("◇"); break;case 7:printf("O "); break;}}printf("\n");}}int main(){FILE *fp;if((fp=fopen("abcd.txt","r"))==NULL)return 0;int i,j;for(i=0;i<11;i++){for(j=0;j<10;j++){fscanf(fp,"%d",&mg[i][j]);}}maze();print();}。
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;}第⼆种⽅法⼴度优先搜索:这⼀步之后,把接下来⼀步的所有路都列出来,在之后的所有扩展之中,在以⼀个为下⼀步,再将所有的该步可以到达的下⼀步,全部列举出来,再将第⼆步的其他选择中的每⼀步,都⼀⼀做扩展,每次扩展,都要检查所扩展的地⽅有没有到达搜索的要求。
应用栈解决迷宫问题的C语言实现

应⽤栈解决迷宫问题的C语⾔实现题⽬来⾃于严蔚敏《数据结构》,参考伪代码实现的程序:1 #include <stdio.h>2 #include <malloc.h>3//记录通道块在迷宫矩阵当中的横、纵坐标4struct Position{5int x;6int y;7 };8//放⼊栈当中的通道块元素9struct SElement {10int ord;//记录此通道块在整个通道当中的次序11 Position p;//记录此通道块在矩阵当中的位置12int di;//记录下⼀次测试这⼀路径的临近路径的位置13 };14//创建栈数据结构15#define STACK_INIT_SIZE 10016#define STACKINCREMENT 1017struct MyStack{18 SElement* base;19 SElement* top;20int stacksize;21 };22//创建⼀个栈如果创建成功则返回1,否则就返回023int InitStack(MyStack* s)24 {25 s->base=(SElement*)malloc(STACK_INIT_SIZE*sizeof(SElement));//为栈分配初始空间26if(!s->base) return0;27 s->top=s->base;//设定为空栈28 s->stacksize=STACK_INIT_SIZE;29return1;30 }31//判断栈是否为空,如果是空的就返回0,否则就返回132int IsStackEmpty(MyStack* s)33 {34if(s->top==s->base) return true;35return false;36 }37//获取栈顶元素,如果栈为空就返回0 否则就返回138int GetTop(MyStack* s,SElement* e)39 {40if(IsStackEmpty(s)) return0;41 e=s->top-1;42return1;43 }44//获取栈的长度,并且通过程序返回45int StackLength(MyStack* s)46 {47return s->top-s->base;48 }49//插⼊元素e为新的栈顶元素,插⼊成功则返回1,否则返回050int Push(MyStack* s,SElement e)51 {52if(s->top-s->base>=STACK_INIT_SIZE)53 {54 s->base=(SElement*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(SElement));55if(!s->base) return0;56 s->top=s->base+s->stacksize;57 s->stacksize+=STACKINCREMENT;58 }59 *(s->top)=e;60 s->top++;61return1;62 }63//弹出栈顶元素赋值给e弹出成功返回1,弹出失败返回064int Pop(MyStack* s,SElement* e)65 {66if(IsStackEmpty(s)) return0;67 *e=*(s->top-1);68 s->top--;69return1;70 }71//定义墙元素为2 可⾛路径为0 已知路径为curStep 不能够通过的路径为-172#define MazeScale 1073int Maze[MazeScale][MazeScale]={{2,2,2,2,2,2,2,2,2,2},{2,0,0,2,0,0,0,2,0,2},{2,0,0,2,0,0,0,2,0,2},{2,0,0,0,0,2,2,0,0,2},74 {2,0,2,2,2,0,0,0,0,2},{2,0,0,0,2,0,0,0,0,2},{2,0,2,0,0,0,2,0,0,2},{2,0,2,2,2,0,2,2,0,2},{2,2,0,0,0,0,0,0,0,2},{2,2,2,2,2,2,2,2,2,2}}; 75//辅助函数考察当前路径能否通过76bool Pass(Position posi)77 {78//只有路径所在位置的数字为0的是可以⾛的79if(Maze[posi.x][posi.y]==0)80 {81return true;82 }83return false;84 }85//按顺时针⽅向从东开始寻找矩阵当中某⼀个位置的临近位置86 Position NextPosition(Position now,int direction)87 {88 Position next;89int x=now.x;90int y=now.y;91switch(direction)92 {93//东94case1:{95 next.x=x;96 next.y=y+1;97break;98 }99//南100case2:{101 next.x=x+1;102 next.y=y;103break;104 }105//西106case3:{107 next.x=x;108 next.y=y-1;109break;110 }111//北112case4:113 {114 next.x=x-1;115 next.y=y;116break;117 }118default:break;119 }120return next;121 }122//留下⾜迹123void FootPrint(Position p,int step)124 {125 Maze[p.x][p.y]=step;126 }127//路径不可⾛的话就留下-1的标记128void MarkPrint(Position p)129 {130 Maze[p.x][p.y]=-1;131 }132int main()133 {134//打印出迷宫矩阵135for(int i=0;i<MazeScale;i++)136 {137for(int j=0;j<MazeScale;j++)138 {139 printf("%d ",Maze[i][j]);140 }141 printf("\n");142 }143//迷宫程序主体144 MyStack path;//记录路径的栈145 InitStack(&path);//初始化路径数组146 Position curp;//当前被试位置147//初始化当前位置为矩阵⼊⼝148 curp.x=1;149 curp.y=1;150int curStep=1;//被探索的步数151do152 {153if(Pass(curp))154 {155 FootPrint(curp,curStep);//可⾛就在迷宫⾥⾯留下⾜迹156//创建⼀个栈元素,存储可⾏路径的相关值,将这个元素存储到栈当中157 SElement e;158 e.di=1;//意味着下⼀个被试路块为这⼀个路块的正上⽅的路块159 e.ord=curStep;160 e.p.x=curp.x;161 e.p.y=curp.y;162 Push(&path,e);//将路径块⼊栈163if(curp.x==MazeScale-2 && curp.y==MazeScale-2) break; //如果被压⼊的路径块到了迷宫的终点就退出循环164//找到下⼀个被试块165 curp=NextPosition(curp,1);//找到前⼀个被试块东⾯的路径块作为被试块166 curStep++;//被探索的步数加⼀167 }else//如果当前被试路径不能够通过的话168 {169if(!IsStackEmpty(&path))170 {171 SElement e;172 Pop(&path,&e);173 curStep--;174//将这⼀段所有的周围路径都已经被测试过的路径从栈中清除175while(e.di==4 && !IsStackEmpty(&path)){176 MarkPrint(e.p);177 Pop(&path,&e);178 curStep--;179 }180//如果当前栈顶还有未被测试的路径就测试剩余的周围路径181if(e.di<4)182 {183 curp=NextPosition(e.p,e.di+1);184 e.di++;185 curStep++;186 Push(&path,e);187 }188 }189 }190 }while(!IsStackEmpty(&path));191 printf("\n");192//打印出结果迷宫矩阵193for(int i=0;i<MazeScale;i++)194 {195for(int j=0;j<MazeScale;j++)196 {197 printf("%d ",Maze[i][j]);198 }199 printf("\n");200 }201return0;202 }。
(完整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语言版

#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define STACK_INIT_SIZE 100 #define STACKINCREMENT 10typedef struct{int r;int c;}PosType;//通道块坐标typedef struct {int ord;//通道块在路径上的序号PosType seat;//通道块的坐标位置int di;//下一个探索的方向}SelemType;typedef struct {int r;int c;char adr[10][10];}MazeType;//迷宫行列,内容typedef struct {SelemType * base;SelemType * top;int stacksize;}SqStack;void InitStack(SqStack &S){S.base=(SelemType*)malloc(STACK_INIT_SIZE * sizeof(SelemType));if(!S.base) exit(0);S.top=S.base;S.stacksize=STACK_INIT_SIZE;}void Push(SqStack &S,SelemType &e){if((S.top-S.base)>=S.stacksize){S.base=(SelemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)* sizeof(SelemType));if(!S.base) exit(0);S.top=S.base+S.stacksize;//溢出重新定位S.stacksize+=STACKINCREMENT;}*S.top++=e;}void Pop(SqStack &S,SelemType &e){if(S.top==S.base) return;e=*--S.top;}void InitMaze(MazeType &maze){int i,j;maze.r=8;maze.c=8;for(i=0;i<10;i++){maze.adr[0][i]='#';maze.adr[9][i]='#';}for(i=0;i<10;i++){maze.adr[i][0]='#';maze.adr[i][9]='#';}for(i=1;i<9;i++)for(j=1;j<9;j++)maze.adr[i][j]='1';maze.adr[1][3]='#'; maze.adr[1][7]='#';maze.adr[2][3]='#'; maze.adr[2][7]='#';maze.adr[3][5]='#'; maze.adr[3][6]='#';maze.adr[4][2]='#'; maze.adr[4][3]='#';maze.adr[4][4]='#';maze.adr[5][4]='#';maze.adr[6][2]='#'; maze.adr[6][6]='#';maze.adr[7][2]='#'; maze.adr[7][3]='#'; maze.adr[7][4]='#'; maze.adr[7][6]='#';maze.adr[7][7]='#';maze.adr[8][1]='#';}int Pass(MazeType &maze,PosType &curpos){if(maze.adr[curpos.r][curpos.c]=='1')return 1;elsereturn 0;}void FootPrint(MazeType &maze,PosType curpos){maze.adr[curpos.r][curpos.c]='*';//已经走过的标记}PosType NextPos(PosType curpos,int i){PosType nextpos;nextpos=curpos;switch(i){case 1:nextpos.c+=1;break;case 2:nextpos.r+=1;break;case 3:nextpos.c-=1;break;case 4:nextpos.r-=1;break;default:printf("探寻方向错误!");}return nextpos;}void MarkPrint(MazeType &maze,PosType curpos){maze.adr[curpos.r][curpos.c]='@';//不通的标识}int StackEmpty(SqStack &S){if(S.base==S.top)return 1;elsereturn 0;}void MazePath(MazeType &maze,PosType start,PosType end) {SelemType e;SqStack S;InitStack(S);PosType curpos;int curstep;curpos=start;curstep=1;do{if(Pass(maze,curpos)){FootPrint(maze,curpos);//留下走过足迹*e.ord=curstep;e.seat=curpos;e.di=1;Push(S,e);//压入栈路径if(curpos.r==end.r&&curpos.c==end.c) return;curpos=NextPos(curpos,1);//探索下一步curstep++;}//ifelse{//当前位置不能通过if(!StackEmpty(S)){Pop(S,e);//top指针退后一下,指向上一步while(e.di==4&&!StackEmpty(S)){MarkPrint(maze,e.seat);//如果此步上下左右都探索过了且栈不为空留下不通过且返回一步Pop(S,e);}//while,用while是可以连续返回if(e.di<4){e.di++;Push(S,e);//换下一个方向探索curpos=NextPos(e.seat,e.di);//探索下一位置块}//if}//if}//else}while(!StackEmpty(S));}//mazepathvoid PrintMaze(MazeType &maze){int i,j;for(i=0;i<10;i++)printf("%4d",i);//输出行printf("\n\n");for(i=0;i<10;i++){printf("%2d",i);//输出列for(j=0;j<10;j++)printf("%4c",maze.adr[i][j]);printf("\n\n");}}void main(){MazeType maze;PosType start,end;InitMaze(maze);start.r=1; start.c=1;end.r=8; end.c=8;PrintMaze(maze);MazePath(maze,start,end);PrintMaze(maze);}。
迷宫求解问题解答(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)。
求迷宫问题就是求出从入口到出口的路径。
在求解时,通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前试探,若能走通,则继续往前走;否则沿原路退回,换一个方向再继续试探,直至所有可能的通路都试探完为止。
为了保证在任何位置上都能沿原路退回(称为回溯),需要用一个后进先出的栈来保存从入口到当前位置的路径。
首先用如图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,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");
}。