电脑鼠走迷宫算法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语⾔⽼⿏⾛迷宫（单路径）算法详细讲解最近在学习C语⾔的⼀些经典算法，其中遇到了⼀点困难，导致卡进度了。
琢磨了很久，在绘制流程图时，突然灵感⼤开理解了，⽼⿏⾛迷宫算法的奇妙。
所以写了这个，⼀来是⽅便以后右和我类似的同学⾃学时，遇到这个问题可以找到解决的⽅法，⼆来是为了记录⼀下⾃⼰的思路，以免以后记不住。
俗话说得好，好记性不如烂笔头。
那么废话不多说，进⼊正题。
关于C语⾔⽼⿏⾛迷宫算法，⽹上有很多案例，CSDN上⾯也有很多。
⼤家都是能找到的。
基本上的思路都是利⽤数组模拟迷宫，利⽤函数的递归算法来实现的。
以下为⽼⿏⾛迷宫(单路径)的代码:1# include <stdio.h>2# include <Stdlib.h>3int vis(int, int);45int maze[7][7] = {{2, 2, 2, 2, 2, 2, 2},//绘制⼀个7x7的迷宫6 {2, 0, 0, 0, 0, 0, 2},7 {2, 0, 2, 0, 2, 0, 2},8 {2, 0, 0, 2, 0, 2, 2},9 {2, 2, 0, 2, 0, 2, 2},10 {2, 0, 0, 0, 0, 0, 2},11 {2, 2, 2, 2, 2, 2, 2}};12int startI = 1, startJ = 1;//定义起点13int endI = 5, endJ = 5;//定义终点14int success = 0;//定义终点变量1516int main (){17 int i, j;18 //显⽰迷宫19 printf("显⽰迷宫: \n");20 for(i = 0; i < 7; i++){21 for(j = 0; j < 7; j++){22 if(maze[i][j] == 2)//当数组内元素为2时就是墙23 printf("■ ");24 else printf("□ ");//否则就说明其余是路25 }26 printf("\n");27 }2829 if(vis(startI, startJ) == 0)//调⽤⾛迷宫函数vis,寻找从起点到终点的路径,若⽆法到达此处输出30 printf("\n没有找到出⼝ \n");31 else {32 //输出解密后的路径3334 printf("\n迷宫路径为:\n");35 for(i = 0; i < 7; i++){36 for(j = 0; j < 7; j++){37 if(maze[i][j] == 2)//同上,2代表墙38 printf("■ ");39 else if(maze[i][j] == 1)//在29⾏处调⽤vis函数后,就已经将迷宫的路径解答出来了. 1代表所⾛的路径及迷宫正确⾛法40 printf(" ");41 else printf("□ ");//否则就是不正确的路42 }43 printf("\n");44 }45 }4647 return 0;48}4950int vis(int i, int j){//迷宫解密函数51 maze[i][j] = 1;//将当前位置定义为152 if(i == endI && j == endJ) success = 1;//若到达终点,令终点为153 if(success != 1 && maze[i][j+1] == 0) vis(i, j+1);//向右探索路径，可以就执⾏，不⾏就执⾏下⼀条语句54 if(success != 1 && maze[i+1][j] == 0) vis(i+1, j);//向下探寻路径，可以就执⾏，不⾏就执⾏下⼀条语句55 if(success != 1 && maze[i][j-1] == 0) vis(i, j-1);//向左探索路径，可以就执⾏，不⾏就执⾏下⼀条语句56 if(success != 1) maze[i][j] = 0;//判断是否到达终点,没有就将路径清零57 return success;58}备注之类的我都写好了。
经典C语言算法实现(linux系统)
经典C语言算法的实现河内塔费式数列巴斯卡三角形三色棋老鼠走迷官（一）老鼠走迷官（二）骑士走棋盘八个皇后八枚银币生命游戏字串核对双色、三色河内塔背包问题（Knapsack Problem）数、运算蒙地卡罗法求PIEratosthenes筛选求质数超长整数运算（大数运算）长PI最大公因数、最小公倍数、因式分解完美数阿姆斯壮数最大访客数中序式转后序式（前序式）后序式的运算关于赌博洗扑克牌（乱数排列）Craps赌博游戏约瑟夫问题（Josephus Problem）集合问题排列组合格雷码（Gray Code）产生可能的集合m元素集合的n个元素子集数字拆解排序得分排行选择、插入、气泡排序Shell 排序法- 改良的插入排序Shaker 排序法- 改良的气泡排序Heap 排序法- 改良的选择排序快速排序法（一）快速排序法（二）快速排序法（三）合并排序法基数排序法搜寻循序搜寻法（使用卫兵）二分搜寻法（搜寻原则的代表）插补搜寻法费氏搜寻法矩阵稀疏矩阵多维矩阵转一维矩阵上三角、下三角、对称矩阵奇数魔方阵4N 魔方阵2(2N+1) 魔方阵1.河内之塔说明河内之塔(Towers of Hanoi)是法国人M.Claus(Lucas)于1883年从泰国带至法国的，河内为越战时北越的首都，即现在的胡志明市；1883年法国数学家Edouard Lucas曾提及这个故事，据说创世纪时Benares有一座波罗教塔，是由三支钻石棒（Pag）所支撑，开始时神在第一根棒上放置64个由上至下依由小至大排列的金盘（Disc），并命令僧侣将所有的金盘从第一根石棒移至第三根石棒，且搬运过程中遵守大盘子在小盘子之下的原则，若每日仅搬一个盘子，则当盘子全数搬运完毕之时，此塔将毁损，而也就是世界末日来临之时。
解法如果柱子标为ABC，要由A搬至C，在只有一个盘子时，就将它直接搬至C，当有两个盘子，就将B当作辅助柱。
如果盘数超过2个，将第三个以下的盘子遮起来，就很简单了，每次处理两个盘子，也就是：A->B、A ->C、B->C这三个步骤，而被遮住的部份，其实就是进入程式的递回处理。
老鼠运动轨迹实验报告
一、实验目的通过本次实验，了解老鼠在迷宫中的运动轨迹，探究其寻找出口的策略，并尝试运用数据结构中的搜索算法来模拟老鼠的行走过程，分析其路径选择的特点。
二、实验原理迷宫问题是一个经典的算法问题，旨在通过模拟老鼠在迷宫中寻找出口的过程，来验证和优化搜索算法。
本实验采用深度优先搜索（DFS）算法来模拟老鼠的运动轨迹，通过堆栈来存储老鼠走过的路径，并记录其最终找到出口的最短路径。
三、实验材料1. 迷宫地图：一个二维数组，表示迷宫的布局，其中0代表无墙、没走过；1代表墙；2代表无墙、已走过。
2. C语言编程环境：用于编写和运行实验代码。
3. 输入设备：用于输入起始点和迷宫地图。
四、实验步骤1. 设计迷宫地图，初始化二维数组map[10][12]。
2. 输入起始点坐标（行列坐标），判断输入是否合法（越界或起始点在墙中）。
3. 初始化一个空堆栈，用于存储老鼠走过的路径。
4. 使用深度优先搜索算法遍历迷宫，寻找出口：a. 将起始点入栈。
b. 标记当前点为已走过。
c. 判断当前点是否为出口，如果是，则输出路径，结束搜索。
d. 找到当前点的后继点（上下左右），如果后继点合法且未走过，则将其入栈并标记为已走过，继续搜索。
e. 如果当前点没有后继点，则回溯，弹出栈顶元素，尝试下一个方向。
5. 输出最短路径，记录老鼠的运动轨迹。
五、实验结果与分析1. 迷宫地图及起始点：```0 1 1 1 1 1 1 1 1 1 1 11 0 0 0 0 0 0 0 0 0 0 11 0 1 1 1 1 1 1 1 1 1 11 0 1 0 0 0 0 0 0 0 0 11 0 1 1 1 1 1 1 1 1 1 11 0 1 0 0 0 0 0 0 0 0 11 0 1 1 1 1 1 1 1 1 1 11 0 0 0 0 0 0 0 0 0 0 11 1 1 1 1 1 1 1 1 1 1 11 1 1 1 1 1 1 1 1 1 1 1```2. 老鼠起始点坐标：(1, 1)3. 运动轨迹及最短路径：```老鼠运动轨迹：[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (2, 11), (3, 11), (4, 11), (5, 11), (6, 11), (7, 11), (8, 11), (9, 11), (10, 11), (11, 11)]最短路径：[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (2, 11), (3, 11), (4, 11), (5, 11), (6, 11), (7, 11), (8, 11), (9, 11), (10, 11), (11, 11)]```4. 分析：通过实验结果可以看出，老鼠在迷宫中寻找出口的过程主要遵循深度优先搜索策略，即优先探索当前路径的深度，直到找到出口。
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"` 和 `"*"`,其他地方都为空。
电子老鼠闯迷宫问题--已测试
电子老鼠闯迷宫有12×12方格图，找出一条自入口（2，9）到出口（11，8）的最短路径。
本题给出完整的程序和一组测试数据。
状态：老鼠所在的行、列。
程序如下：#include<stdio.h>void readdata(); //读入数据void init(); //初始化int search(); //广搜，并在每一个可到达的每一个空格出填上最小步数int emptyopen(); //判栈是否为空：空：1；非空：0。
int takeoutofopen(); //从栈中取出一个元素，并把该元素从栈中删除int canmoveto(int,int,int*,int*,int); //判能否移动到该方向，并带回坐标(r,c)int isaim(int row, int col); //判断该点是否是目标int used(int,int); //判断该点是否已经走过void addtoopen(int,int); //把该点加入到open表int a[12][12]; //a存放迷宫，0表示空格，-2表示墙。
//广搜时，未找到目标以前到达的空格，填上到达该点的最小步数int n; //n为迷宫边长，注：若大于12，必须修改一些参数，如a的大小int open[20],head,tail,openlen=20; //open表int s,t; //起点和终点int main(){int number;readdata(); //读取数据init(); //初始化number=search(); //广搜并返回最小步数printf("%d",number); //打印结果}int search(){int u, row, col, r, c, i, num;while(!emptyopen()) //当栈非空{u=takeoutofopen(); //从栈中取出一个元素，并把该元素从栈中删除row=u/n; //计算该点的坐标col=u%n;num=a[row][col]; //取得该点的步数for(i=0;i<4;i++){if(canmoveto(row,col,&r,&c,i)) //判能否移动到该方向，并带回坐标(r,c){if(isaim(r,c)) //如果是目标结点return(num+1); //返回最小步数if(!used(r,c)) //如果(r,c)还未到达过{a[r][c]=num+1; //记录该点的最小步数addtoopen(r,c); //把该点加入到open表}}}}}int emptyopen(){if(head==tail)return(1);elsereturn(0);}int takeoutofopen(){int u;if(head==tail){printf("errer: stack is empty");return(-1);}u=open[head++];head=head%openlen;return(u);}int canmoveto(int row, int col, int *p, int *q, int direction){int r,c;r=row;c=col;switch(direction){case 0: c--; //左break;case 1: r++; //下break;case 2: c++; //右break;case 3: r--; //上}*p=r;*q=c;if(r<0||r>=n||c<0||c>=n) //如果越界返回0 return(0);if(a[r][c]==0) //如果是空格返回1 return(1);return(0); //其余情况返回0 }int isaim(int row, int col){if(row*n+col==t)return(1);elsereturn(0);}int used(int row, int col){if(a[row][col]==0) // 0表示空格return(0);elsereturn(1);}void addtoopen(int row, int col){int u;u=row*n+col;open[tail++]= u;tail=tail%openlen;}void readdata(){int i,j,row,col;char str[20];scanf("%d",&n);scanf("%d%d",&row,&col); //起点坐标s=row*n+col;scanf("%d%d",&row,&col); //终点坐标t=row*n+col;gets(str);for(i=0;i<n;i++){gets(str);for(j=0;j<n;j++)if(str[j]=='.')a[i][j]=0; //0表示空格elsea[i][j]=-2; //－2表示墙}}void init(){head=0;tail=1;open[0]=s;}测试数据如下：12 10 7 1 8XXXXXXXXXXXXX......X.XXXX.X.XX (X)X.X.XX.XXX.XX.X.....X..XX.XXXXXXXXXXX...X.X. (X)X.XXX (XXXX)X.....X. (X)XXX.XXXX.X.XXXXXXXX..XXXXXXXXXXXXXXX注：测试数据可在运行时粘贴上去（点击窗口最左上角按钮，在菜单中选则“编辑”/“粘贴”即可）。
C语言迷宫程序
基于栈的C语言迷宫问题与实现一．问题描述多年以来，迷宫问题一直是令人感兴趣的题目.实验心理学家训练老鼠在迷宫中寻找食物.许多神秘主义小说家也曾经把英国乡村花园迷宫作为谋杀现场。
于是，老鼠过迷宫问题就此产生,这是一个很有趣的计算机问题,主要利用“栈”是老鼠通过尝试的办法从入口穿过迷宫走到出口。
迷宫只有两个门，一个叫做入口,另一个叫做出口。
把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫.迷宫中设置很多隔壁，对前进方向形成了多处障碍，在迷宫的唯一出口处放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口。
求解迷宫问题，即找出从入口到出口的路径.一个迷宫可用上图所示方阵[m，n]表示,0表示能通过，1 表示不能通过。
现假设耗子从左上角［1,1]进入迷宫，编写算法，寻求一条从右下角［m，n] 出去的路径。
下图是一个迷宫的示意图：迷宫示意图二．算法基本思想迷宫问题是栈应用的一个典型例子。
求解过程可采用回溯法.回溯法是一种不断试探且及时纠正错误的搜索方法。
从入口出发,按某一方向向前探索，若能走通（未走过的），即某处可以到达，则到达新点，否则试探下一方向；若所有的方向均没有通路，则沿原路返回前一点，换下一个方向再继续试探,直到所有可能的通路都探索到，或找到一条通路，或无路可走又返回到入口点。
在求解过程中，为了保证在到达某一点后不能向前继续行走（无路）时，能正确返回前一点以便继续从下一个方向向前试探，则需要用一个栈保存所能够到达的每一点的下标及从该点前进的方向，栈中保存的就是一条迷宫的通路。
为了确保程序能够终止,调整时，必须保证曾被放弃过的填数序列不被再次试验,即要求按某种有序模型生成填数序列.给解的候选者设定一个被检验的顺序,按这个顺序逐一生成候选者并检验。
三．主要数据结构1.方阵栈：＃define STACK_INI_SIZE 100typedef struct｛int ＊top；//指向栈的顶端域int ＊base; //指向栈的低端域int length; //栈的长度int stacksize; //栈的最大长度｝sqstack；2．产生迷宫的矩阵二维数组为了使每一个迷宫存在迷宫的边界和两个端口：入口、出口，设置了一个二维数组，在迷宫的周边定义为1，使得迷宫存在边界，并在（1，1）,（x—2,y—2）初定义为0,即定义迷宫的出口,大大减小了无解的情况。
电脑鼠走迷宫算法C语言
电脑鼠走迷宫算法C语言#include "stdio.h"#include "action.h"#include "bmp_pixel.h"#include "NOKIA_5110.h"#include "configuration.h"void Stop_On_Going(){Wheel_Control(LEFT,WHEEL_FRONT,255); Wheel_Control(RIGHT,WHEEL_FRONT,255); delay_ms(20);}void Turn_Left(){Stop_On_Going();Wheel_Control(LEFT,WHEEL_BACK,80); Wheel_Control(RIGHT,WHEEL_FRONT,80); delay_ms(20);}void Go_straight() //直走的具体实现{Wheel_Control(LEFT,WHEEL_FRONT,80);Wheel_Control(RIGHT,WHEEL_FRONT,80); delay_ms(20);}void Turn_Right() //右转的具体实现{Stop_On_Going();Wheel_Control(LEFT,WHEEL_FRONT,80); Wheel_Control(RIGHT,WHEEL_BACK,80); delay_ms(20);}void Turn_back() //调头的具体实现{Wheel_Control(LEFT,WHEEL_FRONT,80); Wheel_Control(RIGHT,WHEEL_BACK,80); delay_ms(20);}void Left_Adjust() //左偏后向右微调的具体实现{Wheel_Control(LEFT,WHEEL_FRONT,80); Wheel_Control(RIGHT,WHEEL_FRONT,70); delay_ms(10);}void Right_Adjust() //右偏后向左微调的具体实现{Wheel_Control(LEFT,WHEEL_FRONT,70);Wheel_Control(RIGHT,WHEEL_FRONT,80);delay_ms(10);}void main(){u16 mode ;u8 sensor ;u8 i=180,count=0,dir=0,pn =0,dis[20];u16 l_count,r_count;//功能模块初始化// GPIO_config(); //STC15W4K32S4 PWM复用口由高阻初始化为双向口EXTI_config(); //外部中断测速Timer_config(); //定时器PCA_config(); //PWMUART_config(); //串口ADC_config(); //AD 电压检测//液晶屏初始化LCD_init();LCD_clear();LCD_draw_bmp_pixel(15,0,BMP,48,56);delay_ms(250);delay_ms(250);delay_ms(250);delay_ms(250);LCD_clear();LCD_write_english_string(2,0," Welcome To "); LCD_write_english_string(2,1," S W J T U "); LCD_write_english_string(2,2," DNS VER 2.1 "); LCD_write_english_string(2,3,"Nokia5110 LCD "); LCD_write_chinese_string(1,4,12,6,0,2);//wait for the start key downwhile(Start_Key); /////// 延时启动（start按键按下，等待n秒后启动）delay_ms(250);delay_ms(250);delay_ms(250);delay_ms(250);delay_ms(250);delay_ms(250);delay_ms(250);delay_ms(250);delay_ms(250);delay_ms(250);delay_ms(250);delay_ms(250);LCD_clear();//开总中断SET_EA();while(1){Go_straight(); //测试直走}while(1){while(1){Go_straight();}while(1){sensor = P1&0xf8;switch(sensor){case 0x18 : mode = 1; break; ////00011000 左转case 0xd8 : mode = 2; break; ////11011000 直走case 0xc0 : mode = 3; break; ////11000000 左转case 0x00 : mode = 4; break; ////00000000 掉头case 0x98 : mode = 10; break; ////10011000 稍微偏左，后续调整case 0xc8 : mode = 11; break; ////11001000 稍微偏右，后续调整default : mode = 2; break; ////其他情况，执行直走}switch(mode){case 1 : Turn_Left(); break;case 2 : Go_straight(); break;case 3 : Turn_Right(); break;case 4 : Turn_back(); break;case 10 : Left_Adjust(); break;case 11 : Right_Adjust(); break;default : Turn_Right(); break;}}/* 以下是电脑鼠功能模块测试程序，方便测试各个模块功能是否正常，测试完毕后可注释掉或者删除 */if(timer0_flag){timer0_flag = 0;count ++;}if(count == 10){count = 0;l_count = left_count;r_count = right_count;left_count = 0;right_count = 0;// 电机控制测试加速->减速->反转->加速->减速...如此循环if(i<180){dir = !dir;pn = 1;}if(i>254)pn = 0;if(pn) i++;else i--;Wheel_Control(LEFT,dir,255-i);Wheel_Control(RIGHT,dir,255-i);// PWM 显示sprintf(dis,"PWM :%d %3.0f%%",(int)i,(float)i/255*100);LCD_write_english_string(0,0,dis);// 电机供电电池电压显示sprintf(dis,"Vmotor:%.1fV",(float)(4.98/Get_ADC10bitResult( 0)*Get_ADC10bitResult(1)));LCD_write_english_string(0,2,dis);// 单片机供电电池电压显示sprintf(dis,"Vmcu :%.1fV",(float)(4.98/Get_ADC10bitResult(0) *Get_ADC10bitResult(2)));LCD_write_english_string(0,3,dis);// 中断测速sprintf(dis,"L:%d",(int)l_count);LCD_write_english_string(0,4,dis);sprintf(dis,"R:%d",(int)r_count);LCD_write_english_string(40,4,dis);}}/* 以上是电脑鼠功能模块测试程序，方便测试各个模块功能是否正常，测试完毕后可注释掉或者删除 */}。
C++实现简单迷宫游戏
C++实现简单迷宫游戏本⽂实例为⼤家分享了C++实现简单迷宫游戏的具体代码，供⼤家参考，具体内容如下问题描述程序开始运⾏时显⽰⼀个迷宫地图，迷宫中央有⼀只⽼⿏，迷宫的右下⽅有⼀个粮仓。
游戏的任务是使⽤键盘上的⽅向健操纵⽼⿏在规定的时间内⾛到粮仓处。
基本要求（1）⽼⿏形象可以辨认，可⽤键盘操纵⽼⿏上下左右移动；（2）迷宫的墙⾜够结实，⽼⿏不能穿墙⽽过；（3）正确检测结果，若⽼⿏在规定时间内⾛到粮仓处，提⽰成功，并给出⼀条路径，否则提⽰失败；（4）添加编辑迷宫功能，可修改当前迷宫，修改内容：墙变路、路变墙；提⾼要求（1）增加闯关和计分功能；（2）找出⾛出迷宫的所有路径及最短路径。
源代码1.⽂件main.cpp#include<iostream>#include"maze.h"//⾃定义的头⽂件，存放类声明和常量#include<cstdlib>//各种函数头⽂件，如rand函数#include<time.h>//⽇期和时间的头⽂件#include<stdio.h>//标准输⼊输出#include<Windows.h>//图形界⾯设计头⽂件#include<conio.h>//获取⽅向键的头⽂件using namespace std;void MainMenu();//显⽰游戏菜单函数void MeunGame(int num);//显⽰不同关卡函数void Introduce();//游戏介绍int main(){Maze maze_1(11, 11), maze_2(13, 13), maze_3(15, 15), maze_4(17, 17);//定义四个关卡int i = 0, choice = 0, choice_2, choice_3;char isexit = ' ', choice_1 = ' ';bool Go_on = false, judge[4] = { false };cout << "\n\t欢迎试玩憨憨⽼⿏⾛迷宫游戏";for (i = 0;i < 4;i++){Sleep(500);cout << "·";}system("cls");Introduce();//游戏介绍system("cls");MainMenu();//显⽰游戏菜单cout << "\n\t请输⼊选择:（1~4）";cin >> choice;while (1){switch (choice){case 1:for (i = 1;i <= 4;i++){if (i == 1){MeunGame(i);//显⽰关卡菜单system("cls");maze_1.Show_Map();judge[0] = maze_1.Move();if (judge[0] == true){cout << "憨憨⿏所⾛过的路径";maze_1.KeepMap();cout << "是否继续闯关:(Y|N)" << endl;cin >> choice_1;if (choice_1 == 'y' || choice_1 == 'Y'){Go_on = true;}else if (choice_1 == 'n' || choice_1 == 'N'){Go_on = false;}}else{system("pause");break;}}else if (i == 2){MeunGame(i);system("cls");maze_2.Show_Map();judge[1] = maze_2.Move();if (judge[1] == true){cout << "憨憨⿏所⾛过的路径";maze_2.KeepMap();cout << "是否继续闯关:(Y|N)" << endl;cin >> choice_1;if (choice_1 == 'y' || choice_1 == 'Y'){Go_on = true;}else if (choice_1 == 'n' || choice_1 == 'N'){Go_on = false;}}else{system("pause");break;}}else if (i == 3){MeunGame(i);system("cls");maze_3.Show_Map();judge[2] = maze_3.Move();if (judge[2] == true){cout << "憨憨⿏所⾛过的路径";maze_3.KeepMap();cout << "是否继续闯关:(Y|N)" << endl;cin >> choice_1;if (choice_1 == 'y' || choice_1 == 'Y'){Go_on = true;}else if (choice_1 == 'n' || choice_1 == 'N'){Go_on = false;}}else{system("pause");break;}}else if (i == 4){MeunGame(i);system("cls");maze_4.Show_Map();judge[3] = maze_4.Move();if (judge[3] == true){cout << "憨憨⿏所⾛过的路径";maze_4.KeepMap();system("pause");system("cls");cout << "\t★太棒了，恭喜你通过全部关卡★" << endl; cout << "\t 是否退出游戏？(Y|N)" << endl;cin >> choice_1;if (choice_1 == 'y' || choice_1 == 'Y'){return 0;}else if (choice_1 == 'n' || choice_1 == 'N'){Go_on = false;}}else{system("pause");break;}}if (Go_on == false){break;}}break;case 2:system("cls");cout << "请你输⼊要编辑的关卡:" << endl;cout << "1.第⼀关" << endl;cout << "2.第⼆关" << endl;cout << "3.第三关" << endl;cout << "4.第四关" << endl;cin >> choice_2;if (choice_2 == 1 && judge[0] == true){maze_1.EdidMap();}else if (choice_2 == 2 && judge[1] == true){maze_2.EdidMap();}else if (choice_2 == 3 && judge[2] == true){maze_3.EdidMap();}else if (choice_2 == 4 && judge[3] == true){maze_4.EdidMap();}else{cout << "此关卡未通过，不能编译此关！" << endl;system("pause");}break;case 3:system("cls");cout << "请你输⼊要查看的关卡" << endl;cout << "1.第⼀关" << endl;cout << "2.第⼆关" << endl;cout << "3.第三关" << endl;cout << "4.第四关" << endl;cin >> choice_3;if (choice_3 == 1 && judge[0] == true){maze_1.Short();}else if (choice_3 == 2 && judge[1] == true){maze_2.Short();}else if (choice_3 == 3 && judge[2] == true){maze_3.Short();}else if (choice_3 == 4 && judge[3] == true){maze_4.Short();}else{cout << "此关卡未通过，不能查看此关！" << endl;system("pause");}break;case 4:system("cls");cout << "\n\n\t\t是否确定退出游戏？(Y|N)";cin >> isexit;if (isexit == 'Y' || isexit == 'y'){return 0;}else if (isexit == 'N' || isexit == 'n'){break;}default:cout << "\n\t输⼊选择选择⽆效，请从新输⼊:";Sleep(500);break;}system("cls");MainMenu();cout << "\n\t请输⼊输⼊选择:（1~4）";cin >> choice;}}void MainMenu()//游戏菜单函数{cout << "\n\t\t**************************************************************" << endl;cout << "\t\t* *" << endl;cout << "\t\t* *⽼⿏⾛迷宫游戏* *" << endl;cout << "\t\t* *" << endl;cout << "\t\t* 1.开始游戏 *" << endl;cout << "\t\t* *" << endl;cout << "\t\t* 2.编辑地图 *" << endl;cout << "\t\t* *" << endl;cout << "\t\t* 3.破解地图 *" << endl;cout << "\t\t* *" << endl;cout << "\t\t* 4.退出游戏 *" << endl;cout << "\t\t* *" << endl;cout << "\t\t* *" << endl;cout << "\t\t**************************************************************" << endl;}void MeunGame(int num)//关卡菜单{system("cls");cout << "\n\t\t**************************************************************" << endl;cout << "\t\t* *" << endl;cout << "\t\t* ◤第" << num << "关◢ *" << endl;cout << "\t\t* *" << endl;cout << "\t\t**************************************************************" << endl;system("pause");}void Introduce()//游戏介绍{cout << "\n\t\t********************************************************************" << endl;cout << "\t\t* *" << endl;cout << "\t\t* *⽼⿏⾛迷宫游戏介绍* *" << endl;cout << "\t\t* *" << endl;cout << "\t\t* 1.玩家可通过⽅向键↑↓←→控制⽼⿏移动 *" << endl;cout << "\t\t* *" << endl;cout << "\t\t* 2.在选择编辑地图时，玩家通过WASD编辑 *" << endl;cout << "\t\t* *" << endl;cout << "\t\t* 3.在选择破解地图时，会给出坐标路线，原点为迷宫左上⾓ *" << endl; cout << "\t\t* *" << endl;cout << "\t\t* 4.在规定时间内⾛到粮仓算过关，时间越短所获积分越多 *" << endl; cout << "\t\t* *" << endl;cout << "\t\t********************************************************************" << endl;system("pause");}2.maze.cpp⽂件#include<iostream>#include"maze.h"//⾃定义的头⽂件，存放类声明和常量#include<cstdlib>//各种函数头⽂件，如rand函数#include<time.h>//⽇期和时间的头⽂件#include<stdio.h>//标准输⼊输出#include<Windows.h>//图形界⾯设计头⽂件#include<conio.h>//获取⽅向键的头⽂件using namespace std;Maze::Maze(int l, int w)//构造函数初始化地图和成员变量{int i, j;Map_Length = l, Map_Width = w;for (i = 0;i <= Map_Length;i++){for (j = 0;j <= Map_Width;j++){if (i == 0 || j == 0){Map[i][j] = road;}else{Map[i][j] = wall;//默认地图中都是墙}}}for (i = 0;i < Map_Length;i++){for (j = 0;j < Map_Width;j++){Visited[i][j] = 0;}}front = rear = -1;top = -1;}void Maze::CreateMap(int x, int y)//创建地图{int Direction[4][2] = { {1,0}, {0,1}, {0,-1}, {-1,0} };//定义四个⽅向int i, j, temp;for (i = 0;i < 4;i++)//打乱四个⽅向{j = rand() % 4;temp = Direction[i][0];Direction[i][0] = Direction[j][0];Direction[j][0] = temp;temp = Direction[i][1];Direction[i][1] = Direction[j][1];Direction[j][1] = temp;}Map[x][y] = road;//选取[x][y]为路for (i = 0;i < 4;i++){if (Map[x + 2 * Direction[i][0]][y + 2 * Direction[i][1]] == wall)//任意两点之间有路{Map[x + Direction[i][0]][y + Direction[i][1]] = road;CreateMap(x + 2 * Direction[i][0], y + 2 * Direction[i][1]);}}}void Maze::Show_Map()//显⽰地图{//srand((unsigned)time(NULL));//种随机粒⼦CreateMap(2 * (rand() % (Map_Length / 2 + 1)), 2 * (rand() % (Map_Width / 2 + 1)));//随机选取x,y坐标 Map[Map_Length / 2][Map_Width / 2] = Mouse;//定义⽼⿏的位置Map[Map_Length - 1][Map_Width - 1] = End;//定义粮仓的位置Display();}void Maze::Display()//查看地图{int i, j;for (i = 0;i <= Map_Length;i++){for (j = 0;j <= Map_Width;j++){if (Map[i][j] == road){cout << " ";}else if (Map[i][j] == wall){cout << "■";}else if (Map[i][j] == Mouse){cout << "♂";}else if (Map[i][j] == End){cout << "★";}else if (Map[i][j] == visited){cout << " ";}}cout << endl;}}void Maze::KeepMap()//显⽰⽼⿏⾛过的路径{int i, j;for (i = 0;i <= Map_Length;i++){for (j = 0;j <= Map_Width;j++){if (Map[i][j] == road){cout << " ";}else if (Map[i][j] == wall){cout << "■";}else if (Map[i][j] == Mouse){cout << "♂";}else if (Map[i][j] == End){cout << "★";}else if (Map[i][j] == visited){cout << "×";}}cout << endl;}}bool Maze::Move()//⽼⿏移动{int count = 30, m = 0, n = 0;bool temp = false;char Enter = ' ';int t = time(NULL);//获取系统时间pos_x = Map_Length / 2, pos_y = Map_Width / 2;//⽼⿏的初始位置while (count >= 0){if (_kbhit() == 0){if (t != time(NULL)){system("cls");Display();count--;cout << "|---剩余时间：" << count << "---|";if (count == 0){system("cls");cout << "闯关失败" << endl;temp = false;}t = time(NULL);//获取当前时间}}if (_kbhit() != 0){system("cls");Enter = _getch();if (Enter == -32)//*****键盘事件*****Up();Display();break;case 80://downDowm();Display();break;case 75://leftLeft();Display();break;case 77://rightRight();Display();break;default:break;}}if (Map[Map_Length - 1][Map_Width - 1] != End){system("cls");cout << "★恭喜你闯关成功★" << endl;Map[pos_x][pos_y] = visited;cout << "★获得" << count << "点积分★" << endl;temp = true;break;}}}return temp;}void Maze::Up()//⽼⿏向上移动{if (pos_y <= 0){return;}else if (Map[pos_x - 1][pos_y] != wall){Map[pos_x][pos_y] = visited;pos_x--;Map[pos_x][pos_y] = Mouse;}}void Maze::Dowm()//⽼⿏向下移动{if (pos_y > Map_Width - 1){return;}else if (Map[pos_x + 1][pos_y] != wall){Map[pos_x][pos_y] = visited;pos_x++;Map[pos_x][pos_y] = Mouse;}}void Maze::Left()//⽼⿏向左移动{if (pos_x <= 0){return;}else if (Map[pos_x][pos_y - 1] != wall){Map[pos_x][pos_y] = visited;pos_y--;Map[pos_x][pos_y] = Mouse;}}void Maze::Right()//⽼⿏向右移动{if (pos_x > Map_Width - 1){return;}else if (Map[pos_x][pos_y + 1] != wall){Map[pos_x][pos_y] = visited;pos_y++;Map[pos_x][pos_y] = Mouse;}}void Maze::EdidMap()//编辑地图{system("cls");char Enter = ' ';bool isKeep = false;pos_x = Map_Length / 2, pos_y = Map_Width / 2;//确定⽼⿏坐标 Map[pos_x][pos_y] = Mouse;while (1){Display();Enter = _getch();if (Enter == -32)//*****键盘事件*****{switch (_getch()){case 72://upUp();break;case 80://downDowm();break;case 75://leftLeft();break;case 77://rightRight();break;default:break;}if (Map[pos_x - 1][pos_y] == wall){Map[pos_x - 1][pos_y] = road;}else if (Map[pos_x - 1][pos_y] == road || Map[pos_x - 1][pos_y] == visited) {Map[pos_x - 1][pos_y] = wall;}break;case 97://A键if (Map[pos_x][pos_y - 1] == wall){Map[pos_x][pos_y - 1] = road;}else if (Map[pos_x][pos_y - 1] == road || Map[pos_x][pos_y - 1] == visited) {Map[pos_x][pos_y - 1] = wall;}break;case 115://S键if (Map[pos_x + 1][pos_y] == wall){Map[pos_x + 1][pos_y] = road;}else if (Map[pos_x + 1][pos_y] == road || Map[pos_x + 1][pos_y] == visited) {Map[pos_x + 1][pos_y] = wall;}break;case 100://D键if (Map[pos_x][pos_y + 1] == wall){Map[pos_x][pos_y + 1] = road;}else if (Map[pos_x][pos_y + 1] == road || Map[pos_x][pos_y + 1] == visited) {Map[pos_x][pos_y + 1] = wall;}break;case 0x0D://回车system("cls");Map[pos_x][pos_y] = road;cout << "*****保存成功*****" << endl;isKeep = true;system("pause");break;default:break;}if (isKeep == true){for (int i = 0;i < Map_Length;i++){for (int j = 0;j < Map_Width;j++){if (Map[i][j] == visited){Map[i][j] = road;}}}break;}system("cls");}}void Maze::Short(){rear = front = -1;int i, j;for (i = 1;i <= Map_Length;i++){for (j = 1;j <= Map_Width;j++){if (Map[i][j] == visited){Map[i][j] = road;//被访问的变成路}}}for (i = 0;i <= Map_Length;i++){for (j = 0;j <= Map_Width;j++){Visited[i][j] = 0;}}Show_Map();//显⽰地图system("cls");int m = Map_Length - 1, n = Map_Width - 1;SmallRoadDisplay(m, n);//找最短路径while (top != -1){top--;}}void Maze::SmallRoadDisplay(int x, int y)//最短路径{bool flag = false;Visited[x - 1][y - 1] = 1;Map[x][y] = End;int i = 0, j = 0, k = 0;int Direction[4][2] = { {1,0}, {0,1}, {0,-1}, {-1,0} };//定义四个⽅向int arr[100] = { 0 };//存放x坐标的队列int brr[100] = { 0 };//存放y坐标的队列int record_x[100] = { 0 };//存放x坐标的栈int record_y[100] = { 0 };//存放y坐标的栈front = rear = -1;rear++;arr[rear] = x;//当前x坐标⼊队brr[rear] = y;//当前y坐标⼊队while (front != rear){front++;for (i = 0;i < 4;i++)if ((Map[arr[front] + Direction[i][0]][brr[front] + Direction[i][1]] == road || Map[arr[front] + Direction[i][0]][brr[front] + Direction[i][1]] == Mouse || Map[arr[front] + Direction[i][0]][brr[front] + Direction[i][1]] == visited) && Visited[arr[front] + Direction[i][0]][brr[front] + Di {rear++;arr[rear] = arr[front] + Direction[i][0];brr[rear] = brr[front] + Direction[i][1];Visited[arr[front] + Direction[i][0]][brr[front] + Direction[i][1]] = 1;if (arr[rear] == (Map_Length / 2) && brr[rear] == (Map_Width / 2)){flag = true;break;}}}if (flag == true){break;}}front = rear + 1;rear = 0;top = -1;top++;record_x[top] = arr[front - 1];record_y[top] = brr[front - 1];while (rear != front){front--;for (j = 0;j < 4;j++){if (record_x[top] + Direction[j][0] == arr[front - 1] && record_y[top] + Direction[j][1] == brr[front - 1]){top++;record_x[top] = arr[front - 1];record_y[top] = brr[front - 1];}}}Display();cout << "最短路径如下:" << endl;cout << "⿏" << "->";for (i = 0;i <= top;i++){cout << "(" << record_x[i] << "," << record_y[i] << ")" << "->";}cout << "仓" << endl;system("pause");}3.maze.h⽂件#ifndef MAZE_H#define MAZE_Hconst int MaxSize = 100;const int road = 0;//路const int wall = 1;//墙const int Mouse = 2;//⽼⿏const int End = 3;//终点const int visited = 4;//被访问的路径const int MaxSmall = 5;//最短路径class Maze{private:int pos_x, pos_y;//主⾓⽼⿏的坐标int Map_Length, Map_Width;//地图的长宽int Visited[MaxSize][MaxSize];//是否被访问数组int rear, front;int top;public:Maze(int l, int w);//构造函数int Map[MaxSize][MaxSize];//地图数组void CreateMap(int, int);//创建地图void Show_Map();//显⽰地图void Display();//查看地图void KeepMap();//显⽰⽼⿏⾛过的路径bool Move();//⽼⿏移动void Up();//⽼⿏向上移动void Dowm();//⽼⿏向下移动void Right();//⽼⿏向右移动void Left();//⽼⿏向左移动void EdidMap();//编辑地图void Short();void SmallRoadDisplay(int x, int y);//最短路径};#endif#pragma once版本提⽰所⽤开发版本为vs2019版，版本不同编译可能存在错误。
老鼠闯迷宫
用栈的方法设计迷宫求解（c语言）题目：可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出；最好有注释、储结构、基本算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法；问题补充：在vc下运行以下为源代码和部分注释，可以运行#include<stdio.h>#include<stdlib.h>#define M 15#define N 15struct mark //定义迷宫内点的坐标类型{int x;int y;};struct Element //"恋"栈元素，嘿嘿。
{int x,y; //x行,y列int d; //d下一步的方向};typedef struct LStack //链栈{Element elem;struct LStack *next;}*PLStack;/*************栈函数****************/int InitStack(PLStack &S)//构造空栈{S=NULL;return 1;}int StackEmpty(PLStack S)//判断栈是否为空{if(S==NULL)return 1;elsereturn 0;}int Push(PLStack &S, Element e)//压入新数据元素{PLStack p;p=(PLStack)malloc(sizeof(LStack));p->elem=e;p->next=S;S=p;return 1;}int Pop(PLStack &S,Element &e) //栈顶元素出栈{PLStack p;if(!StackEmpty(S)){e=S->elem;p=S;S=S->next;free(p);return 1;}elsereturn 0;}/***************求迷宫路径函数***********************/void MazePath(struct mark start,struct mark end,int maze[M][N],int diradd[4][2]){int i,j,d;int a,b;Element elem,e;PLStack S1, S2;InitStack(S1);InitStack(S2);maze[start.x][start.y]=2; //入口点作上标记elem.x=start.x;elem.y=start.y;elem.d=-1; //开始为-1Push(S1,elem);while(!StackEmpty(S1)) //栈不为空有路径可走{Pop(S1,elem);i=elem.x;j=elem.y;d=elem.d+1; //下一个方向while(d<4) //试探东南西北各个方向{a=i+diradd[d][0];b=j+diradd[d][1];if(a==end.x && b==end.y && maze[a][b]==0) //如果到了出口{elem.x=i;elem.y=j;elem.d=d;Push(S1,elem);elem.x=a;elem.y=b;elem.d=886; //方向输出为-1 判断是否到了出口Push(S1,elem);printf("\n0=东 1=南 2=西 3=北 886为则走出迷宫\n\n通路为:(行坐标,列坐标,方向)\n");while(S1) //逆置序列并输出迷宫路径序列{Pop(S1,e);Push(S2,e);}while(S2){Pop(S2,e);printf("-->(%d,%d,%d)",e.x,e.y,e.d);}return; //跳出两层循环，本来用break,但发现出错，exit又会结束程序，选用return还是不错滴o(∩_∩)o...}if(maze[a][b]==0) //找到可以前进的非出口的点{maze[a][b]=2; //标记走过此点elem.x=i;elem.y=j;elem.d=d;Push(S1,elem); //当前位置入栈i=a; //下一点转化为当前点j=b;d=-1;}d++;}}printf("没有找到可以走出此迷宫的路径\n");}/*************建立迷宫*******************/void initmaze(int maze[M][N]){int i,j;int m,n; //迷宫行,列printf("请输入迷宫的行数 m=");scanf("%d",&m);printf("请输入迷宫的列数 n=");scanf("%d",&n);printf("\n请输入迷宫的各行各列:\n用空格隔开,0代表路,1代表墙\n",m,n); for(i=1;i<=m;i++)for(j=1;j<=n;j++)scanf("%d",&maze[i][j]);printf("你建立的迷宫为o(∩_∩)o...\n");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++)printf("%d ",maze[i][j]);printf("\n");}}void main(){int sto[M][N];struct mark start,end; //start,end入口和出口的坐标int add[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//行增量和列增量方向依次为东西南北initmaze(sto);//建立迷宫printf("输入入口的横坐标,纵坐标[逗号隔开]\n");scanf("%d,%d",&start.x,&start.y);printf("输入出口的横坐标,纵坐标[逗号隔开]\n");scanf("%d,%d",&end.x,&end.y);MazePath(start,end,sto,add); //find pathsystem("PAUSE");}。
迷宫(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语言迷宫代码
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```当然，上述代码只是生成了一个简单的迷宫，还没有解决迷宫问题。
(完整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.1 设计要求走迷宫：绘制和选择迷宫地图，系统能够自动寻找出口，支持鼠标和键盘操作。
通过画图函数设定迷宫，运用数据结构的相关知识，利用一定的算法，实现单步找寻迷宫出口的操作。
1.2 实现功能小游戏，游戏者从左侧入口处走到右侧的出口处，则胜；中途退出，则败。
二整体设计2.1框架设计1.定义操作键键码，用#define实现。
2.系统BGI初始化模块：3.画出迷宫模块：其中包括边框、出口、入口、墙壁等相关信息；用函数drawmaze()实现此操作。
4.定义迷宫中的人模块：用函数move()实现此操作。
实现点的移动，并判断是否到达出口。
5.退出系统模块：用if函数进行判断，如胜则输出-You win,如败则输出you lose.用函数getch()查看结果。
三详细设计3.1界面设计此游戏界面采用图形设计。
主界面设计如下：图1 走迷宫图3.2结构设计：用if语句实现人的坐标移动和判断游戏者输赢。
四总结参考文献暂无附录#include<stdlib.h>#include<graphics.h>/*定义操作键键码*/#define UP 0x4800/*上移--方向键up*/#define DOWN 0x5000/*下移--方向键down*/#define LEFT 0x4b00/*左移--方向键left*/#define RIGHT 0x4d00/*右移--方向键right*/#define ESC 0x011b#define midx getmaxx()/2#define midy getmaxy()/2河北大学电子信息工程学院2008级C程序设计课程设计报告void initgr(void) /* BGI初始化*/{int gd = DETECT, gm = 0; /* 和gd = VGA,gm = VGAHI是同样效果*/registerbgidriver(EGA VGA_driver);/* 注册BGI驱动后可以不需要.BGI文件的支持运行*/initgraph(&gd, &gm, "");}void drawmaze()/* 画出迷宫*/{rectangle(midx-200,midy-200,midx+200,midy+200);/* 画出边框*/setcolor(BLACK);line(midx-200,200,midx-200,226);/* 画出迷宫入口*/line(midx+200,300,midx+200,326);/* 画出迷宫出口*/setcolor(WHITE);line(midx-150,midy-200,midx-150,midy-150);/* 画出迷宫内的墙壁*/line(midx-150,midy-150,midx-170,midy-150);line(midx-170,midy-150,midx-170,midy-100);line(midx-170,midy-75,midx-170,midy+170);line(midx-170,midy+170,midx+100,midy+170);line(midx+120,midy+170,midx+170,midy+170);line(midx+120,midy+170,midx+120,midy+30);line(midx+120,midy,midx+120,midy-50);line(midx+120,midy-50,midx+70,midy-50);line(midx+100,midy+170,midx+100,midy+80);line(midx+70,midy+170,midx+70,midy-200);line(midx,midy+170,midx,midy);line(midx,midy-30,midx,midy-130);line(midx,midy-130,midx-50,midy-130);line(midx-50,midy-130,midx-50,midy-200);line(midx-170,midy+30,midx-100,midy+30);line(midx-70,midy+30,midx,midy+30);line(midx-100,midy+30,midx-100,midy+100);第 3 页共 6 页line(midx-100,midy+130,midx-100,midy+170);line(midx-130,midy+30,midx-130,midy+150);line(midx-110,midy-200,midx-110,midy-50);line(midx-110,midy-50,midx-50,midy-50);line(midx-50,midy-50,midx-50,midy+30);line(midx-170,midy,midx-65,midy);line(midx+150,midy-200,midx+150,midy+170);}void move(){int yes=1;/* 循环的条件*/int x,y;/* 点的坐标，点相当于迷宫中的人*/int key;x=midx-200;y=214;putpixel(x,y,WHITE);while(yes)/* 实现点的重复移动*/{key=bioskey(0);if(key==UP)/* 如果键入上键，位置上移*/{putpixel(x,y,BLACK);y-=5;if(getpixel(x,y)==WHITE)/* 如果改变后的坐标是墙壁，将坐标回到原先的位置，点不会移动*/ y+=5; /* 如果不是墙壁，实现点的移动*/putpixel(x,y,WHITE);/* 在坐标处画点*/}if(key==DOWN)/* 如果键入下键，位置下移?*/{河北大学电子信息工程学院2008级C程序设计课程设计报告putpixel(x,y,BLACK);y+=5;if(getpixel(x,y)==WHITE)y-=5;putpixel(x,y,WHITE);}if(key==LEFT)/* 如果键入左键，位置左移*/{putpixel(x,y,BLACK);x-=5;if(getpixel(x,y)==WHITE)x+=5;putpixel(x,y,WHITE);}if(key==RIGHT)/* 如果键入上键，位置上移*/{putpixel(x,y,BLACK);x+=5;if(getpixel(x,y)==WHITE)x-=5;putpixel(x,y,WHITE);}if(key==ESC){cleardevice();setcolor(WHITE);settextstyle(0,0,3);outtextxy(midx-100,midy,"You lose!");sleep(2);yes=0;}if(x==midx+200&&y>300&&y<326)/* 判断是否到出口位置*/{sleep(1);cleardevice();第 5 页共 6 页setcolor(WHITE);settextstyle(0,0,3);outtextxy(midx-100,midy,"You win!");/* 找到出口位置，输出文本“You win!”*/ setcolor(GREEN);settextstyle(0,0,1);outtextxy(400,400,"Designed by");outtextxy(500,430,"Jianing");outtextxy(500,460,"Jiqiaoyao");sleep(2);yes=0;}}}int main(void){initgr(); /* BGI初始化*/drawmaze();move();getch(); /* 暂停一下，看看前面绘图代码的运行结果*/closegraph(); /* 恢复TEXT屏幕模式*/return 0;}。
c语言实现迷宫问题
数据结构试验——迷宫问题（一）基本问题1.问题描述这是心理学中的一个经典问题。
心理学家把一只老鼠从一个无顶盖的大盒子的入口处放入，让老鼠自行找到出口出来。
迷宫中设置很多障碍阻止老鼠前行，迷宫唯一的出口处放有一块奶酪，吸引老鼠找到出口。
简而言之，迷宫问题是解决从布置了许多障碍的通道中寻找出路的问题。
本题设置的迷宫如图1所示。
入口出口图1 迷宫示意图迷宫四周设为墙；无填充处，为可通处。
设每个点有四个可通方向，分别为东、南、西、北(为了清晰，以下称“上下左右”)。
左上角为入口。
右下角为出口。
迷宫有一个入口，一个出口。
设计程序求解迷宫的一条通路。
2.数据结构设计以一个m×n的数组mg表示迷宫，每个元素表示一个方块状态，数组元素0和1分别表示迷宫中的通路和障碍。
迷宫四周为墙，对应的迷宫数组的边界元素均为1。
根据题目中的数据，设置一个数组mg如下int mg[M+2][N+2]={{1,1,1,1,1,1,1,1},{1,0,0,1,0,0,0,1},{1,1,0,0,0,1,1,1},{1,0,0,1,0,0,0,1},{1,0,0,0,0,0,0,1},{1,1,1,1,1,1,1,1}};在算法中用到的栈采用顺序存储结构，将栈定义为Struct{ int i; //当前方块的行号int j; //当前方块的列号int di; //di是下一个相邻的可走的方位号}st[MaxSize];// 定义栈int top=-1 //初始化栈3设计运算算法要寻找一条通过迷宫的路径，就必须进行试探性搜索，只要有路可走就前进一步，无路可进，换一个方向进行尝试；当所有方向均不可走时，则沿原路退回一步（称为回溯），重新选择未走过可走的路，如此继续，直至到达出口或返回入口（没有通路）。
在探索前进路径时，需要将搜索的踪迹记录下来，以便走不通时，可沿原路返回到前一个点换一个方向再进行新的探索。
后退的尝试路径与前进路径正好相反，因此可以借用一个栈来记录前进路径。
基于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语⾔-⽼⿏⾛迷宫逐步理解c语⾔实现⽼⿏⾛迷宫在没有智能⼿机的时代，不少⼈玩游戏会玩⽼⿏⾛迷宫这样的闯关游戏。
每⼀关有着不同的地图场景，可能还会充斥着各种障碍。
⽼⿏⾛迷宫是经典的递回求解的算法题我们⽤⼆维数组表⽰迷宫场景。
其中⽤2代表迷宫的墙壁，0代表可⾏通道。
我们⽤7*7的⼆维数组具体实现，假定我们设置[1][1]是迷宫⼊⼝，[5][5]是迷宫出⼝。
#define M 7int maze[M][M] ={{2,2,2,2,2,2,2},{2,0,0,0,0,0,2},{2,0,2,0,2,0,2},{2,0,0,2,0,2,2},{2,2,0,2,0,2,2},{2,0,0,0,0,0,2},{2,2,2,2,2,2,2}};int start1=1,start2=1;int end1=5,end2=5;int main (){int i,j;printf("显⽰迷宫：\n");for(i=0;i<M;i++) //对摆放的数组迷宫进⾏打印{for(j=0;j<M;j++)if(maze[i][j] == 2)printf("◾");elseprintf(" ");printf("\n");}}这样我们的迷宫绘制基本完成。
下⾯我们对⽼⿏可能⾏⾛的路径进⾏分析输出。
我们定义⼀个visit函数，对⽼⿏⾏⾛⽅向进⾏逻辑分析。
我们把⽼⿏⾛的路径记作1，也就是数组中的0被改为1 。
int success = 0; //声明全局变量，若到达出⼝，将被赋值为1int visit(int i,int j){maze[i][j] = 1; //传过来的位置⼀定是⽼⿏所⾏路径，赋值为1if(i==end1 && j==end2) //判断是否到达[5][5]出⼝位置success = 1;//判断是否到达出⼝，没有则分析⽼⿏可以在迷宫移动的⽅向，并递归求下⼀步.if(success != 1 && maze[i][j+1] == 0) //⽼⿏先尝试向右，如果可⾏就递归，不⾏则往下判定visit(i,j+1);if(success != 1 && maze[i+1][j] == 0) //⽼⿏尝试向下，如果可⾏就递归，不⾏则往下判定visit(i+1,j);if(success != 1 && maze[i][j-1] == 0) //⽼⿏尝试向左，如果可⾏就递归，不⾏则往下判定visit(i,j-1);if(success != 1 && maze[i-1][j] == 0) //最后⼀歩⽅向判定，⽼⿏尝试向上，如果可⾏就递归。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include "stdio.h"
#include "action.h"
#include "bmp_pixel.h"
#include "NOKIA_5110.h"
#include "configuration.h"
void Stop_On_Going()
{
Wheel_Control(LEFT,WHEEL_FRONT,255);
// 中断测速
sprintf(dis,"L:%d",(int)l_count);
LCD_write_english_string(0,4,dis);
sprintf(dis,"R:%d",(int)r_count);
LCD_write_english_string(40,4,dis);
}
}
/* 以上是电脑鼠功能模块测试程序，方便测试各个模块功能是否正常，测试完毕后可注释掉或者删除 */
}
{
Wheel_Control(LEFT,WHEEL_FRONT,80);
Wheel_Control(RIGHT,WHEEL_FRONT,70);
delay_ms(10);
}
void Right_Adjust() //右偏 后向 左微调 的具体实现
{
l_count = left_count;
r_count = right_count;
left_count = 0;
right_count = 0;
// 电机控制测试 加速->减速->反转->加速->减速...如此循环
if(i<180)
{
dir = !dir;
}
void Turn_Right() //右转的具体实现
{
Stop_On_Going();
Wheel_Control(LEFT,WHEEL_FRONT,80);
Wheel_Control(RIGHT,WHEEL_BACK,80);
delay_ms(20);
case 0x00 : mode = 4; break; ////00000000 掉头
case 0x98 : mode = 10; break; ////10011000 稍微偏左，后续调整
case 0xc8 : mode = 11; break; ////11001000 稍微偏右，后续调整
{
case 0x18 : mode = 1; break; ////00011000 左转
case 0xd8 : mode = 2; break; ////11011000 直走
case 0xc0 : mode = 3; break; ////11000000 左转
delay_ms(250);
delay_ms(250);
delay_ms(250); delay_ms(250);
delay_ms(250);
delay_ms(250);
LCD_clear();
//开总中断
SET_EA();
while(1)
sprintf(dis,"PWM :%d %3.0f%%",(int)i,(float)i/255*100);
LCD_write_english_string(0,0,dis);
// 电机供电电池电压 显示
sprintf(dis,"Vmotor:%.1fV",(float)(4.98/Get_ADC10bitResult(0)*Get_ADC10bitResult(1)));
LCD_write_english_string(0,2,dis);
// 单片机供电电池电压 显示
sprintf(dis,"Vmcu :%.1fV",(float)(4.98/Get_ADC10bitResult(0)*Get_ADC10bitResult(2)));
LCD_write_english_string(0,3,dis);
default : mode = 2; break; ////其他情况，执行直走
}
switch(mode)
{
case 1 : Turn_Left(); break;
case 2 : Go_straight(); break;
case 3 : Turn_Right(); break;
{
Go_straight(); //测试直走
}
while(1)
{
while(1)
{
Go_straight();
}
while(1)
{
sensor = P1&0xf8;
switch(sensor)
Wheel_Control(LEFT,WHEEL_FRONT,70);
Wheel_Control(RIGHT,WHEEL_FRONT,80);
delay_ms(10);
}
void main()
{
u16 mode ;
u8 sensor ;
u8 i=180,count=0,dir=0,pn =0,dis[20];
delay_ms(250);
delay_ms(250);
delay_ms(250);
delay_ms(250);
LCD_clear();
LCD_write_english_string(2,0," Welcome To ");
LCD_write_english_string(2,1," S W J T U ");
}
void Turn_back() //调头的具体实现
{
Wheel_Control(LEFT,WHEEL_FRONT,80);
Wheel_Control(RIGHT,WHEEL_BACK,80);
delay_ms(20);
}
void Left_Adjust() //左偏 后向 右微调 的具体实现
delay_ms(20);
}
void Go_straight() //直走的具体实现
{
Wheel_Control(LEFT,WHEEL_FRONT,80);
Wheel_Control(RIGHT,WHEEL_FRONT,80);
delay_ms(20);
case 4 : Turn_back(); break;
case 10 : Left_Adjust(); break;
case 11 : Right_Adjust(); break;
default : Turn_Right(); break;
}
u16 l_count,r_count;
//功能模块初始化
// GPIO_config(); //STC15W4K32S4 PWM复用口 由高阻初始化为双向口
EXTI_config(); //外部中断 测速
Timer_config(); //定时器
PCA_config(); //PWM
UART_config(); //串口
ADC_config(); //AD 电压检测
//液晶屏初始化
LCD_init();
LCD_clear();
LCD_draw_bmp_pixel(15,0,BMP,48,56);
pn = 1;
}
if(i>254)
pn = 0;
if(pn) i++;
else i--;
Wheel_Control(LEFT,dir,255-i);
Wheel_Control(RIGHT,dir,255-i);
// PWM 显示
LCD_write_english_string(2,2," DNS VER 2.1 ");
LCD_write_english_string(2,3,"Nokia5110 LCD ");
LCD_write_chinese_string(1,4,12,6,0,2);
//wait for the start key down
}
/* 以下是电脑鼠功能模块测试程序，方便测试各个模块功能是否正常，测试完毕后可注释掉或者删除 */
if(timer0_flag)
{
timer0_flag = 0;
count ++;
}
if(count == 10)
{
count = 0;
Wheel_Control(RIGHT,WHEEL_FRONT,255);
delay_ms(20);
}
void Turn_Left()
{
Stop_On_Going();
Wheel_Control(LEFT,WHEEL_BACK,80);
Wheel_Control(RIGHT,WHEEL_FRONT,80);
while(Start_Key); /////
// 延时启动（start按键按下，等待n秒后启动）
delay_ms(250);
delay_ms(250);
delay_ms(250);
delay_ms(250);
delay_ms(250);
delay_ms(250);