C语言迷宫(经典题目)
用C语言解决迷宫问题
⽤C语⾔解决迷宫问题#include <stdio.h>#include <stdlib.h>#define ROW 10#define COL 10/*迷宫中位置信息*/typedef struct position{int x;int y;}position;/*在迷宫中的当前位置的信息，也是⼊栈的基本元素*/typedef struct SElem{int di;position seat;}SElem;/*链式栈中节点的定义*/typedef struct position_stack{SElem p;struct position_stack *next;}*Stack_pNode,Stack_Node;void InitStack(Stack_pNode *Link){*Link = NULL;}void push(Stack_pNode *Link,SElem e){Stack_pNode new_SElem = (Stack_pNode)calloc(1,sizeof(Stack_Node));new_SElem->p = e;new_SElem->next = NULL;if (*Link == NULL)*Link = new_SElem;else{new_SElem->next = *Link;*Link = new_SElem;}}int pop(Stack_pNode *Link,SElem *e){if (*Link == NULL)return 0;*e = (*Link)->p;Stack_pNode q = *Link;*Link = (*Link)->next;free(q);return 1;}int top(Stack_pNode Link, SElem *e){if (Link == NULL)return 0;*e = Link->p;return 1;}int empty(Stack_pNode Link){if (Link == NULL)return 1;elsereturn 0;}int reverse(Stack_pNode *Link){Stack_pNode p, q, r;if (*Link == NULL || (*Link)->next == NULL)return 0;r = *Link;p = (*Link)->next;q = NULL;while (p){r->next = q;q = r;r = p;p = p->next;}r->next = q;*Link = r;}void print(Stack_pNode Link){Stack_pNode r = Link;while (r){printf("(%d,%d) -> ",r->p.seat.x,r->p.seat.y);r = r->next;}printf("exit\n");}int curstep = 1;/*纪录当前的⾜迹，填写在探索前进的每⼀步正确的路上*//*迷宫地图。
c语言~走迷宫
本程序代码为C语言解决数据结构（严蔚敏）中关于迷宫的问题。
程序不仅实现迷宫路径查找，还实现文字描述路径功能可以直接粘贴到vc6.0中运行【代码如下】# include <stdio.h> # include <malloc.h> # define null 0typedef struct{int (*base)[2];int (*top)[2];int listlen;}sqlist;int topelem[2]; //栈顶元素void creatstack(sqlist *mazepath); //创建一个存储路径的栈void creatmap(int (*mazemap)[10]); //创建迷宫图纸void printmap(int (*mazemap)[10]);void footprint(int x,int y,int k,int (*mazemap)[10]);int position(int x,int y); //判断是否到终点int passroad(int x,int y,int (*mazemap)[10]);void findpath(int (*mazemap)[10],sqlist *mazepath); //在mazemap当中寻找mazepahtvoid printpath(sqlist *mazepath);void roadinwords(sqlist *mazepath); //文字叙述如何走迷宫void push(int x,int y,sqlist *mazepath); //栈操作void pop(sqlist *mazepath);void gettop(sqlist *mazepath);void main(){sqlist mazepath;creatstack(&mazepath); //创建一个存储路径的栈int mazemap[10][10]={1,1,1,1,1,1,1,1,1,1,1,0,0,1,0,0,0,1,0,1,1,0,0,1,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1,1,0,1,1,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,1,1,0,1,0,0,0,1,0,0,1,1,0,1,1,1,0,1,1,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};// creatmap(mazemap); //创建迷宫图纸printf("迷宫原图为：\n");printmap(mazemap);findpath(mazemap,&mazepath); //在mazemap当中寻找mazepaht printf("走出迷宫图纸为：\n");printmap(mazemap);printf("走出迷宫文字叙述为：\n");roadinwords(&mazepath);// printpath(&mazepath);}void findpath(int (*mazemap)[10],sqlist *mazepath){int x,y,flag=0,k=0,next; //位置是否可通，flag=0通，1墙，2通但不可走x=1;y=1; //获取初始位置push(x,y,mazepath); //起点位置进栈footprint(x,y,6,mazemap);while(flag==0 && k!=162) //flag==1到达终点,0未到达终点{if(passroad(x,y+1,mazemap)==0)push(x,y+1,mazepath),y=y+1,footprint(x,y,6,mazemap);else if(passroad(x+1,y,mazemap)==0)push(x+1,y,mazepath),x=x+1,footprint(x,y,6,mazemap);else if(passroad(x,y-1,mazemap)==0)push(x,y-1,mazepath),y=y-1,footprint(x,y,6,mazemap);else if(passroad(x-1,y,mazemap)==0)push(x-1,y,mazepath),x=x-1,footprint(x,y,6,mazemap);elsefootprint(x,y,2,mazemap),pop(mazepath),gettop(mazepath),x=topelem[0],y= topelem[1];// printmap(mazemap);k++;flag=position(x,y); //判断是否到达终点// printf("flag==%d\n",flag);}}void creatstack(sqlist *mazepath){mazepath->base=(int (*)[2])malloc(120*sizeof(int (*)[2]));mazepath->top=mazepath->base;mazepath->listlen=120;}void push(int x,int y,sqlist *mazepath){**(mazepath->top)=x;*(*(mazepath->top)+1)=y;mazepath->top++;}void pop(sqlist *mazepath){if(mazepath->top!=mazepath->base)mazepath->top--;}void printmap(int (*mazemap)[10]){int (*p)[10];p=mazemap;int i,j;printf(" \n\n\n");for(i=0;i<10;i++){for(j=0;j<10;j++){if(j==0)printf(" ");if(*(*(p+i)+j)==0)printf("▇");else if(*(*(p+i)+j)==1)printf("□");else if(*(*(p+i)+j)==6)printf("★");elseprintf("▇");if(j==9)printf("\n");}}printf("\n\n");}void printpath(sqlist *mazepath){int (*p)[2];p=mazepath->base;while(p!=mazepath->top){printf("x=%d,y=%d\n",**p,*(*p+1));p++;}}void gettop(sqlist *mazepath){int (*p)[2];int (*q)[2];p=mazepath->base;while(p!=mazepath->top){q=p;p++;}topelem[0]=**q;topelem[1]=*(*q+1);}void footprint(int x,int y,int k,int (*mazemap)[10]){if(x<10 && y<10)*(*(mazemap+x)+y)=k;}int position(int x,int y){int flag;if(x==8 && y==8)flag=1;elseflag=0;return(flag);}int passroad(int x,int y,int (*mazemap)[10]) {int num=1;if(x<10 && y<10)num=*(*(mazemap+x)+y);return(num);}void roadinwords(sqlist *mazepath){int x=1,y=1,i=0;int (*p)[2];p=mazepath->base;p++;while(p!=mazepath->top){if(x==**p && y+1==*(*p+1))printf("向右走→→"),x=**p,y=*(*p+1);else if(x+1==**p && y==*(*p+1))printf("向下走→→"),x=**p,y=*(*p+1);else if(x==**p && y-1==*(*p+1))printf("向左走→→"),x=**p,y=*(*p+1);else if(x-1==**p && y==*(*p+1))printf("向上走→→"),x=**p,y=*(*p+1);i++;if(i%3==0)printf("\n");p++;}printf("\n");}。
C语言递归实现迷宫寻路问题
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语言
求迷宫问题就是求出从入口到出口的路径。
在求解时,通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前试探,若能走通,则继续往前走；否则沿原路退回,换一个方向再继续试探,直至所有可能的通路都试探完为止。
为了保证在任何位置上都能沿原路退回(称为回溯),需要用一个后进先出的栈来保存从入口到当前位置的路径。
首先用如图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•问题描述这是心理学中的一个经典问题。
心理学家把一只老鼠从一个无顶盖的大盒子的入口处放入，让老鼠自行找到出口出来。
迷宫中设置很多障碍阻止老鼠前行，迷宫唯一的出口处放有一块奶酪，吸引老鼠找到出口。
简而言之，迷宫问题是解决从布置了许多障碍的通道中寻找出路的问题。
本题设置的迷宫如图1所示。
入口迷宫四周设为墙；无填充处，为可通处。
设每个点有四个可通方向，分别为东、南、西、北（为了清晰，以下称"上下左右”）。
左上角为入口。
右下角为出口。
迷宫有一个入口，一个出口。
设计程序求解迷宫的一条通路。
2.数据结构设计以一个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语言)经典迷宫算法
main.h#include<stdio.h>#include<stdlib.h>#include<string.h>#include <Windows.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define N 10//#define M 82//0 通道//1 墙壁//2 走过//3 不能通过需退回//4 结果//typedefstruct //二维数组以1和0区分墙壁和通道以显示迷宫int a[N][N]; //{//intMaze[N][N];//}Maze;typedefstruct//通道块在迷宫中的坐标{int x;int y;}Pos;//压入栈的值为可通的坐标typedefstruct{//di//1上//2下//3左//4右intord;//通道块在路径上的序号Pos seat;//通道块在迷宫中的“坐标位置”int di;//从此通道块走向下一通道块的“方向”}ForStack;//栈的元素类型/*typedefstruct{Pos S;}Pstack;*/typedefstruct{ForStack *base;//在栈构造之前和销毁之后，base的值为NULLForStack *top;//栈顶指针intstacksize;//当前已分配的存储空间,以元素为单元}SqStack;//-------基本操作的函数原型-------void tips(); //操作提示void status(int status);//若出错输出出错状态intInitStack(SqStack&s);//构造一个空栈//intDestroyStack(SqStack&s);//销毁栈s,s不再存在//intClearStack(SqStack&s);//把s置为空栈intStackEmpty(SqStack s);//若栈为空返回true，非空返回falseint Push(SqStack&s,ForStack e);//插入元素e为新的栈顶元素int Pop(SqStack&s,ForStack&e);//若栈不空，则删除s的栈顶元素,用e返回其值,并返回OK否则返回falseintGetTop(SqStacks,ForStack&e);//若栈不空，用e返回S的栈顶元素//intInit(int&fa[N][N]);//初始化一个迷宫地图intMazePath(int Maze[][N], Posstart,Pos end);//完成迷宫的寻路功能void ShowMaze(intSMaze[][N],int c);//找到路径后显示迷宫PosNextPos(Posnow,int di);//下一个位置*.cpp#include "main.h"intInitStack(SqStack&s)//构造一个空栈{s.base=(ForStack*)malloc(STACK_INIT_SIZE*sizeof(ForStack));if(!s.base)exit(OVERFLOW);s.top=s.base;s.stacksize=STACK_INIT_SIZE;return OK;}intGetTop(SqStacks,ForStack&e)//若栈不空，用e返回S的栈顶元素{if(s.top==s.base)return ERROR;e=*(s.top-1);return OK;}intStackEmpty(SqStack s)//若栈为空返回true，非空返回false{if(s.top==s.base)//若为空栈返回TRUEreturn TRUE;elsereturn FALSE;}int Push(SqStack&s,ForStack e)//插入元素e为新的栈顶元素{if((s.top-s.base)>=s.stacksize){//若栈满则追加存储空间s.base=(ForStack*)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(ForStack));if(!s.base)//存储追加失败exit(OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=STACKINCREMENT;}*s.top++=e;return OK;}int Pop(SqStack&s,ForStack&e)//若栈不空，//则删除s的栈顶元素,用e返回其值,并返回OK否则返回false{if(s.top==s.base)return ERROR;e=*(--s.top);return OK;}//---------------------------------------------------------------------------PosNextPos(Posnow,int di) //下一个位置{Pos n;switch(di){case 1://上now.y-=1;break;case 2://下now.y+=1;break;case 3://左now.x-=1;break;case 4://右now.x+=1;break;}n.x=now.x;n.y=now.y;return n;}intMazePath(int Maze[][N],Posstart,Pos end) //完成寻路{SqStack S;InitStack(S);//初始化空栈SPoscurpos=start;ForStack e;intcurstep=1;do{if(Maze[curpos.x][curpos.y]==0)//当前位置可通（未曾走到过的通道块）{Maze[curpos.x][curpos.y]=2;//留下足迹e.ord=curstep;e.seat.x=curpos.x;e.seat.y=curpos.y;e.di=1;Push(S,e);//加入路径if(curpos.x==end.x&&curpos.y==end.y)//到达出口return TRUE;curpos=NextPos(curpos,1);//下一位置是当前位置的东邻curstep++;//探索下一步}else//当前位置不能通过{if(!StackEmpty(S)){Pop(S,e);while(e.di==4 && !StackEmpty(S)){Maze[e.seat.x][e.seat.y]=3;//留下不能通过的标记并退回一步Pop(S,e);}if(e.di<4)//换下一个方向继续探索{e.di++;Push(S,e);curpos=NextPos(e.seat,e.di);//设定当前位置是该新方向上的相邻块}}}}while(!StackEmpty(S));return FALSE;}void ShowMaze(intSMaze[N][N],int c)//把用二维数组表示的迷宫打印出来{if(c==1) //显示初始的{for(int i=0;i<N;i++){for(int j=0;j<N;j++){printf("%d ",SMaze[i][j]);}printf("\n");}}if(c==2) //显示寻路完成的{for(int i=0;i<N;i++){for(int j=0;j<N;j++){if(SMaze[i][j]==2)printf("* ");elseprintf("%d ",SMaze[i][j]);}printf("\n");}}}int main(){int count=0;int Maze01[N][N]={{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},};printf("\n---------------------------------迷宫---------------------------\n\n\n");ShowMaze(Maze01,1);//显示迷宫//--------printf("\n用二维数组表示迷宫\n");printf("各数值代表意义如下：\n");printf("0 通道\n1 墙\n");printf("3 特定方向下不能通过的通道块(四周至少有一块墙或走过的不通的路)\n");printf("* 最终路径\n");//-------Pos start={1,1};//入口统一设在(1,1)处,出口在(8,8)处Pos exit={8,8};MazePath(Maze01,start,exit);//完成寻路printf("\n寻路");while(count<20){printf(".");Sleep(100);count++;}printf("\n寻路完成\n");ShowMaze(Maze01,2);//显示迷宫return 0;}。
求解迷宫问题(c语言,很详细哦)
求迷宫问题就是求出从入口到出口的路径。
在求解时,通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前试探,若能走通,则继续往前走；否则沿原路退回,换一个方向再继续试探,直至所有可能的通路都试探完为止。
为了保证在任何位置上都能沿原路退回(称为回溯),需要用一个后进先出的栈来保存从入口到当前位置的路径。
首先用如图所示的方块图表示迷宫。
对于图中的每个方块,用空白表示通道,用阴影表示墙。
所求路径必须是简单路径,即在求得的路径上不能重复出现同一通道块。
为了表示迷宫,设置一个数组mg,其中每个元素表示一个方块的状态,为0时表示对应方块是通道,为1时表示对应方块为墙,如图所示的迷宫,对应的迷宫数组mg如下:int mg[M+1][N+1]={ /*M=10,N=10*/{1,1,1,1,1,1,1,1,1,1},{1,0,0,1,0,0,0,1,0,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,0,0,1,1,0,0,1}, {1,0,1,1,1,0,0,0,0,1}, {1,0,0,0,1,0,0,0,0,1}, {1,0,1,0,0,0,1,0,0,1}, {1,0,1,1,1,0,1,1,0,1}, {1,1,0,0,0,0,0,0,0,1}, {1,1,1,1,1,1,1,1,1,1} }; 伪代码：c语言描述如下：void mgpath() /*路径为:(1,1)->(M-2,N-2)*/ {int i,j,di,find,k;top++; /*初始方块进栈*/Stack[top].i=1;Stack[top].j=1;Stack[top].di=-1;mg[1][1]=-1;while (top>-1) /*栈不空时循环*/{i=Stack[top].i;j=Stack[top].j;di=Stack[top].di;if (i==M-2 && j==N-2) /*找到了出口,输出路径*/{printf("迷宫路径如下:\n");for (k=0;k<=top;k++){printf("\t(%d,%d)",Stack[k].i,Stack[ k].j);if ((k+1)%5==0) printf("\n");}printf("\n");return;}find=0;while (di<4 && find==0) /*找下一个可走方块*/{ di++;switch(di){case 0:i=Stack[top].i-1;j=Stack[top].j ;break;case 1:i=Stack[top].i;j=Stack[top].j +1;break;case 2:i=Stack[top].i+1;j=Stack[top].j ;break;case 3:i=Stack[top].i;j=Stack[top] .j-1;break;}if (mg[i][j]==0) find=1;}if (find==1) /*找到了下一个可走方块*/{Stack[top].di=di; /*修改原栈顶元素的di值*/top++; /*下一个可走方块进栈*/Stack[top].i=i ;Stack[top].j=j ;Stack[top].di= -1;mg[i][j]=-1; /*避免重复走到该方块*/ }else /*没有路径可走,则退栈*/{ mg[Stack[top].i][Stack[top].j]=0;/*让该位置变为其他路径可走方块*/top--;}}printf("没有可走路径!\n");}。
c语言走迷宫代码
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;
迷宫(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语言题目(迷宫问题,团伙问题,格雷码,约瑟夫环)
迷宫中存在通路和障碍，为了方便迷宫的创建，可用0表示通路，用1表示障碍，这样迷宫就可以用0、1矩阵来描述。
输入保存在in.txt文件中：8 81 1 8 80 0 1 0 0 0 1 00 0 1 0 0 0 1 00 0 0 0 1 1 0 00 1 1 1 0 0 0 00 0 0 1 0 0 0 00 1 0 0 0 1 0 00 1 1 1 0 1 1 01 0 0 0 0 0 1 0输出：整个组织有n个人，任何两个认识的人不是朋友就是敌人，而且满足：①我朋友的朋友是我的朋友；②我敌人的敌人是我的朋友。
③所有是朋友的人组成一个团伙。
现在，警方委派你协助调查，拥有关于这n个人的m条信息（即某两个人是朋友，或某两个人是敌人），请你计算出这个城市最多可能有多少个团伙。
数据范围：2≤N≤1000，1≤M≤1000。
输入数据：第一行包含一个整数N，第二行包含一个整数M，接下来M行描述M 条信息，内容为以下两者之一：“F x y”表示x与y是朋友；“E x y”表示x与y是敌人（1≤x≤y≤N）。
输出数据：包含一个整数，即可能的最大团伙数。
样例：输入：64E 1 4F 3 5F 4 6E 1 2输出：33.格雷码Gray码是一个长度为2n的序列。
序列中无相同元素，每个元素都是长度为n位的串，相邻元素恰好只有一位不同。
用分治策略可以对其设计一个算法。
输入为n值，输出对应的Gray码。
下面是n等于1,2，3时的Gray码：N=1, 0 1N=2, 00 01 11 10N=3, 000 001 011 010 110 111 101 1004.排序与查找输入一个数n（n不大于30），随机生成n个不大于1000的正整数。
先输出这n个数的序列，然后再对其进行快速排序，输出排序后的结果。
接下来循环接受输入，对排序后的有序序列进行折半查找，若查找成功，输入”yes”,否则输出”no”。
随机函数：#include<stdlib.h>#include<time.h>srand((int)time(NULL));rand()；快速排序和折半查找函数：#include<stdlib.h>qsort()bsearch()5.约瑟夫环编号为1，2，。
C语言数据结构之迷宫问题
C语⾔数据结构之迷宫问题本⽂实例为⼤家分享了数据结构c语⾔版迷宫问题栈实现的具体代码，供⼤家参考，具体内容如下程序主要参考⾃严蔚敏⽼师的数据结构c语⾔版，在书中程序的⼤体框架下进⾏了完善。
关于迷宫问题的思路可查阅原书。
#include<iostream>using namespace std;#define MAXSIZE 10typedef int Status;typedef struct{int x;int y;}Postype;typedef struct{int ord;Postype seat;int dir;}SElemType;//栈的元素类型typedef struct{//SElemType data[MAXSIZE];SElemType* top;SElemType* base;}Stack;//栈的结构类型typedef struct{char arr[MAXSIZE][MAXSIZE];}MAZETYPE;//迷宫结构体MAZETYPE maze;void InitMaze(){maze.arr[0][0] = maze.arr[0][1] = maze.arr[0][2] = maze.arr[0][3] = maze.arr[0][4] = maze.arr[0][5] = maze.arr[0][6] = maze.arr[0][7] = maze.arr[0][8] = maze.arr[0][9] = '1'; maze.arr[1][0] = maze.arr[1][3] = maze.arr[1][7] = maze.arr[1][9] = '1';maze.arr[1][1] = maze.arr[1][2] = maze.arr[1][4] = maze.arr[1][5] = maze.arr[1][6] = maze.arr[1][8] = '0';maze.arr[2][0] = maze.arr[2][3] = maze.arr[2][7] = maze.arr[2][9] = '1';maze.arr[2][1] = maze.arr[2][2] = maze.arr[2][4] = maze.arr[2][5] = maze.arr[2][6] = maze.arr[2][8] = '0';maze.arr[3][0] = maze.arr[3][5] = maze.arr[3][6] = maze.arr[3][9] = '1';maze.arr[3][1] = maze.arr[3][2] = maze.arr[3][3] = maze.arr[3][4] = maze.arr[3][7] = maze.arr[3][8] = '0';maze.arr[4][0] = maze.arr[4][2] = maze.arr[4][3] = maze.arr[4][4] = maze.arr[4][9] = '1';maze.arr[4][1] = maze.arr[4][5] = maze.arr[4][6] = maze.arr[4][7] = maze.arr[4][8] = '0';maze.arr[5][0] = maze.arr[5][4] = maze.arr[5][9] = '1';maze.arr[5][1] = maze.arr[5][2] = maze.arr[5][3] = maze.arr[5][5] = maze.arr[5][6] = maze.arr[5][7] = maze.arr[5][8] = '0';maze.arr[6][0] = maze.arr[6][2] = maze.arr[6][6] = maze.arr[6][9] = '1';maze.arr[6][1] = maze.arr[6][3] = maze.arr[6][4] = maze.arr[6][5] = maze.arr[6][7] = maze.arr[6][8] = '0';maze.arr[7][0] = maze.arr[7][2] = maze.arr[7][3] = maze.arr[7][4] = maze.arr[7][6] = maze.arr[7][9] = '1';maze.arr[7][1] = maze.arr[7][5] = maze.arr[7][7] = maze.arr[7][8] = '0';maze.arr[8][0] = maze.arr[8][1] = maze.arr[8][9] = '0';maze.arr[8][2] = maze.arr[8][3] = maze.arr[8][4] = maze.arr[8][5] = maze.arr[8][6] = maze.arr[8][7] = maze.arr[8][8] = '0';maze.arr[9][0] = maze.arr[9][1] = maze.arr[9][2] = maze.arr[9][3] = maze.arr[9][4] = maze.arr[9][5] = maze.arr[9][6] = maze.arr[9][7] = maze.arr[9][8] = maze.arr[9][9] = '1'; }Status initStack(Stack &s){s.base = (SElemType*)malloc(MAXSIZE*sizeof(SElemType));if (!s.base) return 0;s.top = s.base;return 1;}void Push(Stack &s, SElemType e){*s.top++ = e;}void Pop(Stack &s, SElemType &e){e = *--s.top;}Status StackEmpty(Stack &s){if (s.top == s.base) return 1;else return 0;}Status Pass(Postype curpos){if (maze.arr[curpos.x][curpos.y] == '0')return 1;else return 0;}void Foot(Postype curpos){maze.arr[curpos.x][curpos.y] = '*';}void MarkPrint(Postype curpos){maze.arr[curpos.x][curpos.y] = '!';}Status StructCmp(Postype a, Postype b){if (a.x = b.x&&a.y == b.y) return 1;else return 0;}//下⼀个位置Postype NextPos(Postype CurPos, int Dir){Postype ReturnPos;switch (Dir){case 1:ReturnPos.x = CurPos.x;ReturnPos.y = CurPos.y + 1;break;case 2:ReturnPos.x = CurPos.x + 1;ReturnPos.y = CurPos.y;break;case 3:ReturnPos.x = CurPos.x;ReturnPos.y = CurPos.y - 1;break;case 4:ReturnPos.x = CurPos.x - 1;ReturnPos.y = CurPos.y;break;}return ReturnPos;}Status MazePath(Postype start, Postype end) {Stack s;SElemType e;initStack(s);Postype curpos = start;int curstep = 1;do{if (Pass(curpos)){Foot(curpos);e = { curstep, curpos, 1 };Push(s, e);if (StructCmp(curpos, end)) return 1;curpos = NextPos(curpos, 1);curstep++;}else{if (!StackEmpty(s)){Pop(s, e);while (e.dir ==4 &&!StackEmpty(s)){MarkPrint(e.seat); Pop(s, e);}if (e.dir < 4 && !StackEmpty(s)){e.dir++;Push(s, e);curpos = NextPos(e.seat, e.dir);}}}} while (!StackEmpty(s));return 0;}int main(){InitMaze();Postype s, e;s.x = s.y = 1;e.x = e.y = 8;if (MazePath(s, e))printf("迷宫成功解密!\n");elseprintf("解密失败\n");for (int i = 0; i < 10; i++){for (int j = 0; j < 10; j++){printf("%c ", maze.arr[i][j]);}printf("\n");}cout << "-=================================" << endl;for (int i = 0; i < 10; i++){for (int j = 0; j < 10; j++){if (maze.arr[i][j] == '*' || maze.arr[i][j] == '!')printf("%c ", maze.arr[i][j]);else cout << " ";}printf("\n");}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
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、迷宫求解设计一个迷宫求解程序，要求如下：✓以M × N表示长方阵表示迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。
✓能任意设定的迷宫✓（选作）如果有通路，列出所有通路提示：✓以一个二维数组来表示迷宫，0和1分别表示迷宫中的通路和障碍，如下图迷宫数据为：1111111111 Array 100100010110010001011000011001101110000110001000011010001001101110110111000000011111111111入口位置：1 1出口位置：8 8✓探索过程可采用如下算法，设定当前位置的初值为入口位置；do {若当前位置可通，则｛将当前位置插入栈顶；若该位置是出口位置，则结束；否则切换当前位置的东邻方块为新的当前位置；｝否则，｛若栈不空且栈顶位置尚有其他方向未经探索，则设定新的当前位置为沿顺时针方向旋转找到的栈顶位置的下一相邻块；若栈不空但栈顶位置的四周均不可通，则｛删去栈顶位置；//从路径中删去该通道块若栈不空，则重新测试新的栈顶位置，直至找到一个可通的相邻块出栈至栈空；｝｝｝while (栈不空)；#include<stdio.h>#include<string.h>#define MaxSize 32int a[30][30];int b[30][30];int m,n;typedef struct{int i;int j;int di;}Box;typedef struct{Box data[MaxSize];int top;}StackType;bool sereach(int X,int Y,int X1,int Y1);void main(){int X,Y,Y1,X1;memset(a,0,sizeof(a));memset(b,0,sizeof(b));// for()printf("请输入迷宫的长度和宽度\n");while(~scanf("%d%d",&m,&n)){printf("请输入迷宫（0表示空地，1表示围墙）\n");for(int i=0;i<n;i++){for(int j=0;j<m;j++){scanf("%d",&a[i][j]);if(a[i][j]==1)b[i][j]=-1;}}printf("请输入迷宫起点的行号和列号\n");scanf("%d%d",&X,&Y);printf("请输入迷宫终点的行号和列号\n");scanf("%d%d",&X1,&Y1);if(!sereach(X,Y,X1,Y1))printf("该迷宫没有解!\n");printf("请输入迷宫的长度和宽度\n");}// return 0;}bool sereach(int X,int Y,int X1,int Y1){StackType st;int i,j,di,find;st.top=-1;while(a[X][Y]!=0){printf("迷宫起点的行号和列号有错，请重新输入\n");scanf("%d%d",&X,&Y);}if(a[X][Y]==0)b[X][Y]=-1;while(a[X1][Y1]!=0){printf("迷宫终点的行号和列号有错，请重新输入\n");scanf("%d%d",&X1,&Y1);}st.top++;st.data[st.top].i=X;st.data[st.top].j=Y;st.data[st.top].di=-1;do{find=0;i=st.data[st.top].i;j=st.data[st.top].j;di=st.data[st.top].di;while(di<4&&find==0){di++;switch(di){case 0:i=st.data[st.top].i-1;j=st.data[st.top].j;break;case 1:i=st.data[st.top].i;j=st.data[st.top].j+1;break;case 2:i=st.data[st.top].i+1;j=st.data[st.top].j;break;case 3:i=st.data[st.top].i;j=st.data[st.top].j-1;break;}if(b[i][j]==0&&i>=0&&i<n&&j>=0&&j<m)find=1;}if(find == 1){st.data[st.top].di=di;st.top++;st.data[st.top].i=i;s t.data[st.top].j=j;st.data[st.top].di=-1;b[i][j]=-1;find=0;}else{b[st.data[st.top].i][st.data[st.top].j]=0;st.top--;}if(i==X1&&j==Y1){printf("迷宫路径如下:\n");for(int k=0;k<=st.top;k++){printf("%d,%d\t",st.data[k].i,st.data[k].j);if((k+1)%6==0)printf("\n");}printf("\n");。
C语言
问题1:迷宫(maze)
• • • • • • • • 【样例输入】 221 1122 12 【样例输出】 1 【数据规模】 1<=N, M<=5
状态空间及描述
• 1)搜索对象 • 2)状态转移 • 3)可行状态判定方表达每个位 置，方向,走到点的坐标:k,nx,ny
问题1:迷宫(maze)
• 【问题描述】 • 给定一个N*M方格的迷宫，迷宫里 有T处障碍，障碍处不可通过。给定起 点坐标和终点坐标，问每个方格最多 经过1次，有多少种从起点坐标到终点 坐标的方案。在迷宫中移动有上下左 右四种方式。保证起点上没有障碍。
问题1:迷宫(maze)
• 【输入文件】 • 第一行N、M和T，N为行，M为列，T为障 碍总数。 • 第二行起点坐标SX,SY，终点坐标FX,FY 。 • 接下来T行，每行为障碍的坐标。 • 【输出文件】 • 给定起点坐标和终点坐标，问每个方格最 多经过1次，从起点坐标到终点坐标的方案总 数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
struct pathNode * next; }foodRoad; foodRoad * head; foodRoad * searchPath(int x,int y) { foodRoad * p=head; while(p) { if(p->x == x && p->y == y) return p; p=p->next; } return 0; } void createHead() { head=(foodRoad *)malloc(sizeof(foodRoad)); head->next=0; } void createPathNode(int x,int y,int k) { int i,*pr; foodRoad *p; p=searchPath(x,y); if(p==0) { foodRoad *pf; pf=(foodRoad *)malloc(sizeof(foodRoad)); pf->x=x;pf->y=y;pf->k=k; pr=(int *)malloc(sizeof(int)*(k+1)); pf->r=pr; for(i=1;i<=k;i++) pr[i]=path[i]; pf->next=0; p=head; while(p->next)
0,0,1,1,0,, 0,1,1,0,0,0, 1,1,0,0,0,0, 1,1,0,1,0,0, 1,0,0,1,0,0, 0,0,1,1,0,0, 0,1,1,1,0,0, 1,0,1,0,0,0,
0,0,1,1,0,0, 0,1,0,0,0,0, 1,1,0,0,0,0, 1,0,1,1,0,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 0,1,1,1,0,0, 1,0,0,1,0,0,
{ a[x][y].visit=1; if(a[x][y].food && !f[x][y]){ f[x][y]=k;print();}//a[x][y].food=0; if(a[x][y].food && f[x][y]>k){f[x][y]=k;printf("\nFound a shortest one "); print();} k++; if(a[x][y].up) { path[k]=1;//方向为1 x--;a[x][y].down=0; if(!a[x][y].visit)try1(x,y); a[x][y].down=1;x++; } if(a[x][y].down) { path[k]=2;//方向为2 x++;a[x][y].up=0; if(!a[x][y].visit)try1(x,y); a[x][y].up=1;x--; } if(a[x][y].left) { path[k]=3;//方向为3 y--;a[x][y].right=0; if(!a[x][y].visit)try1(x,y); a[x][y].right=1;y++; } if(a[x][y].right) { path[k]=4;//方向为4 y++;a[x][y].left=0; if(!a[x][y].visit)try1(x,y); a[x][y].left=1;y--; } a[x][y].visit=0;k--; }
int food,visit; } a[N][N]={ {0,0,0,1,0,0, 0,0,1,1,0,0, 0,1,1,1,0,0, 0,1,1,1,0,0, 0,0,1,1,0,0, 0,1,1,0,0,0}, {0,0,0,1,0,0, 0,0,1,1,0,0, 1,0,1,1,0,0, 1,1,0,1,0,0, 0,1,1,0,0,0, 1,1,0,0,0,0}, {0,1,0,0,0,0, 0,1,0,0,0,0, 0,1,0,0,1,0, 1,1,0,0,0,0, 1,1,0,0,0,0, 1,1,0,0,0,0}, {1,1,0,0,0,0, 1,1,0,1,0,0, 1,1,1,0,0,0, 1,0,1,0,0,0, 1,0,0,0,1,0, 1,1,0,0,0,0}, {1,1,0,1,0,0, 1,1,1,0,0,0, 1,1,0,0,0,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 1,1,1,0,0,0}, {1,0,0,0,0,0, 1,0,0,0,0,0, 1,1,0,1,0,0, 0,1,1,1,0,0, 0,0,1,1,0,0, 1,0,1,0,0,0}, {0,1,0,1,0,0, 0,0,1,1,0,0, 1,0,1,1,0,0, 1,0,1,1,0,0, 0,0,1,1,0,0, 0,1,1,0,0,0}, {1,0,0,1,1,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 1,0,1,0,0,0}}; void print() { int i,x=0,y=0; printf("\n0,0 -> "); for(i=1;i<=k;i++) { switch(path[i]) { case 1 :x--;break; case 2 :x++;break; case 3 :y--;break; case 4 :y++;break; } if(i<k) printf("%d,%d -> ",x,y); else printf("%d,%d food!\n",x,y); } } void try1(int x,int y)
在上面的迷宫中只有一个入口，有▲地方是有食物的，现在一只老 鼠从入口处进来，要求能找到所有的食物并且打印找到食物的路径。 (1)图信息： #define N 8 struct ginfo{ int up,down,left,right; int food,visit;; } a[N][N]={…}; (2)记录路径path[N*N]; (3)找到食物a[x][y].food==1 (4)代码 #include "stdio.h" #include<string.h> #define N 8 int path[64],k=0; struct ginfo{ int up,down,left,right; int food,visit; } a[N][N]={ {0,0,0,1,0,0, 0,0,1,1,0,0, 0,1,1,1,0,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 0,1,1,1,0,0, 0,0,1,1,0,0, 0,1,1,0,0,0}, {0,0,0,1,0,0, 0,0,1,1,0,0, 1,0,1,1,0,0, 0,1,1,0,0,0, 0,1,0,0,0,0, 1,1,0,1,0,0, 0,1,1,0,0,0, 1,1,0,0,0,0}, {0,1,0,0,0,0, 0,1,0,0,0,0, 0,1,0,0,1,0, 1,1,0,0,0,0, 1,1,0,0,0,0, 1,1,0,0,0,0, 1,1,0,0,0,0, 1,1,0,0,0,0}, {1,1,0,0,0,0, 1,1,0,1,0,0, 1,1,1,0,0,0, 1,1,0,1,0,0, 1,0,1,1,0,0, 1,0,1,0,0,0, 1,0,0,0,1,0, 1,1,0,0,0,0}, {1,1,0,1,0,0,
1,1,1,0,0,0, 1,1,0,0,0,0, 1,0,0,1,0,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 1,1,1,0,0,0}, {1,0,0,0,0,0, 1,0,0,0,0,0, 1,1,0,1,0,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 0,1,1,1,0,0, 0,0,1,1,0,0, 1,0,1,0,0,0}, {0,1,0,1,0,0, 0,0,1,1,0,0, 1,0,1,1,0,0, 0,1,1,1,0,0, 0,1,1,1,0,0, 1,0,1,1,0,0, 0,0,1,1,0,0, 0,1,1,0,0,0}, {1,0,0,1,1,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 1,0,1,0,0,0, 1,0,0,1,0,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 1,0,1,0,0,0}}; void print() { int i,x=0,y=0; printf("0,0->"); for(i=1;i<=k;i++) { switch(path[i]) { case 1 :x--;break; case 2 :x++;break; case 3 :y--;break; case 4 :y++;break; } if(i<k) printf("%d,%d->",x,y); else printf("%d,%d found!\n",x,y); } } void try1(int x,int y) { a[x][y].visit=1; if(a[x][y].food){ a[x][y].food=0;print();} k++; if(a[x][y].up) { path[k]=1;//方向为1 x--;a[x][y].down=0; if(!a[x][y].visit)try1(x,y); a[x][y].down=1;x++; }
0,0,1,1,0,0, 0,1,1,0,0,0, 1,1,0,0,0,0, 1,1,0,1,0,0, 1,0,0,1,0,0, 0,0,1,1,0,0, 0,1,1,1,0,0, 1,0,1,0,0,0,
0,0,1,1,0,0, 0,1,0,0,0,0, 1,1,0,0,0,0, 1,0,1,1,0,0, 0,0,1,1,0,0, 0,0,1,1,0,0, 0,1,1,1,0,0, 1,0,0,1,0,0,