c语言老鼠迷宫
⑴ c语言老鼠走迷宫问题
从程序上来看 也就是说在调用这个visit函数时，如果maze[i][j]这个点的上下左右都不是0的话 也就是进入了死胡同 那么就把这个点置为0。
你可以把这个程序这样子改一下，
if(visit(startI, startJ) == 0)
{
printf("\n没有找到出口！\n");
printf("\n显示路径：\n");
for(i = 0; i < 7; i++) {
for(j = 0; j < 7; j++) {
if(maze[i][j] == 2)
printf("█");
else if(maze[i][j] == 1)
printf("◇");
else
printf(" ");
}
else
{
printf("\n显示路径：\n");
for(i = 0; i < 7; i++) {
for(j = 0; j < 7; j++) {
if(maze[i][j] == 2)
printf("█");
else if(maze[i][j] == 1)
printf("◇");
else
printf(" ");
}
printf("\n");
这样对你调试程序和理解程序都有帮助，希望对你有用。
⑵ C语言数据结构 老鼠走迷宫问题
/* 迷宫矩阵
1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 1 0 0 0 1
1 1 1 0 0 1 0 1 0 1
1 0 0 0 1 0 0 0 0 1
1 0 0 0 0 1 0 1 0 1
1 1 0 1 0 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1
1 1 0 0 0 1 0 0 0 1
1 1 1 1 1 1 1 1 1 1
*/
#include<stdio.h>
#define m 7
#define n 8
void path()
{
int maze[m+2][n+2] ;
int move[4][2]={ {0,-1},{-1,0},{0,1},{1,0} };
int s[54][3];
int top=0;
int i,j,k,f=0;
int g,h,p;
for(i=0;i<m+2;++i)
for(j=0;j<n+2;++j)
scanf("%d",&maze[i][j]);
maze[1][1]=2;
s[top][0]=1;
s[top][1]=1;
s[top][2]=0;
++top;
while(top!=0&&f==0)
{
--top;
i=s[top][0];
j=s[top][1];
k=s[top][2];
while(k<4)
{
g=i+move[k][0];
h=j+move[k][1];
if(g==m&&h==n&&maze[g][h]==0)
{
for(p=0;p<top;++p)
printf("%3d,%d\n",s[p][0],s[p][1]);
printf("%3d,%d\n",i,j);
printf("%3d,%d\n",m,n);
f=1;
}//if
if(maze[g][h]==0)
{
maze[g][h]=2;
s[top][0]=i;
s[top][1]=j;
s[top][2]=k;
++top;
i=g;
j=h;
k=0;
}//if
k=k+1;
}//while
}//while
if(f==0)
printf("no path\n");
}//pathvoid main()
{
path();
}
⑶ 数据结构 c语言 课程设计 小鼠走迷宫问题
1、可以用“*”来代表老鼠，“|”来代表墙，空格来代表路。每走一步用system("cls")刷新一次屏幕。
2、墙不可穿过代表，墙与周围的格子没有边。
3、规定一个时间t，若在t步之内没有走到粮仓，则输出无解。
4、这个简单，无非就是修改条件，从而修改整个图。
5、所用路径可以用深搜（回朔）来解决，最短路就用广搜来解决。最短路也可以用Dijstra算法、floyd算法等，但广搜是最简单的。
具体的程序你自己实现吧，如果写不出来，就去请教一下你们学校的ACMer，他们应该会比较熟悉。加油吧。
⑷ 关于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还是不错滴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]=,,,};//行增量和列增量 方向依次为东西南北
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语言 老鼠走迷宫
可以给你点提示：迷宫 可用个二维数组表示。求解方法是：从入口出发，顺某个方向走，若能过去，继续；否则，沿着原路返回，换方向继续走，直到所有可能的通路都被找到为止。为保证在任何位置上都能沿原路退回，需要一个先进后出的栈结构保存从入口到当前位置的路径。这里，给个算法的思想，不实现图形界面了。假设迷宫数据存放在一txt中：
迷宫数据
8 8 //迷宫的大小，行数与列数
1 1 8 8 //1 1 表入口位置 8 8 表出口位置
0 0 1 0 0 0 1 0 //以下表迷宫，1表示墙、0表示通路，为避免走的过程中越界，最好在四周加上以堵墙。
0 0 1 0 0 0 1 0
0 0 0 0 1 1 0 0
0 1 1 1 0 0 0 0
0 0 0 1 0 0 0 0
0 1 0 0 0 1 0 0
0 1 1 1 0 1 1 0
1 1 0 0 0 0 0 0
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 50
#define ERROR -1
#define OK 0
#define FALSE 0
#define TRUE 1
typedef enum{RIGHT,DOWN,LEFT,UP} Direction;
typedef enum{YES,NO} MarkTag;
typedef struct position{ //迷宫中位置的坐标
int x;
int y;
}Position;
typedef struct{ //当前位置在路径中的序号
int order; //当前位置在迷宫中的坐标
Position seat; //从当前位置走到下一位置的方向
Direction di; //栈元素的类型
}SElemType;
typedef struct{
SElemType *elem;
int top;
}Stack;
char maze[MAXSIZE+2][MAXSIZE+2]; //用二维数组表示迷宫
int InitStack(Stack *S){ //创建一个空栈
S->elem=(SElemType *)malloc(MAXSIZE*MAXSIZE*sizeof(SElemType));
if(!S->elem)
return ERROR;
S->top=0;
return OK;
}
int Push(Stack *S,SElemType e){ //元素e入栈
if(S->top>=MAXSIZE*MAXSIZE)
return ERROR;
S->elem[S->top++]=e;
return OK;
}
int Pop(Stack *S,SElemType e){ //栈顶元素出栈，由e带回栈顶元素
if(S->top<=0)
return ERROR;
*e=S->elem[--S->top];
return OK;
}
int Empty(Stack S){ //若栈为空，返回TRUE,否则返回FALSE
if(S.top==0)
return TRUE;
return FALSE;
}
int createMaze(char *filename,Position *startpos,Position *endpos){ //从文件filename读入数据创建迷宫，由参数带回入口位置和出口位置
FILE *fp;
int i,j,rows,cols,temp;
Position start,end;
fp=fopen(filename,"r");
if(!fp){
printf("open file %s error!\n",filename);
return ERROR;
}
if(!feof(fp)){
fscanf(fp,"%d %d",&rows,&cols); //读入迷宫的行数和列数
fscanf(fp,"%d %d",&start.x,&start.y); //读入迷宫的入口位置
fscanf(fp,"%d %d",&end.x,&end.y); //读入迷宫的出口位置
}
for(i=1;i<=rows;i++) //读入迷宫数据
for(j=1;j<=cols;j++){
fscanf(fp,"%d",&temp);
maze[i][j]=48+temp;
}
fclose(fp);
//在迷宫四周加墙
for(i=0,j=0;i<=rows+1;i++) maze[i][j]='1';
for(i=0,j=cols+1;i<=rows+1;i++) maze[i][j]='1';
for(i=0,j=0;j<=cols+1;j++) maze[i][j]='1';
for(i=rows+1,j=0;j<=cols+1;j++) maze[i][j]='1';
*startpos=start;
*endpos=end;
return OK;
}
int canPass(Position curpos){
if(maze[curpos.x][curpos.y]=='0')
return TRUE;
return FALSE;
}
void markPos(Position curpos,MarkTag tag){ //为已走过的位置标记
switch(tag){
case YES: maze[curpos.x][curpos.y]='.'; break; //路径标记
case NO: maze[curpos.x][curpos.y]='#'; break; //死胡同标记
}
}
Position nextPos(Position curpos,Direction dir){ //根据当前的位置坐标和下一步要探索的方向dir求下一步要走的位置坐标
Position nextpos;
switch(dir){
case RIGHT: nextpos.x=curpos.x; nextpos.y=curpos.y+1; break;
case DOWN: nextpos.x=curpos.x+1; nextpos.y=curpos.y; break;
case LEFT: nextpos.x=curpos.x; nextpos.y=curpos.y-1; break;
case UP: nextpos.x=curpos.x-1; nextpos.y=curpos.y; break;
}
return nextpos;
}
Direction nextDir(Direction dir){
switch(dir){ //按照RIGHT DOWN LEFT UP的次序进行路径探索
case RIGHT: return DOWN;
case DOWN: return LEFT;
case LEFT: return UP;
}
}
/*若迷宫中存在从入口start到出口end的通道，则求得一条存放在栈S中，并返回TRUE，若不存在则返回FALSE*/
int Solve(Stack *S,Position start,Position end){
Position curpos;
SElemType e;
int curstep=1;
if(InitStack(S)==ERROR)
return FALSE;
curpos=start;
do{
if(canPass(curpos)){ //当前位置可以通过
markPos(curpos,YES); //留下足迹
e.order=curstep;
e.seat=curpos;
e.di=RIGHT;
Push(S,e);
if(curpos.x==end.x && curpos.y=end.y)
return TRUE; //找到从入口到出口的通道
curpos=nextPos(curpos,RIGHT);
curstep++;
}
else{
if(!Empty(*S)){ //当前位置不能通过
if(Pos(S,&e)==ERROR)
return FALSE;
while(e.di==UP && !Empty(*S)){ //4个方向都找不到通路，则回溯
curpos=e.seat;
markPos(curpos,NO);
if(Pop(S,&e)==ERROR)
return FALSE;
}
if(e.di!=UP){ //4个方向还没有探索完
e.di=nextDir(e.di);
Push(S,e); //换下一个方向探索
curpos=nextPos(e.seat,e.di);
}
}
}while(!Empty(*S));
return FALSE;
}
void main(void){
Position startPos,endPos;
Stack path;
SElemType e;
char *fname="in.txt";
if(createMaze(fname,&startPos,&endPos)==ERROR) return;
Solve(&path,startPos,endPos);
while(!Empty(path)){ //输出出口到入口的路径
Pop(&path,&e);
printf("(%d,%d)\n",e.seat.x,e.seat.y);
}
}
⑹ 走迷宫的C语言版代码求助 程序开始运行时显示一个迷宫地图，迷宫中央有一只老鼠，迷宫的右下方有一个粮
/*注：本程序探索迷宫的优先顺序=> 1-下、2-右、3-上、4-左 <=总体趋势：下右，逆时针方向。因为出口就在右边下方*/
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define stack_init_size 200
#define stack_increment 10
#define OVERFLOW 0
#define OK 1
#define ERROE 0
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef struct{
int x;
int y;
}PosType;
typedef struct {
int ord; // 通道块在路径上的"序号"
PosType seat; //通道块在迷宫中的"坐标位置"
int di; //从此通道块走向下一通道块的"方向"
}SElemType;
typedef struct{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;
int mg[20][20];
/*随机生成迷宫的函数
/*为了能够让尽量能通过，将能通过的块和不能通过的块数量比大致为2:1*/
void Random(){
int i,j,k;
srand(time(NULL));
mg[1][0]=mg[1][1]=mg[18][19]=0; //将入口、出口设置为"0"即可通过
for(j=0;j<20;j++)
mg[0][j]=mg[19][j]=1; /*设置迷宫外围"不可走"，保证只有一个出口和入口*/
for(i=2;i<19;i++)
mg[i][0]=mg[i-1][19]=1; /*设置迷宫外围"不可走"，保证只有一个出口和入口*/
for(i=1;i<19;i++)
for(j=1;j<19;j++){
k=rand()%3; //随机生成0、1、2三个数
if(k)
mg[i][j]=0;
else{
if((i==1&&j==1)||(i==18&&j==18)) /*因为距入口或出口一步的路是必经之路，故设该通道块为"0"加大迷宫能通行的概率*/
mg[i][j]=0;
else
mg[i][j]=1;
}
}
}
//构造一个空栈
Status InitStack(SqStack &s){
s.base =(SElemType *)malloc(stack_init_size * sizeof(SElemType));
if(!s.base) return OVERFLOW;
s.top=s.base;
s.stacksize=stack_init_size;
return OK;
}
//当前块可否通过
Status Pass(PosType e){
if (mg[e.x][e.y]==0) //0时可以通过
return OK; // 如果当前位置是可以通过，返回1
return OVERFLOW; // 其它情况返回0
}
//留下通过的足迹
Status FootPrint(PosType e){
mg[e.x][e.y]=7;
return OK;
}
//压入栈
Status Push(SqStack &s,SElemType e){
if(s.top-s.base>=s.stacksize){
s.base=(SElemType *)realloc(s.base,(s.stacksize+stack_increment) *sizeof(SElemType));
if(!s.base)exit(OVERFLOW);
s.top=s.base+s.stacksize;
s.stacksize+=stack_increment;
}
*s.top++=e;
return OK;
}
//出栈
Status Pop(SqStack &s,SElemType &e){
if(s.top==s.base)
return ERROE;
e=*--s.top;
return OK;
}
//下一步
PosType NextPos(PosType &e,int dir){
PosType E;
switch(dir){
case 1:E.x=e.x; //向下
E.y=e.y+1;
break;
case 2:E.x=e.x+1; //向右
E.y=e.y;
break;
case 3:E.x=e.x; //向上
E.y=e.y-1;
break;
case 4:E.x=e.x-1; //向左
E.y=e.y;
break;
}
return E;
}
//是否空栈
Status StackEmpty(SqStack s){
if (s.top==s.base)
return OK;
return OVERFLOW;
}
//留下不能通过的足迹
Status MarkPrint(PosType e){
mg[e.x][e.y]=3;
return OK;
}
//迷宫函数
// 若迷宫maze中从入口 start到出口 end的通道，则求得一条存放在栈中
// （从栈底到栈顶），并返回TRUE；否则返回FALSE
Status MazePath(int mg,PosType start,PosType end,SqStack &s){
PosType curpos;
InitStack(s);
SElemType e;
int curstep;
curpos=start; // 设定"当前位置"为"入口位置"
curstep=1; // 探索第一步
do{
if(Pass(curpos)){ // 当前位置可通过，即是未曾走到过的通道块
FootPrint(curpos); // 留下足迹
e.di =1;
e.ord = curstep;
e.seat= curpos;
Push(s,e); // 加入路径
if(curpos.x==end.x&&curpos.y==end.y){
printf("\n\n0∩_∩0 能到达终点!");
return TRUE;
}
curpos=NextPos(curpos,1); // 下一位置是当前位置的东邻
curstep++; // 探索下一步
}
else{ // 当前位置不能通过
if(!StackEmpty(s)){
Pop(s,e);
while(e.di==4&&!StackEmpty(s)){
MarkPrint(e.seat);
Pop(s,e);
}
if(e.di<4){
e.di++;
Push(s,e); // 留下不能通过的标记，并退回一步
curpos=NextPos(e.seat,e.di); /* 当前位置设为新方向的相邻块*/
}//if
}//if
}//else
}while(!StackEmpty(s));
printf("\n\n囧 ! 不能到达终点!");
return FALSE;
}
//打印迷宫
void PrintMaze(){
int i,j;
printf("运行路径:\n\n");
for(i=0;i<20;i++){
for(j=0;j<20;j++){
if(mg[i][j]==0)printf(" ");
else if(mg[i][j]==1) printf("■"); //迷宫的"墙"
else if(mg[i][j]==3) printf("◇"); //不通的路
else if(mg[i][j]==7)printf("○"); //通过的路径
}
printf("\n");
}
printf("\n");
}
void main(){
SqStack S;
PosType start,end;
start.x=1;start.y=0; //起点坐标
end.x=18;end.y=19; //终点坐标
printf("\n==================迷宫游戏==================");
printf("\n说明:■不能走的区域\t◇走不通的区域");
printf("\n '空格'代表未到过的区域");
printf("\n ○代表能通过的路径，指向终点");
printf("\n============================================");
Random();
printf("\n\nTest 1:");
MazePath(mg[20][20],start,end,S);
PrintMaze();
system("pause");
Random();
printf("\nTest 2:");
MazePath(mg[20][20],start,end,S);
PrintMaze();
system("pause");
Random();
printf("\nTest 3:");
MazePath(mg[20][20],start,end,S);
PrintMaze();
printf("\n==========程序退出，感谢使用!==========\n");
}
⑺ 求个c++源码 走迷宫 程序开始运行时显示一个迷宫地图，迷宫中央有一只老鼠，迷宫的右下方有一个粮仓
输入地图时：1代表不可通行，0代表可通行，自动增加边框（墙壁），且左上角左边一格为入口，右下角右边一格为出口
编译通过，代码如下：
#include<stdio.h>
#include<stdlib.h>
#defineN50
int**maze;
introw;
intcol;
intstack[50];//存放路径的栈
voidCreateMaze()//用于动态创建迷宫
{
inti,j;
printf("请输入迷宫的行数：");
scanf("%d",&row);
printf("请输入迷宫的列数：");
scanf("%d",&col);
if(row<=0||col<=0)
{
printf("输入的行数或列数不符合规则！ ");
exit(1);
}
//利用指针的指针动态创建二维数组
maze=(int**)malloc((row+2)*sizeof(int*));
for(i=0;i<row+2;i++)
{
maze[i]=(int*)malloc((col+2)*sizeof(int));
}
//加边墙
for(i=0;i<row+2;i++)
{
maze[i][0]=1;
maze[i][col+1]=1;
}
for(i=0;i<col+2;i++)
{
if(i==1)
{
maze[0][i]=0;
}
elsemaze[0][i]=1;
if(i==col)
{
maze[row+1][col]=0;
}
elsemaze[row+1][i]=1;
}
for(i=1;i<=row;i++)
{
for(j=1;j<=col;j++)
{
printf("请输入第%d行的第%d个数: ",i,j);
scanf("%d",&maze[i][j]);
}
}
//输入下一个当前加边墙的迷宫，以验证输入是否正确
printf("输入完毕！当前加边墙的迷宫为： ");
for(i=0;i<row+2;i++)
{
for(j=0;j<col+2;j++)
{
printf("%d ",maze[i][j]);
}
printf(" ");
}
}
voidShowMaze()//输出迷宫
{
inti,j;
for(i=1;i<=row;i++)
{
for(j=1;j<=col;j++)
{
printf("%d ",maze[i][j]);
}
printf(" ");
}
}
//释放迷宫数组
voidDestroyMaze()
{
inti;
for(i=0;i<row+2;i++)
free(maze[i]);
free(maze);
}
//用DFS方法来实现回溯，找到迷宫的一条解路径
intFindPath()
{
inti,j,k,count,x,y,direction;
count=0;
x=1,y=1;
direction=0;
j=0,k=0;
for(i=0;i<N;i++)
{
stack[i]=0;
}
i=0;
while(1)
{
count=0;//用count判断是否有路可走
{
if(x==1&&y==1)
maze[x][y]=2;
if(maze[x][y+1]==0)//东
{
count++;
maze[x][y+1]=2;
y=y+1;
stack[i]=-1;
i++;
if(x==row&&y==col)
return1;
}
elseif(maze[x+1][y]==0)//南
{
if(maze[x+1][y]==0)
count++;
{
maze[x+1][y]=2;
x=x+1;
stack[i]=-2;
i++;
if(x==row&&y==col)
return1;
}
}
elseif(maze[x][y-1]==0)//西
{
count++;
if(maze[x][y-1]==0)
{
maze[x][y-1]=2;
y=y-1;
stack[i]=-3;
i++;
if(x==row&&y==col)
return1;
}
}
elseif(maze[x-1][y]==0)//北
{
count++;
if(maze[x-1][y]==0)
{
maze[x-1][y]=2;
x=x-1;
stack[i]=-4;
i++;
if(x==row&&y==col)
return1;
}
}
}
if(count==0)
{
if(i<0)
return0;
direction=stack[i--];
switch(direction)
{
case-1:y=y-1;break;
case-2:x=x-1;break;
case-3:y=y+1;break;
case-4:x=x+1;break;
default:break;
}
}
}
}
intmain()
{
CreateMaze();
if(FindPath())
{
printf("已经找到了一条路径，如下: ");
ShowMaze();
}
else
{
printf("没有合适的路径走出当前迷宫！ ");
}
DestroyMaze();
}
⑻ 怎么编写老鼠走迷宫游戏
菜单栏上点“项目”，选择“属性”，选择“配置属性”，选择“常规”，编码方式改为“多字节”，也就是multibytes，系统默认是Unicode，所以会报这个错。
老鼠走迷宫你是想要怎么样的，详细要求说清楚点，还有，这么点分，怕是没人愿意做，写一个大的工程，至少200分才说的过去嘛，要写代码，调试，很耗时间的，大哥。
⑼ C语言老鼠迷宫问题求解
很简单 DFS 直到到达出口，存储过程中走过的所有点，然后输出就行了
⑽ 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还是不错滴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");
}