c语言迷宫课程设计
额，又是课程设计。。。
迷宫类算法，用栈，队列来做。不过一般来队列，因为队列能够在较短时间内求出最短路径。
在网上搜下，很多的。。
你的要求很难达到。。。
② 用C语言编写一个迷宫程序 很急很急 （1）利用上下左右方向键控制光标在屏幕上一个20*20的区域内移动，通过
在不在，可以帮你临时写代码，就是怎么发送给你？还有保存DC中的位图到文件 要用到savebitmaptofile,它的头文件找不到，所以一般我制作位图时，显示到屏幕上，然后截屏保存的。（其实截屏就只要两个函数就可以完成了的）至于显示到屏幕上，就得到所有地图文件后才能做到了。
③ c语言迷宫问题程序功能介绍.设计思路.数据结构设计及用法说明程序结构（流程图）.各模块的功能及程序说明.
原来也做过，以下是写的源代码，里面有部分注释，应该能看懂，可以运行。总结的话，把代码写进去，再随便弄几句心得说几句好好学C应该就OK了吧
#include<stdio.h>
#include<stdlib.h>
#define M 15
#define N 15
struct 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;
else
return 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;
}
else
return 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; //开始为-1
Push(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 path
system("PAUSE");
}
④ C语言编程 迷宫问题(队列)
c#界面绘制的时候，底层重绘每次会清除画布背景，然后再全部重新绘制，这才是导致闪烁最主要的原因。于是重载消息发送函数操作，禁掉这条消息。代码如下：
protected override void WndProc(ref Message m)
{
if (m.Msg == 0x0014) // 禁掉清除背景消息
return;
base.WndProc(ref m);
}
⑤ 如何用C语言编写一个迷宫程序
#include
⑥ C语言迷宫，要完整代码的
#include<stdio.h>
#include<conio.h>
intmigong[10][10]=//设置迷宫，最外围1为墙里边0为可走路径1为障碍
{
{1,1,1,1,1,1,1,1,1,1},
{1,0,0,0,0,0,0,1,1,1},
{1,0,1,1,1,1,1,0,0,1},
{1,0,1,0,0,0,0,0,0,1},
{1,0,0,0,1,0,1,1,1,1},
{1,1,1,1,0,0,1,1,1,1},
{1,0,0,0,0,1,1,1,1,1},
{1,0,1,1,0,0,1,1,1,1},
{1,0,0,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1}
};
intnum;
struct
{
intx,y,d;
}lj[100];//x,y分别为垂直和水平方向
voidstart()
{
inttop=0,x,y,d,find;//d为设置方向，上下左右。find为设置找不找得到路
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("迷宫路径如下： ");
printf("start->");
for(x=0;x<=top;x++)
{
printf("(%d,%d)->",lj[x].x,lj[x].y);//把找到的路径输出
num++;
if(num%8==0)
printf(" ");
}
printf("->end! ");
}
while(d<4&&find==0){
d++;
switch(d){
case0:x=lj[top].x-1;y=lj[top].y;break;//方向为上
case1:x=lj[top].x;y=lj[top].y+1;break;//方向为右
case2:x=lj[top].x+1;y=lj[top].y;break;//方向为下
case3:x=lj[top].x;y=lj[top].y-1;}//方向为左
if(migong[x][y]==0)
find=1;
}
if(find==1){//判断是否找得到
lj[top].d=d;
top++;
lj[top].x=x;
lj[top].y=y;
d=-1;find=0;//重新调整方向
migong[x][y]=-1;}
else{
migong[lj[top].x][lj[top].y]=0;
top--;d=lj[top].d;//找不到的话退栈
}
}
}
voidmain()
{
start();
getch();
}
⑦ 数据结构 c语言 课程设计 小鼠走迷宫问题
1、可以用“*”来代表老鼠，“|”来代表墙，空格来代表路。每走一步用system("cls")刷新一次屏幕。
2、墙不可穿过代表，墙与周围的格子没有边。
3、规定一个时间t，若在t步之内没有走到粮仓，则输出无解。
4、这个简单，无非就是修改条件，从而修改整个图。
5、所用路径可以用深搜（回朔）来解决，最短路就用广搜来解决。最短路也可以用Dijstra算法、floyd算法等，但广搜是最简单的。
具体的程序你自己实现吧，如果写不出来，就去请教一下你们学校的ACMer，他们应该会比较熟悉。加油吧。
⑧ C语言用图的广度优先遍历做漫步迷宫问题
这是我们老师给我们上数据结构课的课件
#include "stdio.h"
typedef int datatype; /*假定线性表元素的类型为整型*/
#define maxsize 1024 /*假定线性表的最大长度为1024*/
# define n 100 /* 图的顶点最大个数 */
typedef char VEXTYPE; /* 顶点的数据类型 */
typedef float ADJTYPE; /* 权值类型 */
typedef struct
{ VEXTYPE vexs[n] ; /* 顶点信息数组 */
ADJTYPE arcs[n][n] ; /* 边权数组 */
int num ; /* 顶点的实际个数 */
}GRAPH;
/***********************1。置空图**********************/
void GraphInit(GRAPH *L)
{
L->num=0;
}
/***********************2。求结点数**********************/
int GraphVexs(GRAPH *L)
{
return(L->num);
}
/***********************3。创建图**********************/
void GraphCreate(GRAPH *L)
{
int i,j;
GraphInit(L);
printf("请输入顶点数目：");
scanf("%d",&L->num);
printf("请输入各顶点的信息(单个符号）：");
for(i=0;i<L->num;i++)
{
fflush(stdin);
scanf("%c",&L->vexs[i]);
}
printf("请输入边权矩阵的信息：");
for(i=0;i<L->num;i++)
{
for(j=0;j<L->num;j++)
{
scanf("%f",&L->arcs[i][j]);
}
}
printf("图已经创建完毕！");
}
/***********************4。图的输出**********************/
void GraphOut(GRAPH L)
{
int i,j;
printf("\n图的顶点数目为：%d",L.num);
printf("\n图的各顶点的信息为：\n");
for(i=0;i<L.num;i++)
printf("%c ",L.vexs[i]);
printf("\n图的边权矩阵的信息为：\n");
for(i=0;i<L.num;i++)
{
for(j=0;j<L.num;j++)
{
printf("%6.2f ",L.arcs[i][j]);
}
printf("\n");
}
printf("图已经输出完毕！");
}
/***********************5。图的深度周游**********************/
void DFS(GRAPH g,int qidian,int mark[])
//从第qidian个点出发深度优先周游图g中能访问的各个顶点
{
int v1;
mark[qidian]=1;
printf("%c ",g.vexs[qidian]);
for(v1=0;v1<g.num;v1++)
{
if(g.arcs[qidian][v1]!=0&&mark[v1]==0)
DFS(g,v1,mark);
}
}
/***********************6。图的深度周游**********************/
void GraphDFS(GRAPH g)
//深度优先周游图g中能访问的各个顶点
{
int qidian,v,v1,mark[maxsize];
printf("\n深度周游：");
printf("\n请输入起点的下标：");
scanf("%d",&qidian);
for(v=0;v<g.num;v++)
{
mark[v]=0;
}
for(v=qidian;v<g.num+qidian;v++)
{
//printf("v=%d ",v);
v1=v%g.num;
if(mark[v1]==0)
DFS(g,v1,mark);
}
}
typedef int DATATYPE; //队列元素的数据类型
typedef struct
{
DATATYPE data[maxsize]; //队中元素
int front,rear; //队头元素下标、队尾元素后面位置的下标
} SEQQUEUE;
/*****************************************************************************/
void QueueInit(SEQQUEUE *sq)
//将顺序循环队列sq置空（初始化）
{
sq->front=0;
sq->rear=0;
}
/*****************************************************************************/
int QueueIsEmpty(SEQQUEUE sq)
//如果顺序循环队列sq为空，成功返回1，否则返回0
{
if (sq.rear==sq.front)
return(1);
else
return(0);
}
/*****************************************************************************/
int QueueFront(SEQQUEUE sq,DATATYPE *e)
//将顺序循环队列sq的队头元素保存到e所指地址，成功返回1，失败返回0
{
if (QueueIsEmpty(sq))
else
}
/*****************************************************************************/
int QueueIn (SEQQUEUE *sq,DATATYPE x)
//将元素x入队列sq的队尾，成功返回1，失败返回0
{
if (sq->front==(sq->rear+1)%maxsize)
{
printf("queue is full!\n");
return 0;
}
else
{
sq->data[sq->rear]=x;
sq->rear=(sq->rear+1)%maxsize;
return(1);
}
}
/*****************************************************************************/
int QueueOut(SEQQUEUE *sq)
//将队列sq队首元素出队列，成功返回1,失败返回0
{
if (QueueIsEmpty(*sq))
{
printf("queue is empty!\n");
return 0;
}
else
{
sq->front=(sq->front+1)%maxsize;
return 1;
}
}
/***********************7。图的广度周游**********************/
void BFS(GRAPH g,int v,int mark[])
//从v出发广度优先周游图g中能访问的各个顶点
{
int v1,v2;
SEQQUEUE q;
QueueInit(&q);
QueueIn(&q,v);
mark[v]=1;
printf("%c ",g.vexs[v]);
while(QueueIsEmpty(q)==0)
{
QueueFront(q,&v1);
QueueOut(&q);
for(v2=0;v2<g.num;v2++)
{
if(g.arcs[v1][v2]!=0&&mark[v2]==0)
{
QueueIn(&q,v2);
mark[v2]=1;
printf("%c ",g.vexs[v2]);
}
}
}
}
/***********************8。图的广度周游**********************/
void GraphBFS(GRAPH g)
//深度优先周游图g中能访问的各个顶点
{
int qidian,v,v1,mark[maxsize];
printf("\n广度周游：");
printf("\n请输入起点的下标：");
scanf("%d",&qidian);
for(v=0;v<g.num;v++)
{
mark[v]=0;
}
for(v=qidian;v<g.num+qidian;v++)
{
v1=v%g.num;
if(mark[v1]==0)
BFS(g,v1,mark);
}
}
/***********************主函数**********************/
void main()
{
GRAPH tu;
GraphCreate(&tu);
GraphOut(tu);
GraphDFS(tu);
GraphBFS(tu);
}
⑨ 如何用C语言编写一个迷宫程序
#include<stdio.h>
#include<stdlib.h>
#define M 15
#define N 15
struct 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;
else
return 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;
}
else
return 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; //开始为-1
Push(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还是不错滴
}
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; //迷宫行,列 [/M]
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("你建立的迷宫为(最外圈为强)...\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}};//行增量和列增量 方向依次为东西南北 [/M]
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 path
system("PAUSE");
}
⑩ C语言迷宫问题
给你一个我以前的课程设计注释比较详细希望对你有所帮助！
#include<stdio.h>
#include<stdlib.h>
#define STACK_INI_SIZE 100
#define STACKINCREMENT 50
#define NULL 0
typedef struct
{
int *top;
int *base;
int length;
int stacksize;
}sqstack;
int mg[25][25];
int m=1,n=1,x,y;
/*********************************************/
main()
{
void initstack(sqstack *s);/*初始化栈*/
void stackpush(sqstack *s,int);/*增加栈顶*/
void stackpop(sqstack *s);/*撤销栈顶*/
void stackinput(sqstack *s);/*输出栈*/
int mgway(sqstack *s);/*迷宫路径*/
void destorystack(sqstack *s);/*撤销栈S*/
void makemg(sqstack *s);/*制造迷宫*/
sqstack s;
int i,flag1=1,flag2=1,flag3=1;
char ch;
srand((unsigned)time(NULL));
while(flag1)
{
initstack(&s);
flag2=1;
makemg(&s);
i=mgway(&s);
if(i==0)
printf("此迷宫没有通路\n");
else
stackinput(&s);
destorystack(&s);
printf("还继续么?");
fflush(stdin);
scanf("%c",&ch);
while(flag2)
{
if(ch=='n'||ch=='N')
{
flag1=0;
flag2=0;
}
else if(ch=='y'||ch=='Y')
{
flag1=1;
flag2=0;
}
else
{
printf("输入错误请重新输入");
fflush(stdin);
scanf("%c",&ch);
}
}
}
}
/*********************************************/
void initstack(sqstack *s)/*初始化栈*/
{
s->top=s->base=(int *)malloc(STACK_INI_SIZE*sizeof(int));
if(!s->base)
exit(1);
s->stacksize=STACK_INI_SIZE;
*(s->base)=0;
s->top++;
*(s->top)=101;
s->top++;
s->length=2;
}
/*********************************************/
void stackpush(sqstack *s,int i)/*增加栈顶*/
{
if(s->length>=s->stacksize)
{
printf("路过");
s->base=(int *)realloc(s->base,(STACK_INI_SIZE+STACKINCREMENT)*sizeof(int));
if(!s->base)
exit(1);
s->top=s->base+s->length;
s->stacksize+=STACKINCREMENT;
stackinput(s);
}
if(s->length==0)
{
*(s->base)=i;
s->top++;
s->length++;
}
else
{
*(s->top)=i;
s->top++;
s->length++;
}
}
/*********************************************/
void stackpop(sqstack *s)/*删除栈顶*/
{
if(s->length==0)
printf("栈空 无法删除");
if(s->length==1)
{
s->top--;
*(s->top)=*(s->base)=NULL;
s->length=0;
}
else
{
s->top--;
*(s->top)=NULL;
s->length--;
}
}
/*********************************************/
void stackinput(sqstack *s)/*迷宫栈的输出*/
{
int w,x,y,z,i=0,*p;
p=s->base;
p++;
printf("迷宫正确路径\n");
while(p!=s->top)
{
printf("(%d%d,%d%d)",x=*p/1000,y=*p/100%10,z=*p%100/10,w=*p%10);
p++;
i++;
if(i==7)
{
printf("\n");
i=0;
}
}
}
/*********************************************/
int mgway(sqstack *s)/*迷宫路径*/
{
int gudge(sqstack *s,int);/*判断是否能通行*/
int homing(sqstack *s);/*退栈后I所对应的方向*/
int i=1,j,k;
while(s->top!=s->base)
{
if(i<5)
j=gudge(s,i);
if(j==1&&i<5)
{
k=m*100+n;
stackpush(s,k);
if(m==y-2&&n==x-2)
{
return(1);
}
else
i=1;
}
else
{
if(m==0&&n==0)
return(0);
else if(i==4||i==5)
{
i=homing(s);
stackpop(s);
i++;
}
else
i++;
}
}
return(0);
}
/*********************************************/
int gudge(sqstack *s,int i)/*退栈后i所对应的方向*/
{
int echo(sqstack *s);
if(i==1)
n++;
if(i==2)
m++;
if(i==3)
n--;
if(i==4)
m--;
if((mg[m][n]==0||mg[m][n]==2)&&echo(s))
return(1);
else
{
if(i==1)
n--;
if(i==2)
m--;
if(i==3)
n++;
if(i==4)
m++;
return(0);
}
}
/*********************************************/
int echo(sqstack *s)
{
int i,*p,*q;
i=m*100+n;
p=s->top;
q=s->base;
q++;
p--;
while(p!=q&&*p!=i)
p--;
if(*p==i)
return(0);
else
return(1);
}
/*********************************************/
int homing(sqstack *s)/*i退位后所对应的方向*/
{
int a,b,c,d,*q;
q=s->top;
q--;
a=(*q)/100;
b=(*q)%100;
q--;
c=(*q)/100;
d=(*q)%100;
m=(*q)/100;
n=(*q)%100;
if(a==c)
{
if(d-b==1)
return(3);
else if(d-b==-1)
return(1);
}
else if(b==d)
{
if(c-a==1)
return(4);
else if(c-a==-1)
return(2);
}
return(0);
}
void destorystack(sqstack *s)
{
if(*(s->base)!=NULL)
free(s->base);
s->length=0;
}
/*********************************************/
void makemg(sqstack *s)/*创建迷宫及输出迷宫图的函数*/
{
int mgway(sqstack *s);
void clearstack(sqstack *s);
int flag=1,flag2=1,i,j,k;
char ch;
while(flag)
{
printf("请输入迷宫的长宽(长度范围2-15,宽范围2-15)\n");
printf("输入长");
fflush(stdin);
scanf("%d",&y);
printf("输入宽");
fflush(stdin);
scanf("%d",&x);
if(x<16&&x>3&&y>3&&y<16)
flag=0;
if(flag==0)
printf("自动筛选能通过的迷宫需要一段时间,请耐心等待,如20秒后无法显示出迷宫样本请重试... ...\n");
}
flag=1;
while(flag2)
{
m=1;
n=1;
for(i=0;i<x;i++)
for(j=0;j<y;j++)
mg[i][j]=rand()%3;
i=0;
for(j=0;j<y;j++)
{
mg[i][j]=1;
mg[j][i]=1;
}
i=y-1;
for(j=0;j<x;j++)
mg[j][i]=1;
i=x-1;
for(j=0;j<y;j++)
mg[i][j]=1;
mg[1][1]=0;
mg[x-2][y-2]=0;
k=mgway(s);
if(k==1)
flag2=0;
else
clearstack(s);
}
printf(" ");
for(i=0;i<y;i++)
printf("%2d",i);
printf("\n ");
for(i=0;i<y;i++)
printf("↓");
printf("\n");
for(i=0;i<x;i++)
{
printf("%2d→",i);
for(j=0;j<y;j++)
{
if(mg[i][j]==2)
printf("0 ");
else
printf("%d ",mg[i][j]);
}
printf("\n");
}
}
/*********************************************/
void clearstack(sqstack *s)/*清空栈对于此程序而言*/
{
s->top=s->base;
*(s->base)=0;
s->top++;
*(s->top)=101;
s->top++;
s->length=2;
}