数据结构-走迷宫游戏代码

合集下载

数据结构迷宫问题源代码

数据结构迷宫问题源代码

数据结构迷宫问题源代码#include<stdio.h> #include<malloc.h>#include<stdlib.h>#include <conio.h>#include"typedef.h"#include "ADTStack.h"#include"maze.h"#include"CONSTANT.h"#define MAXLEN 15#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define NULL 0PosType start;PosType end;MazeType maze;bool found;#define MAXLEN 15//迷宫包括外墙最大行列数目#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int Status;// 坐标位置类型typedef struct{int r,c;}PosType;//迷宫中r行c列的位置//迷宫类型typedef struct{int step;PosType seat; //当前的坐标位置int di; //往下一坐标位置的方向}ElemType;//结点类型typedef struct{ ElemType *base;ElemType *top;int size;}Stack;Status FootPrint(MazeType maze,PosType curpos);Status MarkPrint(MazeType maze,PosType curpos);void PrintMaze(MazeType maze);Status MazePath(MazeType maze,PosType start,PosType end);void InitMaze(MazeType maze, char a[MAXLEN][MAXLEN], int row, int col);Status Pass(MazeType maze, PosType curpos);PosType NextPos(PosType curpos,int i);typedef struct NodeType{ElemType data;NodeType *next;}NodeType,*LinkType;//栈类型typedef struct{int r;int c;char arr[MAXLEN][MAXLEN];//可取' ','*','@','#' }MazeType;Status InitStack(Stack &S);//InitStackStatus Push(Stack &S,ElemType e) ;Status Pop(Stack &S, ElemType &e) ;Status DestroyStack(Stack &S);//DestroyStackvoid ClearStack(Stack &S);//ClearStackStatus StackEmpty(Stack S);//StackEmptyint StackLength(Stack S);void StackTraverse(Stack S, Status(*visit)(ElemType e));//创建栈void Initialization(){printf("\n*********************************************************"); printf("\n * CreatMaze--c MazePath--m PrintMaze Quit*"); printf("\n*****************************************************"); printf("\n * Operation: *");printf("\n************************************************");printf("\n\n enter a operation code:c,m,p,q:");}//读入操作命令符,显示提示信息void ReadCommand(char &cmd){do{cmd=getche();}while(!(cmd=='c'||cmd=='m'||cmd=='p'));}//解释ch--具体执行void Interpret(char cmd){switch(cmd){case 'c':{int rnum, cnum, i=0,m=1,n=1;char a2[MAXLEN][MAXLEN];char input[20];char data[1000];printf("\n请输入迷宫数据文件名!\n");scanf("%s",input);FILE *fp;fp=fopen(input,"r");if(!fp){printf("\n不能打开文件\n");break;while(!feof(fp)){fscanf(fp,"%s",&data[i]);if(i==0){rnum=(int)data[i]-(int)'0';}if(i==1){cnum=(int)data[i]-(int)'0';}if(i>=2){if(n>cnum){m++;n=1;}a2[m][n]=data[i];n++;}i++;}fclose(fp);InitMaze(maze, a2, rnum, cnum);printf("\n迷宫建立完成!!\n");break;}case 'm':{printf("\n请输入迷宫入口的坐标,以空格为间隔:--"); scanf("%d %d",&start.r,&start.c);printf("\n请输入迷宫出口的坐标,以空格为间隔:--"); scanf("%d %d",&end.r,&end.c);MazePath(maze, start, end);break;}case 'p':{if(found){printf("\n求解迷宫的结果如下--\n");PrintMaze(maze);}else printf("\n找不到路径!\n");}}void main(){char cmd;printf(" welcome to the game!!! "); Initialization();do{ReadCommand(cmd); //读入一个操作符命令Interpret(cmd); //解释执行命令操作符}while(cmd!='q');}#include "stdio.h"#include "malloc.h"#include"typedef.h"#include"CONSTANT.h"Status InitStack(Stack &S){ // 构造一个空栈SS.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));if (!S.base) return OVERFLOW; //存储分配失败S.top = S.base;S.size = STACK_INIT_SIZE;return OK;} //InitStackStatus Push(Stack &S,ElemType e){if (S.top - S.base >= S.size){//栈满,追加存储空间S.base = (ElemType*)realloc( S.base,(S.size + STACKINCREMENT)*sizeof (ElemType)); if (!S.base) return OVERFLOW; //存储分配失败S.top = S.base + S.size;S.size += STACKINCREMENT;}*S.top++ = e;return OK;}//PushStatus Pop(Stack &S, ElemType &e){// 若栈不空,则删除S的栈顶元素,// 用e返回其值,并返回OK;// 否则返回ERRORif (S.top == S.base) return ERROR;e = *--S.top;return OK;}//PopStatus DestroyStack(Stack &S){ //释放栈S所占据的存储空间if(!S.base) return ERROR;free(S.base);S.base=NULL;S.top= NULL;return OK;}//DestroyStackStatus ClearStack(Stack &S){ //将栈S清为空栈????S.top=S.base;return OK;}//ClearStackStatus StackEmpty(Stack S){//如果栈为空栈,则返回TRUE,否则返回FALSEif(S.top==S.base)return TRUE;else return FALSE;}//StackEmptyint StackLength(Stack S){ //返回栈S的长度,实际上是栈中元素的个数return S.top-S.base;}//StackLengthStatus StackTraverse(Stack S,Status (*visit)(ElemType e)){ int i;//从栈底到栈顶依次对栈中每个元素调用visit函数,如果visit失败,则操作失败if(S.top==S.base) return ERROR;for(i=0;i<S.top - S.base;i++)if(visit(S.base[i])==ERROR) return ERROR;return OK;} //StackTraverse#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include"typedef.h"#include"CONSTANT.h"#include "ADTStack.h"Status MarkPrint(MazeType maze,PosType curpos){maze.arr[curpos.r][curpos.c]='@';//"@"表示曾走过但不通return OK;}//曾走过而且是通路标记并返回OKStatus FootPrint(MazeType maze,PosType curpos){maze.arr[curpos.r][curpos.c]='*';//"*"表示可通return OK;}PosType NextPos(PosType &curpos,int i){PosType cpos;cpos=curpos;scanf("%d",&i);switch(i){ //1.2.3.4分别表示东,南,西,北方向case 1 : cpos.c+=1;break;case 2 : cpos.r+=1;break;case 3 : cpos.c-=1;break;case 4 : cpos.r-=1;break;}return cpos;}//判断当前位置是否可通Status Pass(MazeType maze, PosType curpos){if(maze.arr[curpos.r][curpos.c]==' ')return TRUE;elsereturn FALSE;}//创建迷宫//按照用户输入的二维数组(或),设置迷宫maze的初值,包括加上边缘一圈的值void InitMaze(MazeType maze, char a[MAXLEN][MAXLEN], int row, int col){maze.r=row;maze.c=col;int i;for( i=0;i<=col+1;i++){a[0][i]='1';a[row+1][i]='1';}for(i=0;i<=row+1;i++){a[i][0]='1';a[i][col+1]='1';}for(i=0;i<=maze.r+2;i++){for(int j=0;j<maze.c+2;j++){if(a[i][j]=='1')maze.arr[i][j]='#';elsemaze.arr[i][j]=' ';}}}Status MazePath(MazeType maze,PosType start,PosType end){//求解迷宫maze中,从入口start到出口end的一条路径,若存在,返回TRUE,否则返回FALSE PosType curpos;int curstep=1;Stack S;bool found;ElemType e;InitStack(S);curpos=start;//设定"当前位置"为"入口位置"found=FALSE;do{if(Pass(maze,curpos)){//当前位置可以通过,即是未曾走到过的通道块留下足迹FootPrint(maze,curpos);//做可以通过的标识e.seat=curpos;e.di=1; //为栈顶元素赋值Push(S,e); //加入路径if(curpos.r==end.r && curpos.c==end.c) found=TRUE;//如果到达终点返回trueelse{curpos=NextPos(curpos,1);curstep++;//下一位置是当前位置的东邻}}else //当前位置不能通过if(!StackEmpty(S)){Pop(S,e);while(e.di==4 && !StackEmpty(S)){MarkPrint(maze,e.seat); //留下不能通过的标记Pop(S,e);curstep--;}if(e.di<4){e.di++; //换下个方向Push(S,e); //curpos=NextPos(e.seat,e.di); //进行探索}}}while(!StackEmpty(S)&&!found);//DestroyStack(S);return found;}//MazePath将标记路径信息的迷宫(字符型方阵)输出到终端(包括外墙) void PrintMaze(MazeType maze){for(int i=0;i<=maze.r+2;i++){for(int j=0;j<=maze.c+2;j++){printf(" %c",maze.arr[i][j]);//输出迷宫}printf("\n");}}。

