#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)/*下*/ elseif(c=='z'&&map[x+1][y-1]!=1)DrawPeople(&x,&y,6)/*左下*/elseif(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=0i<Ni++) for(j=0j<Nj++) 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=0i<Ni++){
for(j=0j<Nj++) { 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=0i<Ni++) for(j=0j<Nj++) 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=wayni>=0i--){
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()}
分类: 电脑/网络 >>程序设计 >>其他编程语言问题描述:
程序如下：
#include"stdio.h"
#include"stdlib.h"
#define m 4
#define n 4
struct stype
{int x,y
}stack[400]
int mg[m+2][n+2]
int zx[9],zy[9]
void printlj(int TOP)
{int i
for(i=1i<=TOPi++)
{printf("(%d,%d)",stack[i].x,stack[i].y)
}
}
void mglj()
{int i,j,x,y,top,find,v
top=1stack[1].x=1stack[1].y=1find=0mg[1][1]=-1
while(top>=1&&!find)
{x=stack[top].xy=stack[top].y
for(v=1v<=8v++)
{i=x+zx[v]
j=y+zy[v]
if(mg[i][j]==0)
{top++
stack[top].x=i
stack[top].y=j
mg[i][j]=-1
break
}
if(v==8) top--
}
if((stack[top].x ==m)&&(stack[top].y ==n))
{printlj(top)
find=1
}
}
if(!find) printf("no way\n")
}
void main()
{int i,j
for(i=1i<=mi++)
for(j=1j<=nj++)
scanf("%d",&mg[i][j])
for(i=0i<=m+1i++)
{mg[i][0]=1mg[i][n+1]=1}
for(j=0j<=n+1j++)
{mg[0][j]=1mg[m+1][j]=1}
zx[1]=-1zx[2]=-1zx[3]=0zx[4]=1zx[5]=1zx[6]=1zx[7]=0zx[8]=-1
zy[1]=0zy[2]=1zy[3]=1zy[4]=1zy[5]=0zy[6]=-1zy[7]=-1zy[8]=-1
mglj()
}
解析:
我看了一下,算法应该是一样的,下面是我以前用C++写的
相信你能看得懂
/
/迷宫求解
作者:baihacker/
/时间: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=0iscreate=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=0i<row*coli++)
{
*(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=0i<rowi++)
{
for (j=0j<colj++)
{
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=falseresult=0pathlength=row=col=0iscreate=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=0i<r+2i++)
{
for (j=0j<c+2j++)
{
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=0i<pathlengthi++)
{
*(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=0i<pathlengthi++)
{
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=0i<row+2i++)
{
for (j=0j<col+2j++)
{
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=0i<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=_Si<_W+1i++)
{
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=0i<r+2i++)
{
for (j=0j<c+2j++)
{
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
全部程序分几个文件，看清楚了，每段程序放入一个文件，每段程序前面都有文件名：//stackoperation.cpp
Status InitStack(SqStack &S)
{ //构造一个空栈S
S.base = (SElemType *)malloc(RANGE*sizeof(SElemType))
if(!S.base) exit(OVERFLOW) //存储分配失败
S.top = S.base
S.stacksize = RANGE
return OK
}//Initstack
Status Push(SqStack &S,SElemType e)
{ //插入元素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
}//Push
Status Pop(SqStack &S,SElemType &e){
/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；
否则返回ERROR*/
if(S.top == S.base) return ERROR
e = * --S.top
return OK
}//Pop
bool StackEmpty(SqStack S)
{ //判断伏吵栈是否为空并返回TURN或FALSE
if(S.top == S.base) return TURE
return FALSE
}//StackEmpty
void PrintStack()
{
SqStack ST
SElemType e
InitStack(ST)
do{
Pop(SqS,e)
Push(ST,e)
}while(!StackEmpty(SqS))
do{
Pop(ST,e)
printf("(%d,%d,%d)",e.seat.i,e.seat.j,e.di)
}while(!StackEmpty(ST))
}
//migong.cpp
#include "Basetype.h"
#include "stackoperation.cpp"
#include "Mazeoperation.cpp"
void main()
{
char filename[15]
FILE *fp
printf("御备请输入迷宫数据文件名（长度不超过15个字符）：")
scanf("%s",&filename)
//如找不到文件，则要求重新输入（最多三次机会）
for(int i=0i<3i++){
if((fp = fopen(filename,"r")) == NULL)
{printf("不能打开文件,请重新输入文件名（长度不超过15个字符）：\n")
scanf("%s",filename)
}//if
break
}//for
//读取迷宫的行数和列数
int rnum,cnum
fscanf(fp,"%d,%d",&rnum,&cnum)
printf("这个迷镇厅毁宫有%d行，%d列\n",rnum,cnum)
if(rnum>RANGE-2 || cnum>RANGE-2)
{ printf("迷宫太大，无法求解\n")
return
}//判断迷宫的大小是否符合要求
//初始化一个迷宫变量
MazeType maze
for(i=0i<=rnum+1i++)
for(int j=0j<=cnum+1j++)
maze.arr[i][j] = '#'
CreatMaze(maze,rnum,cnum,fp)//创建迷宫
fclose(fp)//关闭迷宫文件
//打印当前迷宫
printf("当前迷宫为：\n")
for(i=0i<=rnum+1i++)
{ for(int j=0j<=cnum+1j++)
printf("%c",maze.arr[i][j])
printf("\n")
}
printf("其中'#'表示障碍,外围一圈'#'为围墙\n")
//读取入口及出口位置
PosType startp,endp
printf("请输入入口位置（两数中间以逗号相隔）：")
scanf("%d,%d",&startp.i,&startp.j)
printf("请输入出口位置（两数中间以逗号相隔）：")
scanf("%d,%d",&endp.i,&endp.j)
if(MazePath(maze,startp,endp))
{ PrintMaze(maze,rnum,cnum)//将求解的迷宫输出到文件保存，并打印到屏幕
PrintStack()//如果存在路径则打印之
}
else printf("此迷宫不存在路径\n")
}//main
//Mazeoperation.cpp
bool Pass(MazeType maze,PosType curpos)
{ //判断当前位置是否可通，并返回值
switch(char ch = maze.arr[curpos.i][curpos.j])
{ case' ': return(FALSE)
case'#':
case'@':
case'*': return(TURE)
default: { printf("迷宫中第%d行,第%d列出现不明字符%c\n",
curpos.i,curpos.j,ch)exit(0)}
}//switch
}//pass
void FootPrint(MazeType &maze,PosType curpos)
{
maze.arr[curpos.i][curpos.j] = '*'
}//FootPrint
void MarkPrint(MazeType &maze,PosType curpos)
{
maze.arr[curpos.i][curpos.j] = '@'
}//MarkPrint
void NextPos(PosType &curpos,int di)
{
switch(di)
{ case 1: curpos.j++break
case 2: curpos.i++break
case 3: curpos.j--break
case 4: curpos.i--break
default: printf("当前方向%d无效\n",di)
exit(0)
}//switch
}//NextPos
bool MazePath(MazeType &maze,PosType start,PosType end){
SElemType e
InitStack(SqS)
PosType curpos = start
int curstep = 1
do{
if(!Pass(maze,curpos)){
FootPrint(maze,curpos)
e.order = curstep
e.seat.i = curpos.ie.seat.j = curpos.j
e.di = 1
Push(SqS,e)
if(curpos.i == end.i &&curpos.j == end.j) return(TURE)
NextPos(curpos,1)
curstep++
}//if
else{
if(!StackEmpty(SqS)){
Pop(SqS,e)
while(e.di == 4 &&!StackEmpty(SqS)){
MarkPrint(maze,e.seat)Pop(SqS,e)
}//while
if(e.di<4){
e.di++ Push(SqS,e)
NextPos(e.seat,e.di)
curpos.i = e.seat.icurpos.j = e.seat.j
}//if
}//if
}//else
}while(!StackEmpty(SqS))
return(FALSE)
}//Mazepath
void CreatMaze(MazeType &maze,int row,int col,FILE *fp){
//建立迷宫
char ch = fgetc(fp)
for(int i=1i<=rowi++)
{
for(int j=1j<=colj++)
{switch( ch = fgetc(fp))
{
case'0': maze.arr[i][j]=' 'break
case'1': maze.arr[i][j]='#'break
default: printf("迷宫第%d行第%d列数据为%c有错误",i,j,ch)exit(0)
}//switch
}//for
fseek(fp,2,1)
}//for
fclose(fp)
}//CreatMaze
void PrintMaze(MazeType maze,int row,int col)
{ //打印结果并输出到文件保存
FILE *out
if((out = fopen("outfile","w"))==NULL)
{ printf("不能打开文件\n")
exit(0)
}//if
for(int i=0i<=row+1i++)
{for(int j=0j<=col+1j++)
{ fputc(maze.arr[i][j],out)
printf("%c",maze.arr[i][j])
}
printf("\n")
}
printf("其中'*'号代表路径，'#'代表障碍,'@'代表死胡同\n")
fclose(out)//关闭文件
}
//Basetype.h
#include <stdio.h>
#include "stdlib.h"
#define RANGE 30 //栈的存储空间初始分配量，
//以及用来存放迷宫的字符数组的最大维数
#define TURE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define STACKINCREMENT 5 //栈的存储空间分配增量
typedef struct{
int i//行坐标
int j//列坐标
}PosType //迷宫中坐标位置类型
//栈的定义
typedef struct{
int order//通道块在路径上的“方向”
PosType seat //通道块在迷宫中的“坐标位置”
int di //从此通道块走向下一通道块的“方向”
}SElemType //栈的元素类型
typedef struct{
SElemType *base //栈底指针
SElemType *top //栈顶指针
int stacksize //当前已分配的存储空间，以元素为单位
}SqStack
//迷宫的定义
typedef struct{
int m,n
char arr[RANGE][RANGE]
}MazeType
typedef int Status
SqStack SqS //定义一个栈
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）