迷宮小白鼠c語言解說

① c語言迷宮求解如何找到所有的路

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

② 求C語言迷宮程序的解釋說明！！！

我看了一下,演算法應該是一樣的,下面是我以前用C++寫的
相信你能看得懂

/////////////////////////
/////////迷宮求解////////
//////作者:hacker/////
/////時間:11.10.2006/////
/////////////////////////
/*class:
Matrix:矩陣類
offsets:搜索偏移
enum directions:四個方向
struct item:搜索節點
Migong:迷宮類
1.創建一個Migong對象
2.使用用Create方法輸入數據
3.使用Solve方法進行求解
4.ShowSolve方法顯示解
5.可以重復使用Create方法
6.入口只能在左上角
7.默認出口在右下角
ShowAllPath:窮舉所有的路徑
備注:
由於演算法原因,這里的所有路徑應該是指
介於:
a.如果兩條路存在某個點不同那麼就是不同的路
b.如果在一條路中去掉一個或者一個以上的圈,那麼他們是同一條路
之間意義上的路
*/
#include <iostream>
#include <stack>
#include <vector>

using namespace std;

#ifndef MIGONG_H
#define MIGONG_H
///////////////////
///////矩陣類//////
///////////////////
class Matrix{
int* m;
int row, col;
bool iscreate;
public:
Matrix(){m=0;iscreate=false;};
~Matrix() {Release();};
bool Create(int, int);
int& operator () (int, int);
int GetRow(){return row;};
int GetCol(){return col;};
void Release();
void Show(char, char );
};

bool Matrix::Create(int r, int c)
{
if( r<=0 || c<=0) return false;

Release();

row = r;
col = c;
m = new int[row*col];

for (int i=0;i<row*col;i++)
{
*(m+i) = 0;
}
iscreate = true;
return true;
}

int& Matrix::operator ()(int r, int c)
{
return *(m+r*col+c);
}

void Matrix::Release()
{
if (iscreate)
{
row = col = 0;
if (m) delete[] m;
m = 0;
}
iscreate = false;
}

void Matrix::Show(char blk='#', char nblk=' ')
{
int i, j;
for (i=0;i<row;i++)
{
for (j=0;j<col;j++)
{
if (*(m+i*col+j) == 0)
cout<<nblk;
else
cout<<blk;
}
cout<<endl;
}
}
/////////////////////////////
////迷宮相關數據結構的定義///
/////////////////////////////
struct offsets{
int a, b;
};

enum directions{
_S = 0,
_E,
_N,
_W
};

struct item{
int row, col, dir;
};

class Migong{
static offsets move[4];
Matrix maze;
Matrix mark;
int row;
int col;
int desr;
int desc;
stack<item> stk;
bool iscreate;
int pathlength;
bool GetPath();
bool IsInPath(int, int);
public:
Migong(){issolved=false;result=0;pathlength=row=col=0;iscreate=false;};
~Migong(){Release();};
bool Create(int* , int , int , int , int );
void Solve();
void Release();
void OutputMaze();
void ShowSolve(char, char );
public:
bool issolved;
item* result;
};

offsets Migong::move[4]={ {1, 0}, {0, 1},
{-1, 0}, {0, -1}};

////////////////////////////
//迷宮數據應該是不含邊框的//
////////////////////////////
bool Migong::Create(int* m, int r, int c, int desrow=-1, int descol=-1)
{
if (r<=0 || c<=0) return false;

Release();

if (desrow==-1 || descol==-1)
{
desr = r;
desc = c;
}
else
{
desr = desrow;
desc = descol;
}

row = r;
col = c;
maze.Create(r+2, c+2);
mark.Create(r+2, c+2);

int i, j;

for (i=0;i<r+2;i++)
{
for (j=0;j<c+2;j++)
{
if (j==0 || j==c+1 || i==0 || i==r+1)
{
mark(i, j) = maze(i, j) = 1;

}else
{
mark(i, j) = 0;
maze(i, j) = m[((i-1)*col+j-1)];
}
}
}
return iscreate = true;
}

