123迷宫(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语⾔递归实现迷宫寻路问题迷宫问题采⽤递归和⾮递归两种⽅法,暂时完成递归⽅法,后续会补上⾮递归⽅法#include<stdio.h>#include<stdbool.h>bool findPath(int a[][8],int i,int j){//递归找出⼝if(i==6&&j==6)//如果找到了⽬标a[6][6]则返回truereturn true;if(a[i][j]==0)//若当前路径未被找到,则继续{a[i][j]=2;//当前⾛的路径置为2,表⽰⾛过if(findPath(a,i+1,j)||findPath(a,i,j+1)||findPath(a,i-1, j)||findPath(a,i-1,j))//每个⽅向都判断,依次展开递归,寻找最佳路径return true;//若选择的路径可以⾛,则返回trueelse{//若当前选择的路径不能⾛a[i][j]=0;//弹栈并恢复路径,回退到上⼀次的位置return false;}}else//未能找到最终点return false;}void print(int a[][8])//打印当前的⼆维数组表{for(int i=0;i<8;i++){for(int j=0;j<8;j++){printf("%d ",a[i][j]);}printf("\n");}}int main(){int a[8][8]={0};for(int i=0;i<8;i++)//设置围墙和障碍物{a[0][i]=1;a[i][0]=1;a[7][i]=1;a[i][7]=1;}a[3][1]=1;a[3][2]=1;print(a);printf("-----------after find path-----------\n");findPath(a, 1, 1);print(a);}。
C语言实验:迷宫问题(搜索,C语言实现栈、队列)
C语⾔实验:迷宫问题(搜索,C语⾔实现栈、队列)Description给定迷宫起点和终点,寻找⼀条从起点到终点的路径。
(0,1)(2,0)起点(1,1)(1,2)(1,3)(1,4)(2,0)(2,1)(2,4)(3,0)(3,1)(3,2)终点(3,4)(4,1)上图中黄⾊代表墙,⽩⾊代表通路,起点为(1,1),终点为(3,4)。
要求搜寻策略是从起点开始按照“上、下、左、右”四个⽅向寻找终点,到下⼀个点继续按照“上、下、左、右”四个⽅⾯寻找,当该结点四个⽅向都搜寻完,但还没到终点时,退回到上⼀个点,直到找到终点或者没有路径。
⽐如上图从(1,1)开始,向上(0,1)不通,向下到(2,1);到了(2,1)后继续按“上、下、左、右”四个⽅⾯寻找,上已经⾛过,向下到(3,1);到(3,1)后上已经⾛过,下和左不通,向右到(3,2);到(3,2)四个⽅⾯都不通,回到(3,1)四个⽅向都不通,再回到(2,1),(1,1);到达(1,1)后下已经⾛过,左不通,继续向右⾛,重复这个过程最后到达(3,4)。
Input第⼀⾏两个数m和n表⽰迷宫的⾏数和列数。
迷宫⼤⼩不超过100×100第⼆⾏四个数x1,y1,x2,y2分别表⽰起点和终点的坐标。
接下来是m⾏n列的数,⽤来表⽰迷宫,1表⽰墙,0表⽰通路。
Output从起点到终点所经过的路径的坐标。
如果不存在这样的路径则输出“No Path!”。
Sample Input5 61 1 3 41 1 1 1 1 11 0 0 0 0 11 0 1 1 0 11 0 0 1 0 11 1 1 1 1 1Sample Output(1 1)(1 2)(1 3)(1 4)(2 4)(3 4)1.思路:(1)若当前点是终点,dfs函数返回1;(2)若不是终点,将此点标记为1,对该点4个⽅向进⾏搜索,实现⽅式为定义int dir[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} }; 通过⼀个⼩循环: for(int i = 0; i < 4; i++) { position nextp; nextp.x = dir[i][0] + now.x;nextp.y = dir[i][1] + now.y;...... } 进⾏搜索;若该点的下⼀个点nextp不是墙,未⾛,并且没有超界则将nextp压⼊栈中,递归调⽤dfs,若此过程经过(1)判断返回了1,说明最终找到了通往终点的路,便可以返回1,结束函数,此时栈中已储存了通往终点的路径,若没有通路,则弹出栈顶元素,根据递归原理该路径上的所有点都会弹出并标记未⾛,回溯到之前的点,继续向其他⽅向搜索,直到找到终点或遍历完整个图。
c语言随机生成迷宫算法
c语言随机生成迷宫算法迷宫是一种很有趣的游戏,它可以让人们在寻找出路的过程中培养思考能力和耐心。
在许多计算机游戏中,迷宫也是一个常见的题材。
那么,如何用C语言自动生成一个迷宫呢?下面就来详细介绍一下。
第一步,确定迷宫大小首先要确定迷宫的大小,也就是行和列的数量。
这可以通过用户输入来实现,也可以直接在程序中定义。
第二步,初始化迷宫在程序中,我们通常用一个二维数组来表示迷宫,数组元素的值表示对应的格子状态,0表示可通过,1表示不可通过。
因此,我们需要在程序中初始化迷宫,将所有的格子都标记为1,表示不可通过。
第三步,生成迷宫路径接下来,我们需要随机生成一个迷宫路径。
随机生成迷宫路径的方法有很多种,这里介绍一种比较简单的方法:深度优先搜索算法。
深度优先搜索算法是一种递归算法,可以从迷宫的起点开始,不断随机选择一个方向,往前走,直到无法再往前为止。
然后回到上一次的分支点,选择另一个方向继续走,直到整个迷宫路径都被探索完毕。
在探索的过程中,我们可以将经过的格子标记为0,表示可通过,同时记录路径上的所有分支点,方便后面生成迷宫时打通墙壁。
第四步,随机挖墙迷宫路径已经生成完毕,接下来我们需要随机挖墙,打通路径上的墙壁,让迷宫变成一张连接所有路径的图。
随机挖墙的方法也有很多种,这里介绍一种比较常见的方法:挖掉一些分支点周围的墙壁。
具体实现方法是选择一个随机的分支点,然后随机选择一个方向,检查该方向上的格子是否为墙壁,如果是墙壁,就把它打通,同时把该格子标记为已经访问过,以免重复挖掘。
然后继续在周围的格子中挑选下一个候选点,重复上述操作,直到所有的分支点周围的墙壁都被打通。
第五步,输出迷宫迷宫已经生成完毕,最后就是将其输出到屏幕上。
输出迷宫的方法也有很多种,这里介绍一种比较简单的方法:使用ASCII码字符表示迷宫。
具体实现方法是将生成的迷宫数组中的0标记为ASCII码字符' '(空格),将1标记为ASCII码字符'#'(井号),然后按照行列的顺序输出到屏幕上即可。
求解迷宫问题 (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语言写出的迷宫闯关游戏代码
{1,0,1,0,0,0,0,1,0,1,1,1,1,0,0,0,1,0,1,1},
{1,0,1,0,1,1,1,1,0,0,0,0,0,0,1,0,0,0,0,1},
{1,0,1,0,0,0,0,1,0,1,1,1,1,1,0,1,1,1,0,1},
{1,0,1,0,1,1,1,1,0,1,1,0,1,1,0,1,0,0,0,1},
{1,0,0,0,1,0,1,0,0,0,0,0,0,1,0,1,1,1,0,1},
{1,0,1,1,1,0,0,1,0,1,1,1,0,1,0,1,0,0,0,1},
{1,0,0,0,0,0,1,1,0,0,0,0,0,1,0,0,0,1,0,1},
{1,1,0,0,0,1,0,1,0,1,1,1,1,1,1,0,1,1,0,1},
{1,0,0,1,1,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1},
{1,1,0,0,0,1,0,1,0,1,0,1,0,1,1,1,1,0,1,1},
{1,1,1,1,0,1,0,1,1,1,0,1,0,0,0,0,1,0,1,1},
{1,1,1,1,1,1,1,0,1,1,1,1,0,0,0,0,1,1,0,1},
{1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,1,1,0,1},
{1,1,1,0,1,0,1,1,1,1,0,0,0,1,0,0,0,0,0,1},
{1,0,1,0,1,1,1,0,1,0,0,1,0,1,0,1,0,1,0,1},
{1,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,1,0,0,1},
{1,0,1,0,1,1,1,0,1,0,1,0,1,0,1,0,1,1,0,1},
迷宫游戏C语言代码讲解
而其参数nStdHandle的值可以为下面几种类型的一种:STD_INPUT_HANDLE标准输入的句柄STD_OUTPUT_HANDLE标准输出的句柄STD_ERROR_HANDLE标准错误的句柄
void game() //游戏相关操作
先不要管main函数里的代码,我们先逐个分析一下函数
先来看看gotoxy()接受两个参数,代码如下
void gotoxy(int x,int y) //移动坐标
{
COORD coord;
coord.X=x;
coord.Y=y;
SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord );
if(c==Esc)
{
gotoxy(0,24);
5
回复
1楼
2011-12-07 15:46
举报|
我也说一句
未来未来
追忆曾经_
团子家族
10
break;
}
switch(c)
{
case Up: //向上走
if(map[x-1][y]!=Wall)
{
paint(x,y);
x--;
}
break;
case Down: //向下走
map[i][Width+1]=Wall;
}
for(j=0;j<=Width+1;j++) //边界处理
{
map[0][j]=Wall;
c语言迷宫问题代码实现
structStackList
{
SEAT stack[MAXSIZE];
inttop;
}*Stack;
intEmptyStack(StackList*Stack)//判断是否为空栈
{
if(Stack->top==0)
return 0;
else
return 1;
}
intMove[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//分别表示向东、西、南、北需要加上的坐标
CurSeat=temp;
find =1;
}
}
}
}
}while(EmptyStack(Stack));
return false;
}
voidPrintStack(StackList*Stack)//输出路线
{
if(Stack->top==0)
printf("There is no route can be out of the maze\n");
Mark(CurSeat);
if(CurSeat.x==end.x+1&&CurSeat.y==end.y+1)//如果找到出口,返回
{
return true;
}
else
{
intfind=0;
while(CurSeat.di<3&&find==0)//找下一个结点的方向
{
CurSeat.di++;
SEAT temp;
scanf("%d",&n);
printf("Please enter the labyrinth of the coordinates of the wall unit(0<=row,column):\n");
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;
c语言随机生成迷宫算法
c语言随机生成迷宫算法
c语言随机生成迷宫算法是一种常用的算法,用于生成迷宫结构。
该算法的核心思想是通过随机生成迷宫中的墙壁和通路,来创建一个具有迷宫结构的随机图。
具体实现过程可以分为以下几个步骤:
1.初始化迷宫矩阵:创建一个二维数组,用于表示迷宫的结构。
将数组中所有元素初始化为墙壁。
2.随机选取起点:从迷宫中随机选取一个起点。
3.随机生成迷宫结构:从当前位置开始,随机选择一个方向并移动,如果该方向上的位置未被访问过,则将当前位置与该位置之间的墙壁打通,并将该位置标记为已访问。
如果该方向上的位置已被访问,则不进行操作,直接选择下一个方向。
4.生成终点:在生成迷宫结构的过程中,可以随机选择某些位置作为终点。
当达到终点时,迷宫生成结束。
5.输出迷宫结构:将迷宫矩阵输出到控制台或文件中,以便用户查看。
c语言随机生成迷宫算法可以用于游戏开发、路径规划等领域。
其优点是生成的迷宫结构随机性高,具有挑战性,而且可以根据需求进行调整。
缺点是算法复杂度较高,需要耗费大量时间和计算资源。
- 1 -。
123使用C语言解决迷宫问题
目录前言 (3)1什么是数据结构 (3)2学习数据结构有什么用 (3)一问题定义 (4)二可行性研究 (4)2.1迷宫问题处理系统的基本系统模型 (4)2.2迷宫问题处理系统的功能级数据流图 (4)三需求分析 (5)四总体设计 (5)4.1数据结构设计考虑 (5)4.2逻辑结构存储结构 (5)4.2程序流程图 (6)五详细设计 (7)六编码 (9)七运行结果 (15)7.1无路径情况 (15)7.2有路径情况 (15)总结 (16)参考文献 (16)前言1 什么是数据结构?数据结构是计算机存储、组织数据的方式。
数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
数据结构在计算机科学界至今没有标准的定义。
各个大家根据自己的理解,都有不同的表述方式(如:Lobert L.Kruse在《数据结构与程序设计》一书中,将一个数据结构的设计过程分成抽象层、数据结构层和实现层。
其中,抽象层是指抽象数据类型层,它讨论数据的逻辑结构及其运算,数据结构层和实现层讨论一个数据结构的表示和在计算机内的存储细节以及运算的实现。
)。
数据结构具体指同一类数据元素中,个元素之间的相互关系,包括三个组成成分,数据的逻辑结构,数据的存储结构和数据运算结构。
2 学习数据结构有什么用?有很多同学都认为学习数据结构没有多大用处,下面是作者在网上的一些疑问。
同学甲:我学数据结构觉得它类似与高中时的数学,很难!但是没用……好像就专门来考验一个人逻辑思维用的,为了要在同学间获得很聪明的虚荣,拼命的研究,从来也没有思考过到底它有什么用处。
同学乙:老师总是对我们说想要在IT行业中有所成就就必须学好数据结构,但是我们现在学的这些什么栈、数组、图、树之类的东西,好像和我们编程没有什么联系。
现在我们先来说说学习数据结构的意义数据结构是计算机科学与技术专业、计算机信息管理与应用专业,电子商务等专业的基础课,是十分重要的核心课程。
所有的计算机系统软件和应用软件都要用到各种类型的数据结构。
迷宫(direction)C语言代码
};
mazePath(maze,direction,1,1,6,9);
getchar();
return 0;
}
#include<stdio.h>
#include<conio.h>
intmigong[10][10]= //设置迷宫,最外围1为墙 里边0为可走路径 1为障碍
voidpush_seq(PSeqStackpastack,DataTypex ) {
if(pastack->t >= MAXNUM - 1 )
printf( "Overflow! \n" );
else {
pastack->t++;
pastack->s[pastack->t] = x;
}
}
/* 删除栈顶元素 */
element =top_seq(st);
pop_seq(st);
i=element.x; j =element.y;
for (k =element.d+ 1; k <= 3; k++) { /* 依次试探每个方向 */
g =i+ direction[k][0];h = j + direction[k][1];
lj[top].x=1;
lj[top].y=1;
migong[1][1]=-1;
find=0;d=-1;
while(top>-1){
if(lj[top].x==8&&lj[top].y==8)
{
printf("迷宫路径如下:\n");
c语言版 迷宫 完整版代码
line(500,200,450,250);
outtextxy(445,270,"z");
line(500,200,550,250);
case 7: (*y)--;break; /*左*/
case 8: (*x)--;(*y)--;break; /*左上*/ }
setfillstyle(SOLID_FILL,RED);/*新位置显示探索物*/
bar(100+(*y)*15-6,50+(*x)*15-6,100+(*y)*15+6,50+(*x)*15+6); }
else if(c=='x'&&map[x+1][y]!=1) DrawPeople(&x,&y,5);/*下*/
else if(c=='z'&&map[x+1][y-1]!=1) DrawPeople(&x,&y,6); /*左下*/
WayCopy(oldmap,map);
if(oldmap[i+1][j]==0&&!yes)/*判断下方是否可以走,如果标志yes已经是1也不用找下去了*/
{ FindWay(oldmap,i+1,j);
{ FindWay(oldmap,i,j+1);
if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }
WayCopy(oldmap,map);
#include <graphics.h>
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语⾔实现⾛迷宫的具体代码,供⼤家参考,具体内容如下描述给⼀张个迷宫,问能否从起点⾛到终点,只能往上下左右⾛,不能斜着⾛输⼊多组测试数据,每组第⼀⾏两个正整数,分别为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语言版)--数据结构课程设计
一.迷宫问题求解1.问题描述迷宫问题是实验心理学的一个经典问题,心理学家把一只老鼠从一个无顶盖的大盒子的入口出赶迷宫。
迷宫中设置了很多隔壁,对前进方向形成了多出障碍,心理学家在迷宫的唯一出口处放置了一块奶酪,吸引老鼠在迷宫中寻找路径以到达出口。
然而,用计机模拟迷宫问题,即划好迷宫的隔壁的设置,让计算机从入口处进入迷宫探究出一条通路。
2.设计思路回溯法是一种不断试探且及时纠正错误的探索方法。
下面的求解过程既是使用回溯法。
从入口出发,按某一个方向向前探索,若能走通并且未走过,即某处可以到达,则到达新点,否则试探下一个方向;若所有的方向均没有通路,则沿原路返回前一个点,换下一个方向继续探索,直到找到一条通路,或无路可走又返回到入口点。
在求解过程中,为了保证在到达某一点后不能向前继续行走(无路)时,能正确返回前一个点以便继续从下一个方向向前试探,则需要用一个栈保存所有到达点的下标。
另外,求解该问题的一个重要问题是如何防止回溯时走重复节点,以避免发生死循环。
这里,我们采用对走过的结点,修改其结点信息。
如在设计之初,我们设置保存迷宫结构的二维数组中0值代表该节点可走,1值代表其不可走,那么我们可以把走过的结点值改为非0,已使其不能被再次探索。
3.数据结构设计由上面的设计思路知,若想正确的使用回溯法求解迷宫问题,必须要借助一个栈以保存走过的结点信息。
而这里我活用了栈,只把其数据结构抽象为了一个结构体数组,具体设计如下:typedef struct{}pos;pos Pos[100]; /*结构体数组以保存走过的结点信息*/4.功能函数介绍(1)判断是否找到出口函数Isover();该函数的参数是当前结点的x、y坐标与出口结点的x、y坐标,通过比较其值来判断是否找到出口结点,从而控制程序结束。
(2)对程序相关信息的简单介绍函数introduce();该函数主要是在进行绘制迷宫的图形化界面之前开发者搞的一点小插曲,以介绍跟该程序的相关的部分信息。
(完整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");。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#include<stdio.h>#include<stdlib.h>#include<time.h>#define stack_init_size 200#define stack_increment 10#define OVERFLOW 0#define OK 1#define ERROE 0#define TRUE 1#define FALSE 0typedef 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.base =(SElemType *)malloc(stack_init_size *sizeof(SElemType));if(!s.base) return OVERFLOW;s.top=s.base;s.stacksize=stack_init_size;return OK;}//当前块可否通过Status Pass(PosType e){if (mg[e.x][e.y]==0) //0时可以通过return OK; // 如果当前位置是可以通过,返回1return OVERFLOW; // 其它情况返回0}//留下通过的足迹Status FootPrint(PosType e){mg[e.x][e.y]=7;return OK;}//压入栈Status Push(SqStack &s,SElemType e){if(s.top-s.base>=s.stacksize){s.base=(SElemType *)realloc(s.base,(s.stacksize+stack_increment) *sizeof(SElemType));if(!s.base)exit(OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=stack_increment;}*s.top++=e;return OK;}//出栈Status Pop(SqStack &s,SElemType &e){ if(s.top==s.base)return ERROE;e=*--s.top;return OK;}//下一步PosType NextPos(PosType &e,int dir){ PosType E;switch(dir){case 1:E.x=e.x; //向下E.y=e.y+1;break;case 2:E.x=e.x+1; //向右E.y=e.y;break;case 3:E.x=e.x; //向上E.y=e.y-1;break;case 4:E.x=e.x-1; //向左E.y=e.y;break;}return E;}//是否空栈Status StackEmpty(SqStack s){if (s.top==s.base)return OK;return OVERFLOW;}//留下不能通过的足迹Status MarkPrint(PosType e){mg[e.x][e.y]=3;return OK;}//迷宫函数// 若迷宫maze中从入口start到出口end的通道,则求得一条存放在栈中// (从栈底到栈顶),并返回TRUE;否则返回FALSEStatus MazePath(int mg,PosType start,PosType end,SqStack &s){PosType curpos;InitStack(s);SElemType e;int curstep;curpos=start; // 设定"当前位置"为"入口位置"curstep=1; // 探索第一步do{if(Pass(curpos)){// 当前位置可通过,即是未曾走到过的通道块FootPrint(curpos); // 留下足迹e.di =1;e.ord = curstep;e.seat= curpos;Push(s,e); // 加入路径if(curpos.x==end.x&&curpos.y==end.y){printf("\n\n0∩_∩0 能到达终点!");return TRUE;}curpos=NextPos(curpos,1); // 下一位置是当前位置的东邻curstep++; // 探索下一步}else{// 当前位置不能通过if(!StackEmpty(s)){Pop(s,e);while(e.di==4&&!StackEmpty(s)){MarkPrint(e.seat);Pop(s,e);}if(e.di<4){e.di++;Push(s,e); // 留下不能通过的标记,并退回一步curpos=NextPos(e.seat,e.di); /* 当前位置设为新方向的相邻块*/}//if}//if}//else}while(!StackEmpty(s));printf("\n\n囧! 不能到达终点!");return FALSE;}//打印迷宫void PrintMaze(){int i,j;printf("运行路径:\n\n");for(i=0;i<20;i++){for(j=0;j<20;j++){if(mg[i][j]==0)printf(" ");else if(mg[i][j]==1) printf("■"); //迷宫的“墙”else if(mg[i][j]==3) printf("◇"); //不通的路else if(mg[i][j]==7)printf("○"); //通过的路径}printf("\n");}printf("\n");}void main(){SqStack S;PosType start,end;start.x=1;start.y=0; //起点坐标end.x=18;end.y=19; //终点坐标printf("\n==================迷宫游戏==================");printf("\n说明:■不能走的区域\t◇走不通的区域");printf("\n “空格”代表未到过的区域");printf("\n ○代表能通过的路径,指向终点");printf("\n============================================");Random();printf("\n\nTest 1:");MazePath(mg[20][20],start,end,S);PrintMaze();system("pause");Random();printf("\nTest 2:");MazePath(mg[20][20],start,end,S);PrintMaze();system("pause");Random();printf("\nTest 3:");MazePath(mg[20][20],start,end,S);PrintMaze();printf("\n==========程序退出,感谢使用!==========\n");}。