c语言~走迷宫

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++代码

数据结构迷宫问题的C++代码

数据结构课程设计——迷宫问题求解代码问题描述及要求:迷宫问题求解输入:第一行n,m表示迷宫大小n*m之后有n行m列,全由01组成,0表示路,1表示墙入口设为(0, 0)出口设为(n-1, m-1)输出:输出从入口到出口的所有不同解,每组解的第一行打印一个数表示第几组解,之后k行表示路径,如:1(0, 0)(0, 1)(1, 1)代码部分(已测试,可直接运行):#include <cstdio>#include <cstring>#define N 255int n,m,cnt;int maze[N][N],step[N][N];struct Point{int x,y;}path[N*N];int oper[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};bool isvaild(int x,int y){if (x >= 0 && x < n && y >= 0 && y < m && !maze[x][y] && !step[x][y])return true;return false;}void dfs(int x,int y,int len){if (x == n-1 && y == m-1){cnt++;printf("%d\n",cnt);for (int i = 0;i < len;i++)printf("(%d,%d)\n",path[i].x,path[i].y);return;}for (int i = 0;i < 4;i++)if (isvaild(x + oper[i][0],y + oper[i][1])){Point tmp;tmp.x = x + oper[i][0];tmp.y = y + oper[i][1];path[len] = tmp;step[tmp.x][tmp.y] = 1;dfs(tmp.x, tmp.y, len+1);step[tmp.x][tmp.y] = 0;}}void work(){step[0][0] = 1;Point cur;cur.x = 0;cur.y = 0;path[0] = cur;dfs(0, 0, 1);}int main(){scanf("%d%d", &n, &m);for (int i = 0;i < n;i++)for (int j = 0;j < m;j++)scanf("%d", &maze[i][j]);cnt = 0;memset(step, 0, sizeof(step));work();return 0;。

数据结构迷宫问题源代码

数据结构迷宫问题源代码

#include<stdio.h>#include<stdlib.h>#include"Status.h"typedef struct{int x;int y;}posType;typedef struct{posType pos;int dirc;}SElemType;#include"SqStack.h"#define Row 12#define Col 12posType nextPos(posType curPos,int d){posType pos;switch(d){case 1: pos.x=curPos.x;pos.y=curPos.y+1;break;case 2: pos.x=curPos.x+1;pos.y=curPos.y;break;case 3: pos.x=curPos.x;pos.y=curPos.y-1;break;case 4: pos.x=curPos.x-1;pos.y=curPos.y;break;}return pos;}Status canGo(posType pos,int M[Row][Col]){if(M[pos.x][pos.y]==0) return TRUE;else return FALSE;}Status Maze(int M[Row][Col],posType start,posType end){ SqStack S;SElemType e;posType curPos;int d,step;InitSqStack(&S,100);curPos=start;d=4;do{if(canGo(curPos,M)){M[curPos.x][curPos.y]=2;e.pos=curPos;e.dirc=d;Push(&S,e);if(curPos.x==end.x&&curPos.y==end.y) break;d=1;curPos=nextPos(curPos,d);}else if(d<4){d++;getTop(S,&e);curPos=nextPos(e.pos,d);}else if(!stackIsEmpty(S)){Pop(&S,&e);d=e.dirc;curPos=e.pos;}}while(!stackIsEmpty(S));if(!stackIsEmpty(S)){Pop(&S,&e);M[e.pos.x][e.pos.y]='e';d=e.dirc;for(step=stackLength(S);step>0;step--){Pop(&S,&e);switch(d){case 1: M[e.pos.x][e.pos.y]=26;break;case 2: M[e.pos.x][e.pos.y]=25;break;case 3: M[e.pos.x][e.pos.y]=27;break;case 4: M[e.pos.x][e.pos.y]=24;break;}d=e.dirc;}M[start.x][start.y]='s';return TRUE;}else return FALSE;}void printMaze(int M[Row][Col],posType start,posType end){int i,j;printf("迷宫:入口(%d,%d),出口(%d,%d)\n",start.x,start.y,end.x,end.y); printf("\t%3c",' ');for(i=0;i<Col;i++)printf("%2d ",i);printf("\n");for(i=0;i<Row;i++){printf("\t%2d",i);for(j=0;j<Col;j++){if(M[i][j]==1)printf("|||");else if(M[i][j]==0)printf(" ");else if(M[i][j]==2)printf(" = ");else printf(" %c",M[i][j]);}printf("\n");}printf("\n");}int main(){int M[Row][Col]={{1,1,1,1,1,1,1,1,1,1,1,1},{1,0,0,0,1,1,0,1,1,1,0,1},{1,0,1,0,0,1,0,0,1,0,0,1},{1,0,1,1,0,0,0,1,1,0,1,1},{1,0,0,1,0,1,0,0,0,0,0,1},{1,1,0,1,0,1,1,0,1,0,1,1},{1,0,0,1,0,0,0,0,1,1,1,1},{1,0,1,0,1,1,1,1,0,0,1,1},{1,0,0,0,0,1,1,0,0,0,1,1},{1,0,1,0,1,0,0,0,1,0,0,1},{1,0,0,0,0,0,1,0,0,1,0,1},{1,1,1,1,1,1,1,1,1,1,1,1} };posType start,end;start.x=1;start.y=1;end.x=10;end.y=10;printMaze(M,start,end);if(Maze(M,start,end)){printf("找到可行路径:\n");printMaze(M,start,end);}else printf("无可行路径!\n");system("pause");return 0;}。

