走迷宫c语言没路怎么办

Ⅰ 数据结构c语言版的迷宫问题如何解决

#include"iostream.h"
#include"stdlib.h"
#include"stdio.h"
#define M 10
#define N 10
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=4; //方向输出为-1 判断是否到了出口
Push(S1,elem);
printf("0=东 1=南 2=西 3=北 4为则走出迷宫\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);
}
printf("成功 !\n");
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; //迷宫行,列
printf("请输入迷宫的行数 m=");
scanf("%d",&m);
printf("请输入迷宫的列数 n=");
scanf("%d",&n);
printf("请输入迷宫的各行各列:(用空格隔开,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}};//行增量和列增量 方向依次为东西南北
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); //寻找路径
}

Ⅱ 高分C语言迷宫问题！！高手求救！急！！！

下面的问题是一个C语言迷宫问题解决方法及代码，有兴趣的可以研究一下，多多研究别人的代码能提高自己的水平。
【问题描述】
以一个 m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路。或得出没有通路的结论
【基本要求】

【测试数据】

【实现提示】
使用 穷举法和栈求解
【代码过程】
1。
//base.h
//------------------- 公用的常量和类型 ----------------------------
#include<stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status; //函数的返回值
typedef int DirectiveType; //下一个通道方向

#define RANGE 100 //迷宫大小

//~

2。

//stack.h
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

//------------ 栈的顺序存储实现 ------------------------------
typedef struct...{
int row;
int col;
}PosType;

typedef struct...{
int step; //当前位置在路径上的"序号"
PosType seat; //当前的坐标位置
DirectiveType di; //往下一个坐标位置的方向
}SElemType;

