走迷宮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了。

寫得比較簡單，不好意思。