数据结构迷宫源代码

数据结构迷宫源代码

数据结构迷宫源代码数据结构迷宫源代码1.引言在计算机科学中,数据结构是一种组织和存储数据的方式,能够有效地使用和操作这些数据。

迷宫是一种经典的问题,通过使用数据结构,我们可以有效地表示和解决迷宫问题。

本文将介绍如何使用数据结构来表示和解决迷宫问题,并提供相应的源代码。

2.迷宫的定义与表示迷宫可以被定义为一个二维的网格,其中的每个单元格可以是通路或墙壁。

我们可以使用二维数组来表示迷宫,其中的每个元素可以被设定为0代表墙壁,1代表通路。

以下是一个迷宫的示例: ```int[][] maze = {{0, 0, 0, 0, 0},{1, 1, 0, 1, 0},{0, 1, 0, 0, 0},{0, 1, 1, 1, 1},{0, 0, 0, 0, 0}}。

```3.迷宫求解算法3.1 深度优先搜索算法深度优先搜索算法是一种递归的算法,它会尽可能地深入到迷宫中的某个通路,直到无法继续深入为止。

然后回溯到上一个分支点,继续搜索其他的分支。

以下是深度优先搜索算法的代码: ```void dfs(int[][] maze, int row, int col) {// 标记当前位置为已经访问过maze[row][col] = .1。

// 检查周围的四个方向int[] dx = {.1, 1, 0, 0}。

int[] dy = {0, 0, .1, 1}。

for (int i = 0。

i < 4。

i++) {int newRow = row + dx[i]。

int newCol = col + dy[i]。

// 检查新位置是否合法并且是通路if (newRow >= 0 && newRow < maze.length && newCol >= 0 && newCol < maze[0].length &&maze[newRow][newCol] == 1) {dfs(maze, newRow, newCol)。

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"` 和 `"*"`,其他地方都为空。

闯迷宫游戏代码

闯迷宫游戏代码

迷宫游戏源代码Const row = 22, col = 30Dim grid(row + 1, col + 1)Private Sub dmg_Click()Picture1.Left = 400 '初始化图片位置Picture1.Top = 400Timer1.Enabled = True '启动时钟End SubPrivate Sub Form_KeyDown(KeyCode As Integer, Shift As Integer) '键盘控制图片移动l = Picture1.Left \ 400t = Picture1.Top \ 400Line (l * 400, t * 400)-(400 * (l + 1), 400 * (t + 1)), vbGreen, BF '显示走过的路径Select Case KeyCode '随着键盘的动作来移动Case vbKeyLeftIf Picture1.Left - 400 >= 400 ThenIf grid(t, l - 1) = 0 ThenPicture1.Left = Picture1.Left - 400Picture1.Top = Picture1.TopEnd IfEnd IfCase vbKeyRightIf Picture1.Left + 400 <= 400 * col ThenIf grid(t, l + 1) = 0 ThenPicture1.Left = Picture1.Left + 400Picture1.Top = Picture1.TopEnd IfEnd IfCase vbKeyDownIf Picture1.Top + 400 <= 400 * row ThenIf grid(t + 1, l) = 0 ThenPicture1.Left = Picture1.LeftPicture1.Top = Picture1.Top + 400End IfEnd IfCase vbKeyUpIf Picture1.Top - 400 >= 400 ThenIf grid(t - 1, l) = 0 ThenPicture1.Left = Picture1.LeftPicture1.Top = Picture1.Top - 400End IfEnd IfIf Picture1.Top \ 400 = row And Picture1.Left \ 400 = col - 1 ThenTimer1.Enabled = FalseMsgBox ("恭喜你,成功走出迷宫!") '显示成功信息End IfEnd SubPrivate Sub Form_Load()Open "迷宫矩阵.txt" For Input As #1 '读取迷宫矩阵,绘制迷宫图For i = 0 To row + 1For j = 0 To col + 1If 1 <= i And i <= row And 1 <= j And j <= col ThenInput #1, grid(i, j)If grid(i, j) = 1 Then '值为1则表示障碍或墙,0则表示通道,即可行路径Line (j * 400, i * 400)-(400 * (j + 1), 400 * (i + 1)), vbBlue, BFEnd IfElseLine (j * 400, i * 400)-(400 * (j + 1), 400 * (i + 1)), vbBlue, BFEnd IfNextNextClose #1End SubPrivate Sub mig_Click() '随机获取迷宫矩阵Picture1.Left = 400Picture1.Top = 400Randomizem = row * Int(20 * Rnd)Open "迷宫矩阵.txt" For Input As #1 '读取事先设计好的迷宫矩阵,随机读取一种矩阵Do While n <> mLine Input #1, tempn = n + 1LoopFor i = 1 To rowFor j = 1 To colInput #1, grid(i, j)If grid(i, j) = 1 ThenLine (j * 400, i * 400)-(400 * (j + 1), 400 * (i + 1)), vbBlue, BFElseLine (j * 400, i * 400)-(400 * (j + 1), 400 * (i + 1)), vbWhite, BEnd IfNextNextEnd SubPrivate Sub start_Click()Picture1.Left = 400Picture1.Top = 400Open "迷宫矩阵.txt" For Input As #1 '初始化迷宫矩阵For i = 1 To rowFor j = 1 To colInput #1, grid(i, j)If grid(i, j) = 1 ThenLine (j * 400, i * 400)-(400 * (j + 1), 400 * (i + 1)), vbBlue, BFElseLine (j * 400, i * 400)-(400 * (j + 1), 400 * (i + 1)), vbWhite, BEnd IfNextNextClose #1End SubPrivate Sub Timer1_Timer() '使迷宫矩阵动态变化,随机生成的迷宫可能是走不通的X = 1: Y = 1For i = 1 To rowFor j = 1 To colRandomizegrid(i, j) = Int(2 * Rnd)If grid(i, j) = 1 ThenLine (j * 400, i * 400)-(400 * (j + 1), 400 * (i + 1)), vbBlue, BFElseLine (j * 400, i * 400)-(400 * (j + 1), 400 * (i + 1)), vbWhite, BEnd IfNextNextEnd Sub设计时,只需3个picture控件和1个timer控件即可,故还是比较简单的。

数据结构迷宫源代码

数据结构迷宫源代码