typedef struct...{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;

//----------------- 栈的基本操作的算法实现 --------------------------------
Status InitStack(SqStack &s)...{
s.base = (SElemType * ) malloc(STACK_INIT_SIZE * sizeof(SElemType));
if(!s.base) exit(OVERFLOW);
s.top=s.base;
s.stacksize=STACK_INIT_SIZE;
return OK;
}

Status GetTop(SqStack s, SElemType &e )...{
if( s.top == s.base) return ERROR;
e = *(s.top-1);
return OK;
}

Status Push(SqStack &s, SElemType e)...{
if(s.top-s.base >= s.stacksize)...{ //栈满，追加存储空间
s.base = (SElemType *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!s.base) exit(OVERFLOW);
s.top = s.base + s.stacksize;
s.stacksize += STACKINCREMENT;
}
*s.top++ = e;
return OK;
}

Status Pop(SqStack &s, SElemType &e)...{
if(s.top==s.base)return ERROR;
e = * --s.top;
return OK;
}

int StackEmpty(SqStack s)
...{
return s.base == s.top;
}

Status ClearStack(SqStack &s)
...{
s.top = s.base;
return OK;
}
//~
3。

//maze.h
//-------------------- 迷宫程序 ----------------------------------
/**//**************************************************************
迷宫问题算法: 从入口出发,顺着某一个方向进行探索,若能走通,则继续
前进;否则沿着原路退回,换一个方向继续探索,直至出口位置,求得一条通路,
假如所有可能的通路都探索到而未能达到出口,则所设定的迷宫没有通路.
说明:可通: 未增走到过的通道快.
*********************************************************/
#define ROW 9 //迷宫的行数
#define COL 8 //迷宫的列数

typedef struct...{
int m,n;
int arr[RANGE][RANGE];
}MazeType; //迷宫类型

Status InitMaze(MazeType &maze, int a[][COL], int row, int col)...{
//按照用户输入的row行和col列的二维数组(0/1)
//设置迷宫maze的初值,包括加上边缘一圈的值
for(int i=1;i<=row;i++)...{
for(int j=1;j<=col;j++)...{
maze.arr[i][j] = a[i-1][j-1];
}
}
//加上围墙
for(int j=0;j<=col+1;j++)...{
maze.arr[0][j] = maze.arr[row+1][j]=1;
}
for(i=0;i<=row+1;i++)...{
maze.arr[i][0] = maze.arr[i][col+1]=1;
}
maze.m = row, maze.n = col;
return OK;
}

Status Pass(MazeType maze,PosType curpos)...{
//判断当前节点是否通过
return maze.arr[curpos.row][curpos.col] == 0;
}

Status FootPrint(MazeType &maze,PosType curpos)...{
//留下足迹
maze.arr[curpos.row][curpos.col]=’*’;
return OK;
}

Status MarkPrint(MazeType &maze,PosType curpos)...{
//留下不能通过的标记
maze.arr[curpos.row][curpos.col]=’@’;
return OK;
}

SElemType CreateSElem(int step, PosType pos, int di)...{
SElemType e;
e.step = step; e.seat = pos; e.di = di;
return e;
}

PosType NextPos(PosType curpos, DirectiveType di)...{
//返回当前节点的下一节点
PosType pos = curpos;
switch(di)
...{
case 1: //东
pos.col++;
break;
case 2: //南
pos.row++;
break;
case 3: //西
pos.col--;
break;
case 4: //北
pos.row--;
break;
}
return pos;
}

Status PosEquare(PosType pos1, PosType pos2)...{
//判断两节点是否相等
return pos1.row==pos2.row && pos1.col==pos2.col ;
}

void PrintMaze(MazeType maze,int row,int col)...{
//打印迷宫信息
for(int i=1;i<=row;i++)...{
for(int j=1;j<=col;j++)...{
switch(maze.arr[i][j])
...{
case 0:
printf(" ");
break;
case ’*’:
printf("* ");
break;
case ’@’:
printf("@ ");
break;
case 1:
printf("# ");
break;
}
}
printf(" ");
}
}

Status MazePath(MazeType &maze,PosType start, PosType end)...{
//求解迷宫maze中,从入口start到出口end的一条路径
//若存在,返回TRUE,否则返回FALSE
SqStack s;SElemType e;
InitStack(s);
PosType curpos = start;
int curstep = 1; //探索第一部
do...{
if( Pass(maze,curpos) )...{ //如果当前位置可以通过,即是未曾走到的通道块
FootPrint(maze,curpos); //留下足迹
e = CreateSElem(curstep,curpos,1); //创建元素
Push(s,e);
if( PosEquare(curpos,end) ) return TRUE;
curpos =NextPos(curpos,1); //获得下一节点:当前位置的东邻
curstep++; //探索下一步
}else...{ //当前位置不能通过
if(!StackEmpty(s))...{
Pop(s,e);
while(e.di==4 && !StackEmpty(s) )...{
MarkPrint(maze,e.seat); Pop(s,e);curstep--; //留下不能通过的标记,并退回一步
}
if(e.di<4)...{
e.di++; Push(s,e); //换一个方向探索
curpos = NextPos(e.seat,e.di); //求下一个节点
}
}
}
}while(!StackEmpty(s));
return FALSE;
}
//~

4。

//test.cpp
#include "base.h"
#include "stack.h"
#include "maze.h"

/**//**************** 测试 ***********************************/
void main()
...{
int a[ROW][COL];
printf("enter the maze’s data: ");
for(int i=0;i<ROW;i++)
...{
for(int j=0; j<COL;j++)
...{
scanf("%d",&a[i][j]);
}
}
PosType start,end;
start.row = 1;start.col=1;
end.row = 9; end.col = 8;
MazeType maze;
InitMaze(maze,a,ROW,COL);
Status ok = MazePath(maze,start,end);
if(ok) PrintMaze(maze,ROW,COL);
else printf("没有找到通路");
}

Ⅲ c语言迷宫小游戏，10乘10大小的迷宫，我拿别人的代码修改的，为什么结果总是显示找不到路径，代码如下

这个代码太多，明显是不会看的节奏，但是我可以给出我的一个简化的方案或者说是一个思路

首先这明显是个搜索题：

1. 我到了一个迷宫的一个点 它有上下左右四个方向可以去走吧，

   所以简便方法 ：：先定义int x[4] ={0, 0, -1, +1};

   int y[4]={1, -1, 0, 0};

2. 我走迷宫肯定要标记的吧，不然我来回走不是永远也走不玩么;

所以我定义一个数组int is_walk_by[row][colum];

3.然后我开始走了

bool zoulu( int a, int b){

//判断走对了的方法，再来个剪枝

主体

for( int i=0;i<4;i++){

xx= a+x[i];

yy= b+x[i];

mark[xx][yy]=1;//假设已经走过

if(zoulu(xx, yy)){

return true;

}

else {

mark[xx][yy]=0;//还原

return false;

}

}

//这好像是个递归深搜的方法，看看对你有没有用吧，没用当我没说

Ⅳ C语言设计的迷宫问题 哪里出错了

1.手动输入迷宫后，总是输出没有路径，而且数组也无法正常输出。自动生成迷宫是正常的。

printf("Enter the %d * %d maze:\n",m,m); /*手动输入*/
for (x=1; x<=m; x++)
for(y=1; y<=m; y++)
{
scanf("%d",&maze[x][y]);
}

scanf("%d",&maze[x][y]); 这里不对, 为何不用scanf("%s",&maze[x][y]);

2.最后“Would you want to try again? 1or0”，无论输入1或是0，程序都会循环无法停止。
while(d==1)改为while(1)
在scanf("%d",&d)下面加入
if(d==0)
break;

3.我是用“.”表示的路径，怎样将最后的路径用连线连起来？在vc环境下。
在DOS界面下不太好画线, 我觉得你的路径表示很好了

Ⅳ C语言迷宫求解如何找到所有的路

迷宫源程序*/
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>

Ⅵ 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语言编写迷宫游戏

#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#define N 20/*
迷宫的大小，可改变
*/
int oldmap[N][N];/*
递归用的数组
,
用全局变量节约时间
*/
int yes=0;/*yes
是判断是否找到路的标志
,1
找到，
0
没找到
*/
int way[100][2],wayn=0;/*way
数组是显示路线用的
,wayn
是统计走了几个格
子
*/
void Init(void);/*
图形初始化
*/
void Close(void);/*
图形关闭
*/
void DrawPeople(int *x,int *y,int n);/*
画人工探索物图
*/
void PeopleFind(int (*x)[N]);/*
人工探索
*/
void
WayCopy(int
(*x)[N],int
(*y)[N]);/*
为了
8
个方向的递归，把旧迷宫图
拷贝给新数组
*/
int FindWay(int (*x)[N],int i,int j);/*
自动探索函数
*/
void MapRand(int (*x)[N]);/*
随机生成迷宫函数
*/
void PrMap(int (*x)[N]);/*
输出迷宫图函数
*/
void Result(void);/*
输出结果处理
*/
void Find(void);/*
成功处理
*/
void NotFind(void);/*
失败处理
*/
void main(void)/*
主函数
*/
{
int map[N][N]; /*
迷宫数组
*/
char ch;
clrscr();
printf("\n Please select hand(1) else auto\n");/*
选择探索方式
*/
scanf("%c",&ch);
Init(); /*
初始化
*/
MapRand(map);/*
生成迷宫
*/
PrMap(map);/*
显示迷宫图
*/
if(ch=='1')
PeopleFind(map);/*
人工探索
*/
else
FindWay(map,1,1);/*
系统自动从下标
1,1
的地方开始探索
*/
Result();/*
输出结果
*/
Close();
}
void Init(void)/*
图形初始化
*/
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"c:\\tc"); }
void DrawPeople(int *x,int *y,int n)/*画人工控制图*/ {/*如果将以下两句注释掉，则显示人工走过的路径，*/
setfillstyle(SOLID_FILL,WHITE); /*设置白色实体填充样式*/ bar(100+(*y)*15-6,50+(*x)*15-6,100+(*y)*15+6,50+(*x)*15+6); /*恢复原通路*/
switch(n)/*判断x,y的变化，8个方向的变化*/ {
case 1: (*x)--;break; /*上*/
case 2: (*x)--;(*y)++;break /*右上*/ case 3: (*y)++;break; /*右*/
case 4: (*x)++;(*y)++;break; /*右下*/ case 5: (*x)++;break; /*下*/
case 6: (*x)++;(*y)--;break; /*左下*/ case 7: (*y)--;break; /*左*/
case 8: (*x)--;(*y)--;break; /*左上*/ }
setfillstyle(SOLID_FILL,RED);/*新位置显示探索物*/
bar(100+(*y)*15-6,50+(*x)*15-6,100+(*y)*15+6,50+(*x)*15+6); }
void PeopleFind(int (*map)[N])/*人工手动查找*/ {
int x,y;
char c=0;/*接收按键的变量*/ x=y=1;/*人工查找的初始位置*/ setcolor(11);
line(500,200,550,200); outtextxy(570,197,"d"); line(500,200,450,200); outtextxy(430,197,"a"); line(500,200,500,150); outtextxy(497,130,"w"); line(500,200,500,250); outtextxy(497,270,"x"); line(500,200,450,150); outtextxy(445,130,"q"); line(500,200,550,150); outtextxy(550,130,"e"); line(500,200,450,250); outtextxy(445,270,"z"); line(500,200,550,250);
outtextxy(550,270,"c");/*以上是画8个方向的控制介绍*/
setcolor(YELLOW);
outtextxy(420,290,"Press 'Enter' to end");/*压回车键结束*/ setfillstyle(SOLID_FILL,RED);
bar(100+y*15-6,50+x*15-6,100+y*15+6,50+x*15+6);/*入口位置显示*/ while(c!=13)/*如果按下的不是回车键*/ {
c=getch();/*接收字符后开始各个方向的探索*/ if(c=='w'&&map[x-1][y]!=1) DrawPeople(&x,&y,1);/*上*/ else if(c=='e'&&map[x-1][y+1]!=1) DrawPeople(&x,&y,2);/*右上*/ else if(c=='d'&&map[x][y+1]!=1) DrawPeople(&x,&y,3);/*右*/ else if(c=='c'&&map[x+1][y+1]!=1) DrawPeople(&x,&y,4);/*右下*/ else if(c=='x'&&map[x+1][y]!=1) DrawPeople(&x,&y,5);/*下*/ else if(c=='z'&&map[x+1][y-1]!=1) DrawPeople(&x,&y,6); /*左下*/ else if(c=='a'&&map[x][y-1]!=1) DrawPeople(&x,&y,7); /*左*/ else if(c=='q'&&map[x-1][y-1]!=1) DrawPeople(&x,&y,8); /*左上*/ }
setfillstyle(SOLID_FILL,WHITE); /*消去红色探索物，恢复原迷宫图*/ bar(100+y*15-6,50+x*15-6,100+y*15+6,50+x*15+6); if(x==N-2&&y==N-2)/*人工控制找成功的话*/ yes=1; /*如果成功标志为1*/ }
void WayCopy(int (*oldmap)[N],int (*map)[N])/*拷贝迷宫数组 */ {
int i,j;
for(i=0;i<N;i++) for(j=0;j<N;j++) oldmap[i][j]=map[i][j]; }
int FindWay(int (*map)[N],int i,int j)/*递归找路*/ {

if(i==N-2&&j==N-2)/*走到出口*/ {
yes=1;/*标志为1,表示成功*/ return; }
map[i][j]=1;/*走过的地方变为1*/ WayCopy(oldmap,map); /*拷贝迷宫图*/
if(oldmap[i+1][j+1]==0&&!yes)/*判断右下方是否可走*/ {
FindWay(oldmap,i+1,j+1); if(yes)/*如果到达出口了，再把值赋给显示路线的way数组,也正是这个原因,所以具体路线是从最后开始保存*/ { way[wayn][0]=i; way[wayn++][1]=j; return; } }
WayCopy(oldmap,map);
if(oldmap[i+1][j]==0&&!yes)/*判断下方是否可以走,如果标志yes已经是1也不用找下去了*/ {
FindWay(oldmap,i+1,j); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }
WayCopy(oldmap,map);
if(oldmap[i][j+1]==0&&!yes)/*判断右方是否可以走*/ {
FindWay(oldmap,i,j+1); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }
WayCopy(oldmap,map);
if(oldmap[i-1][j]==0&&!yes)/*判断上方是否可以走*/ {

FindWay(oldmap,i-1,j); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }
WayCopy(oldmap,map);
if(oldmap[i-1][j+1]==0&&!yes)/*判断右上方是否可以走*/ {
FindWay(oldmap,i-1,j+1); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }
WayCopy(oldmap,map);
if(oldmap[i+1][j-1]==0&&!yes)/*判断左下方是否可以走*/ {
FindWay(oldmap,i+1,j-1); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }
WayCopy(oldmap,map);
if(oldmap[i][j-1]==0&&!yes)/*判断左方是否可以走*/ {
FindWay(oldmap,i,j-1); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }
WayCopy(oldmap,map);
if(oldmap[i-1][j-1]==0&&!yes)/*判断左上方是否可以走*/ {

FindWay(oldmap,i-1,j-1); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }
return; }
void MapRand(int (*map)[N])/*开始的随机迷宫图*/ {
int i,j;
cleardevice();/*清屏*/
randomize(); /*随机数发生器*/ for(i=0;i<N;i++) {
for(j=0;j<N;j++) { if(i==0||i==N-1||j==0||j==N-1)/*最外面一圈为墙壁*/ map[i][j]=1; else if(i==1&&j==1||i==N-2&&j==N-2)/*出发点与终点表示为可走的*/ map[i][j]=0; else map[i][j]=random(2);/*其它的随机生成0或1*/ } } }
void PrMap(int (*map)[N])/*输出迷宫图*/ {
int i,j;
for(i=0;i<N;i++) for(j=0;j<N;j++) if(map[i][j]==0) { setfillstyle(SOLID_FILL,WHITE);/*白色为可走的路*/ bar(100+j*15-6,50+i*15-6,100+j*15+6,50+i*15+6); } else { setfillstyle(SOLID_FILL,BLUE);/*蓝色为墙壁*/ bar(100+j*15-6,50+i*15-6,100+j*15+6,50+i*15+6);

} }
void Find(void)/*找到通路*/ {
int i;
setfillstyle(SOLID_FILL,RED);/*红色输出走的具体路线*/ wayn--;
for(i=wayn;i>=0;i--) {
bar(100+way[i][1]*15-6,50+way[i][0]*15-6,100+ way[i][1]*15+6,50+way[i][0]*15+6); sleep(1);/*控制显示时间*/ }
bar(100+(N-2)*15-6,50+(N-2)*15-6,100+ (N-2)*15+6,50+(N-2)*15+6); /*在目标点标红色*/ setcolor(GREEN);
settextstyle(0,0,2);/*设置字体大小*/ outtextxy(130,400,"Find a way!"); }
void NotFind(void)/*没找到通路*/ {
setcolor(GREEN);
settextstyle(0,0,2);/*设置字体大小*/ outtextxy(130,400,"Not find a way!"); }
void Result(void)/*结果处理*/ {
if(yes)/*如果找到*/ Find();
else/*没找到路*/ NotFind(); getch(); }
void Close(void)/*图形关闭*/ {
closegraph(); }