bool Migong::GetPath()
{
mark(1,1) = 1;
item temp;
temp.col = 1;
temp.row = 1;
temp.dir = _S;
stk.push(temp);

while (!stk.empty())
{
temp = stk.top();
stk.pop();

int i = temp.row;
int j = temp.col;
int d = temp.dir;

while (d<4)
{//根據當前點的狀態確定下一個搜索點
int g = i + move[d].a;
int h = j + move[d].b;

if (g==desr && h==desc)
{
return true;
}
//如果這個點不是障礙點且沒有被搜索過那麼可以對這個點進行搜索
if (maze(g, h)==0 && mark(g, h)==0)
{
mark(g, h) = 1;
temp.row = g;
temp.col = h;
temp.dir = d+1;
stk.push(temp);
i = g;
j = h;
d = _S;//對一下個點進行搜索
}
else d++;
}
}
return false;
}

void Migong::Solve()
{
issolved = GetPath();
if (issolved)
{
pathlength = stk.size();
result = new item[pathlength];
for (int i=0;i<pathlength;i++)
{
*(result+i) = stk.top();
stk.pop();
// cout<<"("<<(*(result+i)).row<<","<<(*(result+i)).col<<")"<<endl;
}
}
while (!stk.empty())
stk.pop();
}

void Migong::Release()
{
if (iscreate)
{
maze.Release();
mark.Release();
row=col=0;
if (result)
delete [] result;
result = 0;
while (!stk.empty())
stk.pop();
}
iscreate = false;
issolved = false;
pathlength = 0;
}

void Migong::OutputMaze()
{
if (!iscreate) return;
maze.Show();
}

bool Migong::IsInPath(int r, int c)
{
if (!iscreate || !issolved)
return false;

item temp;
for (int i=0;i<pathlength;i++)
{
temp = *(result+i);
if ((temp.row==r) && (temp.col==c))
return true;
}

return false;
}

void Migong::ShowSolve(char blk='#',char s='o')
{
if (!iscreate) return;
if (!issolved)
{
cout<<"無解"<<endl;
}
else
{
int i, j;
for (i=0;i<row+2;i++)
{
for (j=0;j<col+2;j++)
{
if ((i==1 && j==1) || (i==desr && j==desc))
{
cout<<s;
}
else if (maze(i, j) == 1)
{
cout<<blk;
}else
{
if (IsInPath(i, j))
cout<<s;
else
cout<<' ';
}
}
cout<<endl;
}
}
}

//////////////////////
//////窮舉所有路徑////
//////////////////////
offsets move[4]={ {1, 0}, {0, 1},
{-1, 0}, {0, -1}};

struct node
{
int row,col;
};

vector<node> path;
int count;
bool IsReachable( Matrix& maze, Matrix& mark, node beg, node des)
{
if (beg.row==des.row&&beg.col==des.col)
{//如果達到的話那麼顯示路徑
count++;
cout<<"第"<<count<<"條路徑:"<<endl;
for (int i=0;i<path.size();i++)
cout<<"("<<path[i].row<<","<<path[i].col<<")";
cout<<"("<<des.row<<","<<des.col<<")";
cout<<endl;
return false;
}
if (maze(beg.row, beg.col)==1 || mark(beg.row, beg.col)==1)
{
return false;
}

path.push_back(beg);
mark(beg.row, beg.col) = 1;

node nextnode;

for (int i=_S;i<_W+1;i++)
{
nextnode.row = beg.row + move[i].a;
nextnode.col = beg.col + move[i].b;

IsReachable(maze, mark, nextnode, des);
}

path.resize(path.size()-1);
mark(beg.row, beg.col) = 0;

return false;//如果不是窮舉的話應該根據for循環的結果重新設置返回值
}