数据结构迷宫源代码```python数据结构迷宫源代码概述本文档介绍了一个基于数据结构的迷宫算法的源代码。

迷宫是一个由墙壁和通道组成的网络结构,本算法通过使用数据结构来并解决迷宫。

目录1、算法原理1.1 数据结构选择1.2 迷宫1.3 解决迷宫2、源代码实现2.1 数据结构定义2.2 迷宫算法2.3 迷宫解决算法3、使用示例4、附件1、算法原理1.1 数据结构选择本算法使用了图的数据结构来表示迷宫,其中节点表示迷宫中的位置,边表示相邻位置之间的连接。

使用图的数据结构可以方便地和解决迷宫。

1.2 迷宫迷宫的算法采用了深度优先搜索(DFS),通过递归地寻找迷宫中的通道并打通墙壁,直到无法再继续搜索。

迷宫的过程中使用了堆栈来辅助处理。

1.3 解决迷宫解决迷宫的算法采用了广度优先搜索(BFS),通过从起点开始,逐步扩展搜索范围,直到找到终点或无法再继续搜索。

解决迷宫的过程中使用了队列来辅助处理。

2、源代码实现2.1 数据结构定义以下是迷宫和解决算法所使用的数据结构的定义。

```python定义迷宫节点class MazeNode:def __init__(self, x, y):self:x = xself:y = yself:visited = Falseself:walls = {'N': True, 'S': True, 'W': True, 'E': True}定义迷宫class Maze:def __init__(self, width, height):self:width = widthself:height = heightself:nodes = [[MazeNode(x, y) for y inrange(height)] for x in range(width)]```2.2 迷宫算法以下是迷宫的算法的实现。

```pythondef generate_maze(maze):start_node = maze:nodes[0][0]stack = [(start_node, None)]while stack:curr_node, prev_node = stack:pop()if not curr_node:visited:curr_node:visited = Trueif prev_node:remove_wall(prev_node, curr_node)neighbors =get_unvisited_neighbors(curr_node)if neighbors:stack:append((curr_node, prev_node)) next_node = random:choice(neighbors) stack:append((next_node, curr_node))```2.3 迷宫解决算法以下是解决迷宫的算法的实现。

迷宫游戏C语言小游戏源代码

迷宫游戏C语言小游戏源代码
void FootPri nt(PosType curpos);
PosType NextPos(PosType seat,i nt di);
Status MazePath(PosType start,PosType end);
void CreatMaze(void)
/* Forቤተ መጻሕፍቲ ባይዱ the maze. */
case ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''':Maze[j][k]=2・break・
case ''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''':Maze[j][k]=1・

数据结构-迷宫-实验报告及代码

数据结构-迷宫-实验报告及代码

一.需求分析本程序是利用非递归的方法求出一条走出迷宫的路径,并将路径输出。

首先由用户输入一组二维数组来组成迷宫,确认后程序自动运行,当迷宫有完整路径可以通过时,以0和1所组成的迷宫形式输出,标记所走过的路径结束程序;当迷宫无路径时,提示输入错误结束程序。

程序执行的命令:1创建迷宫;2求解迷宫;3输出迷宫求解;二.算法设计本程序中采用的数据模型,用到的抽象数据类型的定义,程序的主要算法流程及各模块之间的层次调用关系程序基本结构:设定栈的抽象数据类型定义:ADT Stack {数据对象:D={i a |i a ∈CharSet ,i=1,2,3,…..,n,n>=0;}数据关系:R={<1-i a ,i a >|1-i a ,i a ∈D,i=2,…,n}设置迷宫的抽象类型ADT maze{数据对象:D={ai|ai ∈‘ ’,‘@’,‘#’,‘1’,i=1,2,…,n,n>=0} 数据关系:R={r,c}r={<ai-1,ai>|ai-1,ai ∈D, i=1,2,…,n,}c=<ai-1,ai>|ai-1,ai ∈D, i=1,2,…,n,}结构体定义:typedef struct //迷宫中x 行y 列的位置{ int x;int y;}PosType;typedef struct //栈类型{ int ord; //通道块在路径上的“序号”PosType seat; //通道块在迷宫中的“坐标位置”int di; //从此通道块走向下一通道块的“方向”}MazeType;typedef struct{ MazeType *base;MazeType *top;int stacksize; }MazeStack;基本函数:Status InitStack(MazeStack &S)//新建一个栈Status Push(MazeStack &S, MazeType &e)//入栈Status Pop(MazeStack &S, MazeType &e)//出栈Status StackEmpty(MazeStack &S)//判断是否为空Status MazePath(PosType start, PosType end)//迷宫路径求解void FootPrint(PosType pos)PosType NextPos(PosType curPos, int &i)void MakePrint(PosType pos)三.程序设计根据算法设计中给出的有关数据和算法,选定物理结构,详细设计需求分析中所要求的程序。

迷宫寻路游戏使用JavaScript和HTMLCanvas进行开发

迷宫寻路游戏使用JavaScript和HTMLCanvas进行开发

迷宫寻路游戏使用JavaScript和HTMLCanvas进行开发迷宫寻路游戏是一款能够锻炼思维能力和逻辑推理的游戏,通过寻找正确路径来从迷宫的起点到达终点。

本文将介绍如何使用JavaScript 和HTMLCanvas来进行迷宫寻路游戏的开发。

一、准备工作在开始开发之前,我们需要准备好以下工作:1. 创建HTML页面,引入JavaScript和CSS文件;2. 创建绘制迷宫的画布;3. 准备迷宫的数据结构。

二、绘制迷宫为了展示迷宫,我们需要将迷宫数据结构绘制到HTMLCanvas上。

首先,我们需要创建一个画布元素和上下文对象,代码如下:```html<canvas id="mazeCanvas" width="600" height="400"></canvas>``````javascriptconst canvas = document.getElementById('mazeCanvas');const ctx = canvas.getContext('2d');```接下来,我们可以通过遍历迷宫的数据结构来绘制墙壁和通道。

假设迷宫数据结构由一个二维数组表示,其中0代表墙壁,1代表通道,代码如下:```javascriptconst maze = [[0, 0, 0, 0, 0 ,0],[0, 1, 1, 1, 1 ,0],[0, 0, 0, 0, 1 ,0],[0, 1, 0, 0, 1 ,0],[0, 1, 1, 1, 1 ,0],[0, 0, 0, 0, 0 ,0]];const blockSize = canvas.width / maze[0].length;maze.forEach((row, rowIndex) => {row.forEach((cell, colIndex) => {const x = colIndex * blockSize;const y = rowIndex * blockSize;if (cell === 0) {ctx.fillRect(x, y, blockSize, blockSize); // 填充墙壁} else {ctx.clearRect(x, y, blockSize, blockSize); // 清除通道}});});```通过以上代码,我们可以将迷宫绘制到画布上。

简单的迷宫小游戏C语言程序源代码

简单的迷宫小游戏C语言程序源代码

简单的迷宫小游戏C语言程序源代码#include <stdio.h>#include <conio.h>#include <windows.h>#include <time.h>#define Height 31 //迷宫的高度,必须为奇数#define Width 25 //迷宫的宽度,必须为奇数#define Wall 1#define Road 0#define Start 2#define End 3#define Esc 5#define Up 1#define Down 2#define Left 3#define Right 4int map[Height+2][Width+2];void gotoxy(int x,int y) //移动坐标{COORD coord;coord.X=x;coord.Y=y;SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HA NDLE ), coord );}void hidden()//隐藏光标{HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);CONSOLE_CURSOR_INFO cci;GetConsoleCursorInfo(hOut,&cci); cci.bVisible=0;//赋1为显示,赋0为隐藏SetConsoleCursorInfo(hOut,&cci);}void create(int x,int y) //随机生成迷宫{int c[4][2]={0,1,1,0,0,-1,-1,0}; //四个方向int i,j,t;//将方向打乱for(i=0;i<4;i++){j=rand()%4;t=c[i][0];c[i][0]=c[j][0];c[j][0]=t;t=c[i][1];c[i][1]=c[j][1];c[j][1]=t;}map[x][y]=Road;for(i=0;i<4;i++)if(map[x+2*c[i][0]][y+2*c[i][1]]==Wall) {map[x+c[i][0]][y+c[i][1]]=Road; create(x+2*c[i][0],y+2*c[i][1]);}}int get_key() //接收按键{char c;while(c=getch()){if(c==27) return Esc; //Escif(c!=-32)continue;c=getch();if(c==72) return Up; //上if(c==80) return Down; //下if(c==75) return Left; //左if(c==77) return Right; //右}return 0;}void paint(int x,int y) //画迷宫{gotoxy(2*y-2,x-1);switch(map[x][y]){case Start:printf("入");break; //画入口case End:printf("出");break; //画出口case Wall:printf("※");break; //画墙case Road:printf(" ");break; //画路}}void game(){int x=2,y=1; //玩家当前位置,刚开始在入口处int c; //用来接收按键while(1){gotoxy(2*y-2,x-1);printf("☆"); //画出玩家当前位置if(map[x][y]==End) //判断是否到达出口{gotoxy(30,24);printf("到达终点,按任意键结束"); getch();break;}c=get_key();if(c==Esc){gotoxy(0,24);break;}switch(c){case Up: //向上走if(map[x-1][y]!=Wall){paint(x,y);x--;}break;case Down: //向下走if(map[x+1][y]!=Wall){paint(x,y);x++;}break;case Left: //向左走if(map[x][y-1]!=Wall){paint(x,y);y--;}break;case Right: //向右走if(map[x][y+1]!=Wall){paint(x,y);y++;}break;}}}int main(){int i,j;srand((unsigned)time(NULL)); //初始化随即种子hidden(); //隐藏光标for(i=0;i<=Height+1;i++)for(j=0;j<=Width+1;j++)if(i==0||i==Height+1||j==0||j==Width+1) //初始化迷宫map[i][j]=Road;else map[i][j]=Wall;create(2*(rand()%(Height/2)+1),2*(rand()%(Width/2)+1)); //从随机一个点开始生成迷宫,该点行列都为偶数for(i=0;i<=Height+1;i++) //边界处理{map[i][0]=Wall;map[i][Width+1]=Wall;}for(j=0;j<=Width+1;j++) //边界处理{map[0][j]=Wall;map[Height+1][j]=Wall;}map[2][1]=Start; //给定入口map[Height-1][Width]=End; //给定出口for(i=1;i<=Height;i++)for(j=1;j<=Width;j++) //画出迷宫paint(i,j);game(); //开始游戏getch();return 0;}。

迷宫游戏代码

迷宫游戏代码
for(i=1;i<m+1;i++)
{
for(j=1;j<n+1;j++)
{
maze[i][j]=rand()%5; //产生随机数
if(maze[i][j]==1)
{maze[i][j]=1;}
else
{maze[i][j]=0;}
}
}
maze[1][1]=0,mazedl;
}
return 0;
}
int computer()
{
for(i=0;i<n+2;i++) {maze[0][i]=1;}
for(i=0;i<m+2;i++) {maze[i][0]=1;}
for(i=0;i<n+2;i++) {maze[m+1][i]=1;}
for(i=0;i<m+2;i++) {maze[i][n+1]=1;} //在迷宫外面加一圈围墙
cout<<"0 1 0 1"<<endl;
cout<<"0 0 0 1"<<endl;
cout<<"1 1 0 0"<<endl;
cout<<"请设置你的地图:"<<endl;
for(i=0;i<n+2;i++) {maze[0][i]=1;}
for(i=0;i<m+2;i++) {maze[i][0]=1;}

数据结构迷宫源代码

数据结构迷宫源代码

#include <stdio.h>#include <malloc.h>#include <stdlib.h>#include <string.h>#include <time.h>#define OK 1#define ERROR 0#define NULL 0#define OVERFLOW -2#define STACK_INIT_SIZE 100#define STACKINCREMENT 10//栈的顺序存储表示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 InitStack(SqStack *S){S->base=(SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));if(!S->base)exit(OVERFLOW);S->top=S->base;S->stacksize=STACK_INIT_SIZE;return OK;}//若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERROR int GetTop(SqStack *S,SElemType *e){if(S->top==S->base) return ERROR;*e=*(S->top-1);return OK;}int Push(SqStack *S,SElemType *e)//插入元素e作为新的栈顶元素{if(S->top-S->base>=S->stacksize)/*栈满,追加存储空间*/{S->base = (SElemType *)realloc(S->base,(S->stacksize + STACKINCREMENT) * sizeof(SElemType));if(!S->base) exit(OVERFLOW);S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=*e;return OK;}//若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERRORint Pop(SqStack *S,SElemType *e){if(S->top==S->base) return ERROR;*e=*--S->top;return OK;}int StackEmpty(SqStack *S){return(S->top==S->base) ;}//迷宫程序typedef struct {int lie; /*列数*/int hang; /*行数*/char a[999][999];}MazeType; /*迷宫类型*//*随机生成迷宫*/int generatemaze( MazeType *maze){int i,j;maze->a[0][0]=2;maze->a[++maze->hang][++maze->lie]=3;/*设置外墙*/maze->a[0][maze->lie]='!';maze->a[maze->hang][0]='!';for(j=1;j<maze->lie;j++){maze->a[0][j]='!';maze->a[maze->hang][j]='!';}for(i=1;i<maze->hang;i++){maze->a[i][0]='!';maze->a[i][maze->lie]='!';}srand((unsigned)time( NULL ));rand();for(i=1; i <maze->hang; i++)for(j=1;j<maze->lie;j++){if (rand()>=RAND_MAX/4) maze->a[i][j] =' '; //' ' 暗示出路else maze->a[i][j] ='!'; //'!'暗示无出路}return OK;}int Pass(MazeType *maze, PosType curpos ) //判断当前位置可否通过{if ((curpos.x < 1) || (curpos.x >= maze->lie)) return ERROR;if ((curpos.y < 1) || (curpos.y >= maze->hang)) return ERROR;if (maze->a[curpos.y][curpos.x]==' ') return OK;else return ERROR;}int FootPrint(MazeType *maze,PosType curpos) //留下足迹{maze->a[curpos.y][curpos.x]='*';return OK;}int MarkPrint(MazeType *maze,PosType curpos) //留下不能通过的标记{maze->a[curpos.y][curpos.x]='@';return OK;}PosType NextPos(PosType curpos,int di) //返回当前位置的下一位置{PosType pos=curpos;switch(di){case 1: //右东pos.x++;break;case 2: //下南pos.y++;break;case 3: //左西pos.x--;break;case 4: //上北pos.y--;break;}return pos;}//若迷宫有解,则求得一条存放在栈中(从栈底到栈顶),并返回OK,否则返回ERROR int MazePath(MazeType *maze,PosType start,PosType end){PosType curpos;SqStack *S=(SqStack *)malloc(sizeof(SqStack));InitStack(S);SElemType *e;e=(SElemType *)malloc(sizeof(SElemType));curpos=start; //设定当前位置为入口位置int curstep = 1; //探索第一步do{if(Pass(maze,curpos)) //当前位置可通过{FootPrint(maze,curpos);e->ord=curstep;e->seat=curpos;e->di=1;Push(S,e);if(curpos.x==end.x&&curpos.y==end.y) return (OK);curpos=NextPos(curpos,1);curstep++;}else{if(!StackEmpty(S)){Pop(S,e);while(e->di==4&&!StackEmpty(S)) //栈不空但栈顶位置四周均不通{MarkPrint(maze,e->seat);Pop(S,e);}if(e->di<4) //栈不空且栈顶位置四周有其他位置未探索{e->di++;Push(S,e);curpos=e->seat;curpos=NextPos(curpos,e->di);}}}}while(!StackEmpty(S));return ERROR;}void PrintMaze(MazeType *maze) //打印迷宫{int i,j,k,n;int c[999],d[999];for(i=0,k=0;i<=maze->hang;i++){for(j=0;j<=maze->lie;j++){printf("%c ",maze->a[i][j]);if(maze->a[i][j]=='*'){c[k]=i;d[k]=j;k++;}}printf("\n");}n=k;for(k=0;k<n;k++)printf("<%d,%d>",c[k],d[k]);printf("\n");printf("\n");}int main(){int zmg;char ch;printf(" 数据结构课程设计--迷宫问题求解\n\n");printf(" |----------------------------------------|\n");printf(" | |\n");printf(" | |\n");printf(" | |\n");printf(" | |\n");printf(" | XXXX XXXXXXXXXXXXXX |\n");printf(" | XXXXXXX |\n");printf(" |----------------------------------------|\n");getchar();do{system("cls");fflush(stdin);MazeType *maze=(MazeType *)malloc(sizeof(MazeType));//设置迷宫的长宽不含外墙printf("请输入迷宫的列数(不含外墙时):");scanf("%d",&maze->lie);printf("请输入迷宫的行数(不含外墙时):");scanf("%d",&maze->hang);generatemaze(maze);printf("随机创建迷宫\n");PrintMaze(maze);getchar();getchar();PosType start,end;start.x=1;start.y=1;end.x=maze->lie-1;end.y=maze->hang-1;zmg=MazePath(maze,start,end);if(zmg){printf("此迷宫通路为\n");PrintMaze(maze);}else printf("此迷宫无通路\n");//getchar();printf("再次尝试?(Y/N)?");scanf("%c",&ch);}while(ch=='Y'||ch=='y');return 0; }。

基于C语言实现简单的走迷宫游戏

基于C语言实现简单的走迷宫游戏

基于C语⾔实现简单的⾛迷宫游戏本⽂实例讲述了C语⾔实现简单的⾛迷宫游戏的⽅法,代码完整,便于读者理解。

学数据结构时⽤“栈”写的⼀个⾛迷宫程序,实际上⽤到双向队列,⽅便在运⾏完毕后输出经过的点。

#include <cstdio>#include <deque>#include <windows.h>using namespace std;class node{public:int x,y;int lastOpt;};deque<node> sta;int x,y;int endx,endy;int mapW,mapH;int steps;int xopt[5]= {0,0,1,0,-1};int yopt[5]= {0,1,0,-1,0};int map[100][100]={};void init(){x = 1;y = 1;endx = 1;endy = 9;mapH = 10;mapW = 10;for(int i=0; i<=mapH; i++)for(int j=0; j<=mapW; j++){if(i==0 ||j==0 ||i==mapH||j==mapW)map[i][j]=-1;}steps=0;map[1][2]=-1;map[2][2]=-1;map[3][2]=-1;map[4][2]=-1;map[6][2]=-1;map[7][2]=-1;map[8][2]=-1;map[9][2]=-1;map[9][3]=-1;map[8][3]=-1;map[1][4]=-1;map[3][4]=-1;map[4][4]=-1;map[5][4]=-1;map[6][4]=-1;map[7][4]=-1;map[1][6]=-1;map[2][6]=-1;map[3][6]=-1;map[4][6]=-1;map[5][6]=-1;map[6][6]=-1;map[7][6]=-1;map[8][6]=-1;map[8][7]=-1;map[8][8]=-1;map[7][8]=-1;map[6][8]=-1;map[5][8]=-1;map[4][8]=-1;map[2][8]=-1;map[1][8]=-1;map[endx][endy]=5;}void dis(){system("cls");int ori = map[x][y];map[x][y]=1;for(int i=0; i<=mapH; ++i){for(int j=0; j<=mapW; ++j){if(map[i][j]==0)printf(" ");else if(map[i][j]==-1)printf(" #");else if(map[i][j]==1)printf(" @");else if(map[i][j]==2)printf(" .");else if(map[i][j]==5)printf(" !");}cout<<i<<endl;}for(int j=0; j<=mapW; ++j)cout<<j<<" ";printf("\n\n > steps:%d Exit:(%d,%d)\n",steps,endx,endy);map[x][y] = ori;}int can(int n){if(map[x+xopt[n]][y+yopt[n]] == 0 || map[x+xopt[n]][y+yopt[n]] == 5) return 1;return 0;}void visit(int n){map[x][y]=2;x+=xopt[n];y+=yopt[n];node tem;tem.x = x;tem.y = y;stOpt = n;sta.push_back(tem);steps++;}int main(){init();node tem;while( x != endx || y!=endy){int cans = 0;for(int i=1; i<=4; i++){if(can(i)){cans = 1;visit(i);break;}}if(!cans){if(!sta.empty()){tem = sta.back();map[tem.x][tem.y]=0;}else{map[x][y]=2;x+=xopt[stOpt];x+=yopt[stOpt];dis();break;}}dis();Sleep(500);}if(x==endx && y == endy)cout<<"\n > i am finished....\n";elsecout<<"\n > i am finished...but i can't find the right way\n";return 0;}效果图:以上就是本⽂的全部内容,希望对⼤家学习C语⾔有所帮助。

C++迷宫游戏源代码

C++迷宫游戏源代码
for(int j=1;j<=n;j++){
if(maze[i][j]==-1)
maze[i][j]=0;
}
}
}
int path1(int **maze,int m,int n,int c,int d,int x1,int y1)//最短路径
{ //m,n为迷宫的ze为迷宫;
front++; //当前点搜索完,取下一个点搜索
} //while
G:cout<<"无路径。"<<endl;
return 0;
}
void path(int **maze,int a,int b,int m,int n)
{
item move[8]={{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}};
#include<iostream>
#include<stack>
#include<stdio.h>
#include<time.h>
#include<string>
using namespace std;
typedef struct
{
int x,y;
}item;
typedef struct
}
if(i==x1&&j==y1){
cout<<"最短路径为:"<<endl;
printpath(sq,rear); //输出路径;
restore(maze,m,n); //恢复迷宫;

C语言数据结构中求解迷宫问题实现方法

C语言数据结构中求解迷宫问题实现方法

C语⾔数据结构中求解迷宫问题实现⽅法C语⾔数据结构中求解迷宫问题实现⽅法在学习数据结构栈的这⼀节遇到了求迷宫这个问题,拿来分享⼀下~⾸先求迷宫问题通常⽤的是“穷举求解” 即从⼊⼝出发,顺某⼀⽅向试探,若能⾛通,则继续往前⾛,否则原路返回,换另⼀个⽅向继续试探,直⾄⾛出去。

我们可以先建⽴⼀个8*8的迷宫其中最外侧为1的是墙int mg[M+2][N+2]={{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},}如上所⽰,0对应通道⽅块,1代表墙。

对于迷宫中的每个⽅块,有上下左右4个⽅块相邻,我们规定第i⾏第j列⽅块的位置为(i,j)规定上⽅⽅块⽅位为0,顺时针⽅向递增编号。

(i,j)上⽅的即为(i-1,j),下⽅(i+1,j),左⽅(i,j-1),右⽅(i,j+1). 为了⽅⾯回溯,我们需要有进栈出栈操作,所以我们来定义:struct {int i;//当前⽅位⾏int j;//当前⽅位列int di;//下⼀个可⾛⽅位号}St[MaxSize];//栈int top=-1;//初始化栈顶指针我们来看看⽂字过程~~⾸先将⼊⼝进栈(初始⽅位为-1),在栈不空的情况下循环:取栈顶⽅块(不退栈),若该⽅块是出⼝,则退栈。

若存在这样的⽅块,则将其⽅位保存到栈顶元素中,并将这个可⾛的相邻⽅块进栈。

对应的算法:void mgpath(int x1,int y1,int x2,int y2){int i.j,di,find,k;top++;St[top].i=x1; St[top].j=y1; St[top].di=-1; mg[x1][y1]=-1;while (top>-1){i=St[top].i; j=St[top].j; di=St[top].di;if (i==x2 && j==y2){printf("迷宫路径如下:\n");for (k=0;k<=top;k++){printf("\t(%d,%d)",St[k].i,S[k].j);if ((k+1)%5==0) printf("\n"); //输出5个换⼀⾏}printf("\n"); //找到⼀条路径后结束return ;}find=0;while (di<4 && find==0){di++;switch(di){case 0: i=St[top].i-1; j=S[top].j;break;case 1: i=St[top].i; j=St[top].j+1;break;case 2: i=St[top].i+1;j=St[top].j;break;case 3: i=St[top].i; j=St[top].j-1;break;}if(mg[i] [j]==0) find=1;}if (find==1){ //找到了下⼀个可⾛⽅块St[top].di=di;//修改原栈顶的值top++; //下⼀个可⾛⽅块进栈St [top].i=i; St[top].j=j;St[top].di=-1;mg[i] [j]=-1;//避免重复⾛到该⽅块}else{ //没有路径可⾛,进⾏退栈操作mg[St[top].i] [St[top].j]=0;//让该位置变为其他路径的可⾛⽅块top--;}}printf("没有路径可⾛!\n");}当然我们也可以⽤队列去求该迷宫的最优算法,这只是⼀个⽤来理解栈的例⼦~~~感谢阅读,希望能帮助到⼤家,谢谢⼤家对本站的⽀持!。

C++实现简单走迷宫的代码

C++实现简单走迷宫的代码

C++实现简单⾛迷宫的代码本⽂实例为⼤家分享了C++实现⾛迷宫的具体代码,供⼤家参考,具体内容如下⽤n*n个⼩⽅格代表迷宫,每个⽅格上有⼀个字符0或1,0代表这个格⼦不能⾛,1代表这个格⼦可以⾛。

只能⼀个格⼦⼀个⾛,⽽且只能从⼀个格⼦向它的上、下、左、右四个⽅向⾛,且不能重复。

迷宫的⼊⼝和出⼝分别位于左上⾓和右下⾓,存在唯⼀的⼀条路径能够从⼊⼝到达出⼝,试着找出这条路径。

例如,下图是⼀个迷宫,红⾊表⽰⾛出迷宫的⼀条路径输⼊:⼊⼝坐标(startX,startY),出⼝坐标(endX,endY)输出:如果存在这样⼀条路径,则输出1,并输出路径(0,0)->(1,0)->(1,1)->(2,1)->(2,2)->(3,2)->(4,2)->(5,2)->(5,3)->(5,4)->(5,5)->(4,5)->(4,6)->(4,7)->(5,7)->(6,7)->(7,7)思路:利⽤回溯法求解。

⾸先,根据输⼊在矩阵中找到路径的起点。

假设矩阵中某个格⼦的字符为1,就往相邻的格⼦寻找字符为1的格⼦。

除了在矩阵边界上的格⼦之外,每个格⼦都有4个相邻的格⼦。

重复这个过程直到在矩阵中找到相应的出⼝位置。

当在矩阵中定位了路径上n个格⼦的位置后,在与第n个格⼦周围都没有找到第n+1个格⼦为1,则只好在路径上回到第n-1个格⼦,重新去寻找第n个字符为1的格⼦由于路径不能重复进⼊格⼦,我们需要定义⼀个字符矩阵⼀样⼤⼩的布尔值矩阵,⽤来标记路径是否已经进⼊了相应格⼦。

代码实现如下#include <iostream>#include <vector>using namespace std;class Solution {public:bool hasPath(char* matrix, int rows, int cols, int startX,int startY, int endX, int endY,vector<int>& Path){if (matrix == NULL || rows < 1 || cols < 1 || startX<0||startY<0||endX<0||endY<0||(startX==endX&&startY==endY))return false;bool* visited = new bool[rows*cols]; //定义⼀个辅助矩阵,⽤来标记路径是否已经进⼊了每个格⼦memset(visited, 0, rows*cols);int pathLength = 0;if (hasPathCore(matrix, rows, cols, startX, startY, endX, endY, visited, Path)){return true;}delete[] visited;return false;}/*此函数⽤来判断在当前路径满⾜条件下,相邻格⼦中是否存在⼀个格⼦满⾜条件*/bool hasPathCore(char* matrix, int rows, int cols, int row, int col, int endX, int endY, bool* visited, vector<int>& Path) {if ((row == endX) && (col == endY)&&(matrix[row*cols+col]=='1')){Path.push_back(endY);Path.push_back(endX);return true;}bool hasPath = false;if (row >= 0 && row < rows&&col >= 0 && col < cols&&matrix[row*cols + col] == '1' && !visited[row*cols + col]){// ++pathLength;visited[row*cols + col] = true;Path.push_back(col);Path.push_back(row);/*如果矩阵格⼦(row,col)字符为1时,从它的4个相邻格⼦中寻找下⼀个字符为1的格⼦*/hasPath = hasPathCore(matrix, rows, cols, row, col - 1, endX, endY, visited,Path) ||hasPathCore(matrix, rows, cols, row - 1, col, endX, endY, visited,Path) ||hasPathCore(matrix, rows, cols, row, col + 1, endX, endY, visited,Path) ||hasPathCore(matrix, rows, cols, row + 1, col, endX, endY, visited,Path);if (!hasPath) //如果没找到,则说明当前第n个格⼦定位不正确,返回上⼀个位置重新定位{visited[row*cols + col] = false;Path.pop_back();Path.pop_back();}}return hasPath;}};int main(){// char* matrix = "abcesfcsadee";char* matrix = "1000000110110001101000010111011110100000010000001"; //设置迷宫int startX, startY, endX, endY;cin >> startX >> startY >> endX >> endY; //输⼊起始结束坐标Solution s;vector<int> Path;bool re = s.hasPath(matrix, 7, 7, startX,startY,endX,endY,Path);cout << re << endl;for (int i = 0; i < Path.size();)cout << "(" << Path[i++] << ',' << Path[i++] << ")" << " ";cout << endl;return 0;}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
exit(0);
}
else{
fprintf(fp,"\n");
fprintf(fp,"new map:");
for( i=0;i<h;i++)
{
fprintf(fp,"\n");
for( j=0;j<w;j++)
S->top=-1;
return S;
}
void Push(SqStack *S,SElemType data)//入栈
{
S->top++;
S->data[S->top]=data;
}
void Pop(SqStack *S)//出栈
{
S->top--;
}
void print(SqStack *s) //显示一条路径
{ printf("\a");
if(x>0&&!MAP[y][x-1])
x--;
}break;
case 'd'://右
{ printf("\a");
}
}
void savemap(int map[h][w])//保存地图
{
int iHale Waihona Puke j; FILE *fp;
if((fp=fopen("mapshow.txt","a"))==NULL)//以追加的方式打开一个文件
{
printf("Can't open file\n");
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<stdlib.h>
#include<conio.h>
#define h 11
#define w 10
typedef struct
{
int r,c;
}PosType;//坐标 r表示行,c表示列
switch(cCtrl)
{
case 'w'://向上
{ printf("\a");//响铃
if(y>0&&!MAP[y-1][x])
y--;
{
printf(" 你输了,完蛋了,小老鼠要饿死了 囧rz!!\n");
}
else//win
{ printf(" \n └(^o^)┘ 小老鼠总算找到粮仓了,谢谢啊! \n 这是你赢得的金币◎,小老鼠奉上:\n");
int i;
printf("第%d条路径为:\n",count);
for(i=0;i<=s->top;i++)
{
printf("(%d,%d,%d) ",s->data[i].seat .r,s->data[i].seat.c,s->data[i].d);
map[s->data[i].seat .r][s->data[i].seat.c]=2;
SElemType data;
if(x==h-2&&y==w-2)//到达出口
{
print(S);
return;
}
for(i=0;i<4;i++)//进行四个方向的判断
{
data.seat.r=x;
data.seat.c=y;
data.d=i;
maze[x][y]=-1;
printf(" ");
for(int i=0;i<20-duration;i++)
printf("◎");
printf("\n");
}
return;
}
}
printf("\n");
}
}
}
printf("\n");
printf("你耗费的时间是:\n");
printf("%f秒\n",duration);
if(duration>killtime)//lose
{1,0,0,0,1,0,0,0,0,1},
{1,0,1,0,0,0,1,0,1,1},
{1,0,1,1,1,1,0,0,1,1},
{1,1,1,0,0,0,1,0,1,1},
{1,1,1,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1}
};
typedef struct
{
PosType seat;
int d;
}SElemType;//seat表示当前坐标,d表示当前要转的方向序号
typedef struct
{
SElemType data[1000];
int top;
}SqStack;//栈元素类型,含有一个三元组,top表示该数组的元素个数
if(!MAP[y][x+1])
x++;
}break;
}
system("cls");//刷屏
for(m=0;m<h;m++)
{
int t=0;
while(fscanf(fp,"%d",&a[t])!=EOF)//没有到文件结尾
for(n=0;n<w;n++)
{
if(m==y&&n==x)
{
system("color 6");
printf("◎");//现实老鼠所在位置
if(m==9&&n==8)
printf("☆");//显示粮仓
else
printf("□");//显示可行路径
}
}
double duration;//持续时间
int x=1,y=1,m=0,n=0,M,N,MAP[100][100];//x->colom y->row
char cCtrl='\0';
printf(" 游戏规则:\n w向上,s向下,a向左,d向右,q退出\n 按任意键开始,方向键开始计时\n");
}break;
case 's'://下
{ printf("\a");
if(!MAP[y+1][x])
y++;
}break;
case 'a'://左
}
else
{
if(MAP[m][n])
printf("■");//打印墙壁
else
{
if((i+1)%5==0)
printf("\n");
}
printf("\n");
printf("\n");
count++;
int m,n;
for(m=0;m<h;m++)
{
printf("\n");
for(n=0;n<w;n++)
{
if(map[m][n]==2)
for(M=0;M<=h-1;M++)
for(N=0;N<=w-1;N++)
MAP[M][N]=map1[M][N];
{
{
start = clock();//开始计时
while((cCtrl=getch())!='q')
{
{
int map[h][w]={//形成迷宫的矩阵
{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,0,0,1,1},
{1,0,1,1,1,0,0,1,0,1},
if(x==8&&y==9)
{
finish = clock();//停止计时
duration = (double)(finish - start) / CLOCKS_PER_SEC;//compute the time
}
x=x-move[i].r;//若下一方向不通,回到此坐标
y=y-move[i].c;
maze[x][y]=0;
}
}
void game(int map1[h][w])//游戏函数
{
#define killtime 15
clock_t start, finish;
x=x+move[i].r;//对下一个方向处理
y=y+move[i].c;
if(maze[x][y]==0)//如果下一方向可通,把此元素入栈
相关文档
最新文档