Ⅷ c语言的迷宫问题

//寻路_带权重_带障碍_最短_文件地图_不闪------wlfryq------//
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<windows.h>

typedefstruct
{
	intx;
	inty;
}_PT;

_PTpt;
introw=0,col=0;

//设置CMD窗口光标位置
voidsetxy(intx,inty)
{
COORDcoord={x,y};
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),coord);
}
//获取当前CMD当前光标所在位置
voidgetxy()
{
	HANDLEhConsole=GetStdHandle(STD_OUTPUT_HANDLE);
COORDcoordScreen={0,0};//光标位置
CONSOLE_SCREEN_BUFFER_INFOcsbi;
if(GetConsoleScreenBufferInfo(hConsole,&csbi))
{
	pt.x=csbi.dwCursorPosition.X;
	pt.y=csbi.dwCursorPosition.Y;
}
}

typedefstruct
{
	intx;
	inty;
	inttype;
	intv;
}PT;

PT**s=NULL,stack[50],start,end,c;
intpos=0;

voidprt()
{
	inti,j;
	system("cls");
	for(i=0;i<row;i++)
	{
		for(j=0;j<col;j++)
		{
			if(s[i][j].type==1)
			{
				printf("■");
			}
			elseif(i==end.x&&j==end.y)
			{
				printf("★");
			}
			elseif(i==c.x&&j==c.y)
			{
				printf("◎");
			}
			else
			{
				printf("");
			}
		}
		printf("
");
	}
	Sleep(500);
}

voidstack_in(PTa)
{
	stack[pos++]=a;
}

PTstack_out()
{
	inti;
	PTt;
	t=stack[0];
	for(i=0;i<pos-1;i++)
	{
		stack[i]=stack[i+1];
	}
	pos--;
	returnt;
}

voidfun()
{
	PTa;
	intx,y,v;
	while(1)
	{
		if(pos==0)
		{
			break;
		}
		a=stack_out();
		x=a.x;
		y=a.y;
		if(x==start.x&&y==start.y)
		{
			break;
		}
		v=s[x][y].v;
		if(x-1>=0&&s[x-1][y].type==0&&(s[x-1][y].v==-1||s[x-1][y].v>v+1))
		{
			s[x-1][y].v=v+1;
			stack_in(s[x-1][y]);
		}
		if(x+1<=row-1&&s[x+1][y].type==0&&(s[x+1][y].v==-1||s[x-1][y].v>v+1))
		{
			s[x+1][y].v=v+1;
			stack_in(s[x+1][y]);
		}
		if(y-1>=0&&s[x][y-1].type==0&&(s[x][y-1].v==-1||s[x-1][y].v>v+1))
		{
			s[x][y-1].v=v+1;
			stack_in(s[x][y-1]);
		}
		if(y+1<=col-1&&s[x][y+1].type==0&&(s[x][y+1].v==-1||s[x-1][y].v>v+1))
		{
			s[x][y+1].v=v+1;
			stack_in(s[x][y+1]);
		}
	}
}

voidgo(intx,inty)
{
	printf("
按任意键开始
");
	getchar();
	intv;
	while(1)
	{
		if(x==end.x&&y==end.y)
		{
			setxy(0,y+2);
			printf("end....");
			return;
		}
		v=s[x][y].v;
		if(v==0)
		{
			return;
		}
		if(x-1>=0&&s[x-1][y].v==v-1)
		{
			c=s[x-1][y];
			setxy(y*2,x);
			x=x-1;
			printf("");
			setxy(y*2,x);
			printf("◎");
			Sleep(500);
			continue;
		}
		elseif(x+1<=row-1&&s[x+1][y].v==v-1)
		{
			c=s[x+1][y];
			setxy(y*2,x);
			x++;
			printf("");
			setxy(y*2,x);
			printf("◎");
			Sleep(500);
			continue;
		}
		elseif(y-1>=0&&s[x][y-1].v==v-1)
		{
			c=s[x][y-1];
			setxy(y*2,x);
			y--;
			printf("");
			setxy(y*2,x);
			printf("◎");
			Sleep(500);
			continue;
		}
		elseif(y+1<=col-1&&s[x][y+1].v==v-1)
		{
			c=s[x][y+1];
			setxy(y*2,x);
			y++;
			printf("");
			setxy(y*2,x);
			printf("◎");
			Sleep(500);
			continue;
		}
	}
	printf("
returngo
");
	system("pause");
}

voidGetMapFromFile()
{
	inti,j,x,y,len;
	charch[50]={''};
	FILE*fp=fopen("e:\map1.txt","r");
	if(fp==NULL)
	{
		printf("openfilefailed.
");
		return;
	}
	x=0;
	
	while(!feof(fp))
	{
		fgets(ch,50,fp);
		row++;
	}
	col=strlen(ch);
	fseek(fp,0L,SEEK_SET);
	while(!feof(fp))
	{
		fgets(ch,50,fp);
		if(s==NULL)
		{
			len=strlen(ch);
			for(i=len-1;i>0;i--)
			{
				if(ch[i]!='0'&&ch[i]!='1')
				{
					ch[i]='';
				}
				else
				{
					break;
				}
			}
			len=strlen(ch);
			s=(PT**)malloc(sizeof(PT*)*row);
			for(j=0;j<len;j++)
			{
				*(s+j)=(PT*)malloc(sizeof(PT)*len);
			}
		}
		y=0;
		for(i=0;i<len;i++)
		{
			s[x][y].type=ch[i]-48;
			s[x][y].x=x;
			s[x][y].y=y;
			s[x][y].v=-1;
			y++;
		}
		x++;
	}
	start=s[row-2][1];
	end=s[row-2][len-2];
	fclose(fp);
}

intmain()
{
	GetMapFromFile();
	inti,j;
	intx,y;
	x=end.x;
	y=end.y;
	s[x][y].v=0;
	stack_in(end);
	fun();
	c=start;
	prt();
	go(start.x,start.y);
	return0;
}

Ⅸ C语言：迷宫，求程序，快哭了！好虐。。。

输入这段就不用写了吧。比较简单

A 输入迷宫
用2维数组把这个 迷宫存下来就行了。 墙用0表示 路用1表示。 或者直接用字符的2维数组也行。设为公共变量 migong[m][m] 用公共变量存 m

B 走通判定 (这里以一个迷宫为例，多个迷宫的话 输入那边处理一下就好了，反正中心思想就是1个迷宫用一个2维数组存)
是否能走通的判定。 用迭代法
1 判定周围是否有e(因为e在右下角 只用判断下方和右方就可以了)
2 没有向右走
3 右是墙的话向下走
4 下是墙的话向左走
5 左是墙的话向上走。
bool findway(int startx,int,starty)
{
int end = m - 1;
if(x + 1 == end && y == end || x == end && y + 1 == end )
{
return true; //可以走通 返回YES
}
else if (x + 1 < end && migong[x + 1][y] != '#') //当前点不处于最右侧 且右侧点不为墙的时候
{
findway(startx + 1,starty); //右移
}
else if(y + 1 < end && migong[x][y+1] !='#' ) //当前点不处于最下侧 且下侧点不为墙的时候
{
findway(startx,starty + 1); //下移
}
............................//按照这个思路做 以下省略
}

然后主函数中调用 findway(0,0) 就OK了。

写得比较简单，不好意思。