/*
參數maze,mark為迷宮長寬均加二的矩陣
desr,desc為出口點
*/
void FindAllPath( Matrix& maze, Matrix& mark, int desr, int desc)
{
node first, last;
first.row = 1;
first.col = 1;
last.row = desr;
last.col = desc;

IsReachable(maze, mark, first, last);

path.clear();
}

/*
m迷宮矩陣數據
r,c行和列的大小
desr,desc目標位置
*/
void ShowAllPath(int* m, int r, int c, int desr=-1, int desc=-1)
{
Matrix maze, mark;
maze.Create(r+2, c+2);
mark.Create(r+2, c+2);

if (desr==-1 || desc==-1)
{
desr = r;
desc = c;
}

int i, j;

for (i=0;i<r+2;i++)
{
for (j=0;j<c+2;j++)
{
if (j==0 || j==c+1 || i==0 || i==r+1)
{
mark(i, j) = maze(i, j) = 1;

}else{
mark(i, j) = 0;
maze(i, j) = m[((i-1)*c+j-1)];
}
}
}

count = 0;
FindAllPath(maze, mark, desr, desc);

maze.Release();
mark.Release();
}
#endif

③ 如何用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語言版迷宮問題

剛學都這樣，想當初我學習的時候連一個單鏈表的逆置，都要理解半天。編程就是把實際問題給抽象成數學或非數學模型，結合數據的表示，再找到解決的方法。別忘了，學習數據結構是為了更好的操作數據。
思路：
首先，迷宮如何用計算機語言表示？一般用二維數組。0表示牆，1表示路。
其次，其次就是如何從迷宮中走出來了。結合堆棧，進行搜索。
你可以嘗試著對問題進行分層，然後逐步細化來解決。

如果你要解決一個別人給的走迷宮的問題，同樣還是要這樣，首先把別人給的迷宮在計算機中表示出來，其次結合數據結構所學的知識，找到通路，（關於結合數據結構的知識就看你自己的了，關鍵是對堆棧的了解）。

關於你說的，先看別人的程序，找到思路後自己才能編程問題。我看你是操之過急了，你得明白，知識的學習，首先就是會模仿，等你對整個課程有了系統的認識，你才會有自己的解題思路。創新是在有基礎的前提下進行的。別人的東西，試著理解，畢竟許多東西單憑我們自己是不太可能想出來的，就像kmp演算法一樣（你應該馬上就會學到）。
第一章說過，研究數據間的關系的目的是為了更好的操作數據，迷宮問題，可以說是一類「搜索」問題，更強調的是演算法，即在精通堆棧的基礎上想出一個利用堆棧對迷宮進行搜索的辦法。而堆棧，則是基礎，堆棧的操作就那麼幾個，學完馬上就會用。關鍵是如何運用三種程序設計方法再結合某些數據結構設計出一個演算法。一步一步來吧。
對了，給你一個問題考慮考慮，「不用任何輔助變數」編寫一個程序，逆置一個字元串試試。只給你一個參數：該參數就是指向字元串的指針。

你的最後問題問的就有點沒頭緒了，學習的過程並不是你想的那樣的，不見得數據結構學完之後就能編寫高質量程序，寫程序和看程序是相輔相成的，寫而不學則怠，學而不寫則罔。可以嘗試的寫寫，自己找不到思路可以看看別人是怎麼想的，自己多做做總結。

⑤ c語言程序設計的迷宮

這個可行的
/*4.3.3源程序*/
#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語言 老鼠走迷宮

可以給你點提示：迷宮 可用個二維數組表示。求解方法是：從入口出發，順某個方向走，若能過去，繼續；否則，沿著原路返回，換方向繼續走，直到所有可能的通路都被找到為止。為保證在任何位置上都能沿原路退回，需要一個先進後出的棧結構保存從入口到當前位置的路徑。這里，給個演算法的思想，不實現圖形界面了。假設迷宮數據存放在一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<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語言迷宮問題

給你一個我以前的課程設計注釋比較詳細希望對你有所幫助！
#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;
}

⑨ 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();
}