using namespace std;
class T //定义描述迷宫中当前位置的结构类型
{
public:
int x; //x代表当前位置的行坐标
int y; //y代表当前位置的列坐标
int dir; //0:无效,1:东,2:南,3:西,4:北
};
class LinkNode //链表结点
{
friend class Stack;
public:
T data;
LinkNode *next;
};
class Stack
{
private:
LinkNode *top; //指向第一个结点的栈顶指针
public:
Stack(); //构造函数，置空栈
~Stack(); //析构函数
void Push(T e); //把元素data压入栈中
T Pop(); //使栈顶元素出栈
T GetPop(); //取出栈顶元素
void Clear(); //把栈清空
bool empty(); //判断栈是否为空，如果为空则返回1，否则返回0
};
Stack::Stack() //构造函数，置空栈
{
top=NULL;
}
Stack::~Stack() //析构函数
{
}
void Stack::Push(T e) //把元素x压入栈中
{
LinkNode *P;
P=new LinkNode;
P->data=e;
P->next=top;
top=P;
}
T Stack::Pop() //使栈顶元素出栈
{
T Temp;
LinkNode *P;
P=top;
top=top->next;
Temp=P->data;
delete P;
return Temp;
}
T Stack::GetPop() //取出栈顶元素
{
return top->data;
}
void Stack::Clear() //把栈清空
{
top=NULL;
}
bool Stack::empty() //判断栈是否为空，如果为空则返回1，否则返回0
{
if(top==NULL) return 1;
else return 0;
}
int move[4][2]={{0,1},{1,0},{0,-1},{-1,0}}; //定义当前位置移动的4个方向
bool Mazepath(int **maze,int m,int n);
//寻找迷宫maze中从（0，0）到（m,n）的路径
//到则返回true,否则返回false
void PrintPath(Stack p); //输出迷宫的路径
void Restore(int **maze,int m,int n); //恢复迷宫
int** GetMaze(int &m,int &n); //获取迷宫
//返回存取迷宫的二维指针
int main()
{
int m=0,n=0; //定义迷宫的长和宽
int **maze; //定义二维指针存取迷宫
maze=GetMaze(m,n); //调用GetMaze(int &m,int &n)函数，得到迷宫
if(Mazepath(maze,m,n)) //调用Mazepath(int **maze,int m,int n)函数获取路径
cout<<"迷宫路径探索成功!\n";
else cout<<"路径不存在!\n";
return 0;
}
int** GetMaze(int &m,int &n)//返回存取迷宫的二维指针
{
int **maze; //定义二维指针存取迷宫
int i=0,j=0;
cout<<"请输入迷宫的长和宽:";
int a,b;cin>>a>>b; //输入迷宫的长和宽
cout<<"请输入迷宫内容:\n";
m=a;
n=b; //m,n分别代表迷宫的行数和列数
maze=new int *[m+2]; //申请长度等于行数加2的二级指针
for(i= 0;i<m+2;i++) //申请每个二维指针的空间
{
maze[i]=new int[n+2];
}
for(i=1;i<=m;i++) //输入迷宫的内容，0代表可通，1代表不通
for(j=1;j<=n;j++)
cin>>maze[i][j];
for(i=0;i<m+2;i++)
maze[i][0]=maze[i][n+1]=1;
for(i=0;i<n+2;i++)
maze[0][i]=maze[m+1][i]=1;
return maze; //返回存贮迷宫的二维指针maze
};
bool Mazepath(int **maze,int m,int n)//寻找迷宫maze中从（0，0）到（m,n）的路径
//到则返回true,否则返回false
{
Stack q,p; //定义栈p、q,分别存探索迷宫的过程和存储路径
T Temp1,Temp2;
int x,y,loop;
Temp1.x=1;
Temp1.y=1;
q.Push(Temp1); //将入口位置入栈
p.Push(Temp1);
maze[1][1]=-1; //标志入口位置已到达过
while(!q.empty()) //栈q非空，则反复探索
{
Temp2=q.GetPop(); //获取栈顶元素
if(!(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y))
p.Push(Temp2);
//如果有新位置入栈，则把上一个探索的位置存入栈p
for(loop=0;loop<4;loop++) //探索当前位置的4个相邻位置
{
x=Temp2.x+move[loop][0]; //计算出新位置x位置值
y=Temp2.y+move[loop][1]; //计算出新位置y位置值
if(maze[x][y]==0) //判断新位置是否可达
{
Temp1.x=x;
Temp1.y=y;
maze[x][y]=-1; //标志新位置已到达过
q.Push(Temp1); //新位置入栈
}
if((x==(m))&&(y==(n))) //成功到达出口
{
Temp1.x=m;
Temp1.y=n;
Temp1.dir=0;
p.Push(Temp1); //把最后一个位置入栈
PrintPath(p); //输出路径
Restore(maze,m,n); //恢复路径
return 1; //表示成功找到路径
}
}
if(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y)
//如果没有新位置入栈，则返回到上一个位置
{
p.Pop();
q.Pop();
}
}
return 0; //表示查找失败，即迷宫无路经
}
void PrintPath(Stack p) //输出路径
{
cout<<"迷宫的路径为\n";
cout<<"括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)\n";
Stack t; //定义一个栈，按从入口到出口存取路径
int a,b;
T data;
LinkNode *temp;
temp=new LinkNode; //申请空间
temp->data=p.Pop(); //取栈p的顶点元素，即第一个位置
t.Push(temp->data); //第一个位置入栈t
delete temp; //释放空间
while(!p.empty()) //栈p非空，则反复转移
{
temp=new LinkNode;
temp->data=p.Pop(); //获取下一个位置
//得到行走方向
a=t.GetPop().x-temp->data.x; //行坐标方向
b=t.GetPop().y-temp->data.y; //列坐标方向
if(a==1) temp->data.dir=1; //方向向下，用1表示
else if(b==1) temp->data.dir=2; //方向向右，用2表示
else if(a==-1) temp->data.dir=3; //方向向上，用3表示
else if(b==-1) temp->data.dir=4; //方向向左，用4表示
t.Push(temp->data); //把新位置入栈
delete temp;
}
//输出路径，包括行坐标，列坐标，下一个位置方向
while(!t.empty()) //栈非空，继续输出
{
data=t.Pop();
cout<<'('<<data.x<<','<<data.y<<','<<data.dir<<","; //输出行坐标，列坐标
switch(data.dir) //输出相应的方向
{
case 1:cout<<"↓)\n";break;
case 2:cout<<"→)\n";break;
case 3:cout<<"↑)\n";break;
case 4:cout<<"←)\n";break;
case 0:cout<<")\n";break;
}
}
}
void Restore(int **maze,int m,int n) //恢复迷宫
{
int i,j;
for(i=0;i<m+2;i++) //遍历指针
for(j=0;j<n+2;j++)
{
if(maze[i][j]==-1) //恢复探索过位置，即把-1恢复为0
maze[i][j]=0;
}
}
示例输出：
测试1：
请输入迷宫的长和宽:5 5
请输入迷宫内容:
0 1 1 0 0
0 0 1 1 0
1 0 0 1 1
1 0 0 1 0
1 1 0 0 0
迷宫的路径为
括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)
(1,1,1,↓)
(2,1,2,→)
(2,2,1,↓)
(3,2,1,↓)
(4,2,2,→)
(4,3,1,↓)
(5,3,2,→)
(5,4,2,→)
(5,5,0,)
迷宫路径探索成功!
测试2：
请输入迷宫的长和宽:9 8
请输入迷宫内容:
0 0 1 0 0 0 1 0
0 0 1 0 0 0 1 0
0 0 0 0 1 1 0 1
0 1 1 1 0 0 1 0
0 0 0 1 0 0 0 0
0 1 0 0 0 1 0 1
0 1 1 1 1 0 0 1
1 1 0 0 0 1 0 1
1 1 0 0 0 0 0 0
迷宫的路径为
括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)
(1,1,1,↓)
(2,1,1,↓)
(3,1,1,↓)
(4,1,1,↓)
(5,1,2,→)
(5,2,2,→)
(5,3,1,↓)
(6,3,2,→)
(6,4,2,→)
(6,5,3,↑)
(5,5,2,→)
(5,6,2,→)
(5,7,1,↓)
(6,7,1,↓)
(7,7,1,↓)
(8,7,1,↓)
(9,7,2,→)
(9,8,0,)
迷宫路径探索成功!
绝对原创，我自己花了整整3个小时给你编了个，很累的，以前用 c 编过但功能不全，这次更安全，更具有适用性。
//==========================================================================================================================
//
// 使用： 须知
//
// 迷宫 1表示通路 0表示障碍
// 若为其他符号 不用修改运行部分 修改初始化即可 始终把 通路符号替换成1 障碍部分替换成0即可
// 功能 输出长宽 3--100 间的任何迷宫 若需要更大 只需修改初始化部分(Init部分)
// 可输出 所有路径(printall) 所有最短路径(printmin)
//
//==========================================================================================================================
#include<iostream>
#include<vector>
using std::ostream;
using std::istream;
using std::cin;
using std::cout;
using std::vector;
//--------------------------------------------------------------------------------------------------------------------------
// 定义部分
class MG
{
public:
MG(int mm=10,int nn=10):m(mm),n(nn){init(),Init();};
void run();
void printmin();
void printall();
private:
int m,n;
int a[100][100]; //记录迷宫
vector<int > key; //记录路口
vector<int > b; //记录当前路径
vector<vector<int > > c; //记录所有路径
void init();
void Init();
void back();
bool judge(int n);
};
//--------------------------------------------------------------------------------------------------------------------------
// 实现部分
void MG::init(){if(m<3&&m>98&&n<3&&n>98) {exit(1),cout<<"input error\n";}}
void MG::Init()
{
for(int i=0; i<=m+1; i++)
for(int j=0; j<=n+1; j++)
a[i][j]=0;
cout<<"请输入迷宫图形\n";
for(i=1; i<=m; i++)
for(int j=1; j<=n; j++)
cin>>a[i][j];
b.push_back(101);
}
bool MG::judge(int n)
{
int w;
w=a[n/100][n%100+1]+a[n/100+1][n%100]+
a[n/100-1][n%100]+a[n/100][n%100-1];
if(w<=1||b[b.size()-2]>=40000) return 0;
else return 1;
}
void MG::run()
{
int M,N;
do{
if(key.size()) back();
while(b.back()%1000!=m*100+n)
{
int q=0;
M=b.back()%10000,N=M%100,M=M/100;
if(b.back()<10000&&(b[b.size()-1]=b.back()%10000+10000)&&a[M+1][N]) b.push_back((M+1)*100+N),a[M][N]=0,q=1;
else if(b.back()<20000&&(b[b.size()-1]=b.back()%10000+20000)&&a[M][N+1]) b.push_back(M*100+N+1),a[M][N]=0,q=2;
else if(b.back()<30000&&(b[b.size()-1]=b.back()%10000+30000)&&a[M][N-1]) b.push_back(M*100+N-1),a[M][N]=0,q=3;
else if(b.back()<40000&&(b[b.size()-1]=b.back()%10000+40000)&&a[M-1][N]) b.push_back((M-1)*100+N),a[M][N]=0,q=4;
else if(!key.size()) break;
else back();
if(q&&judge(M*100+N)) key.push_back(b[b.size()-2]);
}
if(b.back()%1000==m*100+n) c.push_back(b);
}
while(key.size()!=0);
}
void MG::back()
{
while(b.back()%1000!=key.back()%1000)
{
int n=b.back()%1000;
b.pop_back();
a[n/100][n%100]=1;
}
key.pop_back();
}
void MG::printmin()
{
int min=c[0].size(),w;
if(!c.size()) cout<<"无通路";
for(int i=1; i<c.size(); i++)
if(min>c[i].size()) min=c[i].size();
cout<<"最短路径为:\n";
for(i=0,w=1; i<c.size(); i++)
{
if(min==c[i].size())
{
cout<<"第"<<w++<<"条最短路径:\n";
cout<<"("<<(c[i][0]%10000)/100<<","<<(c[i][0]%10000)%100<<")";
for(int j=1; j<c[i].size(); j++)
cout<<"->("<<(c[i][j]%10000)/100<<","<<(c[i][j]%10000)%100<<")";
cout<<"\n";
}
}
}
void MG::printall()
{
cout<<"所有的路径:\n";
if(!c.size()) cout<<"无通路";
for(int i=0; i<c.size(); i++)
{
cout<<"第"<<i+1<<"条路径:\n";
cout<<"("<<(c[i][0]%10000)/100<<","<<(c[i][0]%10000)%100<<")";
for(int j=1; j<c[i].size(); j++)
cout<<"->("<<(c[i][j]%10000)/100<<","<<(c[i][j]%10000)%100<<")";
cout<<"\n";
}
}
//-------------------------------------------------------------------------------------------------------------------
// 应用部分
int main()
{
int m,n;
cout<<"请输入行数和列数\n";
cin>>m>>n;
MG g(m,n);
g.run();
g.printmin(); //可输出最短路径
// g.printall(); //可输出所有路径
return(0);
}
#include<iostream>
using namespace std;
class T //定义描述迷宫中当前位置的结构类型
{
public:
int x; //x代表当前位置的行坐标
int y; //y代表当前位置的列坐标
int dir; //0:无效,1:东,2:南,3:西,4:北
};
class LinkNode //链表结点
{
friend class Stack;
public:
T data;
LinkNode *next;
};
class Stack
{
private:
LinkNode *top; //指向第一个结点的栈顶指针
public:
Stack(); //构造函数，置空栈
~Stack(); //析构函数
void Push(T e); //把元素data压入栈中
T Pop(); //使栈顶元素出栈
T GetPop(); //取出栈顶元素
void Clear(); //把栈清空
bool empty(); //判断栈是否为空，如果为空则返回1，否则返回0
};
Stack::Stack() //构造函数，置空栈
{
top=NULL;
}
Stack::~Stack() //析构函数
{
}
void Stack::Push(T e) //把元素x压入栈中
{
LinkNode *P;
P=new LinkNode;
P->data=e;
P->next=top;
top=P;
}
T Stack::Pop() //使栈顶元素出栈
{
T Temp;
LinkNode *P;
P=top;
top=top->next;
Temp=P->data;
delete P;
return Temp;
}
T Stack::GetPop() //取出栈顶元素
{
return top->data;
}
void Stack::Clear() //把栈清空
{
top=NULL;
}
bool Stack::empty() //判断栈是否为空，如果为空则返回1，否则返回0
{
if(top==NULL) return 1;
else return 0;
}
int move[4][2]={{0,1},{1,0},{0,-1},{-1,0}}; //定义当前位置移动的4个方向
bool Mazepath(int **maze,int m,int n);
//寻找迷宫maze中从（0，0）到（m,n）的路径
//到则返回true,否则返回false
void PrintPath(Stack p); //输出迷宫的路径
void Restore(int **maze,int m,int n); //恢复迷宫
int** GetMaze(int &m,int &n); //获取迷宫
//返回存取迷宫的二维指针
int main()
{
int m=0,n=0; //定义迷宫的长和宽
int **maze; //定义二维指针存取迷宫
maze=GetMaze(m,n); //调用GetMaze(int &m,int &n)函数，得到迷宫
if(Mazepath(maze,m,n)) //调用Mazepath(int **maze,int m,int n)函数获取路径
cout<<"迷宫路径探索成功!\n";
else cout<<"路径不存在!\n";
return 0;
}
int** GetMaze(int &m,int &n)//返回存取迷宫的二维指针
{
int **maze; //定义二维指针存取迷宫
int i=0,j=0;
cout<<"请输入迷宫的长和宽:";
int a,b;cin>>a>>b; //输入迷宫的长和宽
cout<<"请输入迷宫内容:\n";
m=a;
n=b; //m,n分别代表迷宫的行数和列数
maze=new int *[m+2]; //申请长度等于行数加2的二级指针
for(i= 0;i<m+2;i++) //申请每个二维指针的空间
{
maze[i]=new int[n+2];
}
for(i=1;i<=m;i++) //输入迷宫的内容，0代表可通，1代表不通
for(j=1;j<=n;j++)
cin>>maze[i][j];
for(i=0;i<m+2;i++)
maze[i][0]=maze[i][n+1]=1;
for(i=0;i<n+2;i++)
maze[0][i]=maze[m+1][i]=1;
return maze; //返回存贮迷宫的二维指针maze
};
bool Mazepath(int **maze,int m,int n)//寻找迷宫maze中从（0，0）到（m,n）的路径
//到则返回true,否则返回false
{
Stack q,p; //定义栈p、q,分别存探索迷宫的过程和存储路径
T Temp1,Temp2;
int x,y,loop;
Temp1.x=1;
Temp1.y=1;
q.Push(Temp1); //将入口位置入栈
p.Push(Temp1);
maze[1][1]=-1; //标志入口位置已到达过
while(!q.empty()) //栈q非空，则反复探索
{
Temp2=q.GetPop(); //获取栈顶元素
if(!(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y))
p.Push(Temp2);
//如果有新位置入栈，则把上一个探索的位置存入栈p
for(loop=0;loop<4;loop++) //探索当前位置的4个相邻位置
{
x=Temp2.x+move[loop][0]; //计算出新位置x位置值
y=Temp2.y+move[loop][1]; //计算出新位置y位置值
if(maze[x][y]==0) //判断新位置是否可达
{
Temp1.x=x;
Temp1.y=y;
maze[x][y]=-1; //标志新位置已到达过
q.Push(Temp1); //新位置入栈
}
if((x==(m))&&(y==(n))) //成功到达出口
{
Temp1.x=m;
Temp1.y=n;
Temp1.dir=0;
p.Push(Temp1); //把最后一个位置入栈
PrintPath(p); //输出路径
Restore(maze,m,n); //恢复路径
return 1; //表示成功找到路径
}
}
if(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y)
//如果没有新位置入栈，则返回到上一个位置
{
p.Pop();
q.Pop();
}
}
return 0; //表示查找失败，即迷宫无路经
}
void PrintPath(Stack p) //输出路径
{
cout<<"迷宫的路径为\n";
cout<<"括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)\n";
Stack t; //定义一个栈，按从入口到出口存取路径
int a,b;
T data;
LinkNode *temp;
temp=new LinkNode; //申请空间
temp->data=p.Pop(); //取栈p的顶点元素，即第一个位置
t.Push(temp->data); //第一个位置入栈t
delete temp; //释放空间
while(!p.empty()) //栈p非空，则反复转移
{
temp=new LinkNode;
temp->data=p.Pop(); //获取下一个位置
//得到行走方向
a=t.GetPop().x-temp->data.x; //行坐标方向
b=t.GetPop().y-temp->data.y; //列坐标方向
if(a==1) temp->data.dir=1; //方向向下，用1表示
else if(b==1) temp->data.dir=2; //方向向右，用2表示
else if(a==-1) temp->data.dir=3; //方向向上，用3表示
else if(b==-1) temp->data.dir=4; //方向向左，用4表示
t.Push(temp->data); //把新位置入栈
delete temp;
}
//输出路径，包括行坐标，列坐标，下一个位置方向
while(!t.empty()) //栈非空，继续输出
{
data=t.Pop();
cout<<'('<<data.x<<','<<data.y<<','<<data.dir<<","; //输出行坐标，列坐标
switch(data.dir) //输出相应的方向
{
case 1:cout<<"↓)\n";break;
case 2:cout<<"→)\n";break;
case 3:cout<<"↑)\n";break;
case 4:cout<<"←)\n";break;
case 0:cout<<")\n";break;
}
}
}
void Restore(int **maze,int m,int n) //恢复迷宫
{
int i,j;
for(i=0;i<m+2;i++) //遍历指针
for(j=0;j<n+2;j++)
{
if(maze[i][j]==-1) //恢复探索过位置，即把-1恢复为0
maze[i][j]=0;
}
}
/*
Maze.cpp
输入文件maze.txt
输入文件格式：第一行输入行数和列数
第二行4个整数：开始的坐标 结束的坐标
下面n行m列为迷宫图
*/
#include <iostream>
using namespace std;
const int way[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
int n,m;
int g[201][201];
int q[50001][3],open,closed,visit[201][201];
//q[i][0]表示当前的x，q[i][1]表示当前的y，q[i][2]表示当前的步数
int bx,by,ex,ey;
void init()
{
cin>>n>>m;
cin>>bx>>by>>ex>>ey;
for (int i=1;i<=n;i++)
for (int j=1;j<=m;j++)
cin>>g[i][j];
}
void work() //用BFS解决迷宫，效率比DFS高，楼上都是DFS吧。。
{
open=closed=0;
q[open][0]=bx, q[open][1]=by, q[open++][2]=0;
visit[bx][by]=true;
int tx,ty,tp,nx,ny;
while (closed < open)
{
tx=q[closed][0], ty=q[closed][1], tp=q[closed][2];
if (tx==ex && ty==ey){ cout<<"Step="<<tp<<endl;return; }
for (int i=0;i<4;i++)
{
nx=tx+way[i][0], ny=ty+way[i][1];
if (nx>=1 && nx<=n && ny>=1 && ny<=m && !g[nx][ny] && !visit[nx][ny])
q[open][0]=nx,q[open][1]=ny,q[open++][2]=tp+1,visit[nx][ny]=true;
}
closed++;
}
cout<<"NoWay!"<<endl;
}
int main(void)
{
freopen("maze.txt","r",stdin);
init(), work();
while (1);
return 0;
}
样例：
4 4
1 1 4 4
0 0 0 1
1 1 0 1
0 1 0 1
1 1 1 0
输出Noway!
4 4
1 1 4 4
0 0 0 1
1 1 0 1
0 1 0 1
1 1 0 0
输出Step=6
1楼超级牛，我需然学完C++的基础~但还是看不懂~要用到数据结构的知识吗? 如果加上MFC封装就完美了~
求大神用C++编写一个迷宫游戏程序。~
#include
using namespace std;
class T//定义描述迷宫中当前位置的结构类型
{
public:
int x;//x代表当前位置的行坐标
int y;//y代表当前位置的列坐标
int dir;//0:无效,1:东,2:南,3:西,4:北
};
class LinkNode//链表结点
{
friend class Stack;
public:
T data;
LinkNode *next;
};
class Stack
{
private:
LinkNode *top;//指向第一个结点的栈顶指针
public:
Stack();//构造函数，置空栈
~Stack()//析构函数
{}
void Push(T e);//元素data入栈中
T Pop();//栈顶元素出栈
T GetPop();//取出栈顶元素
void Clear();//把栈清空
bool empty();//判断栈是否为空，如果为空则返回1，否则返回0
};
Stack::Stack()//构造函数，置空栈
{
top=NULL;
}
void Stack::Push(T e)//元素x入栈中
{
LinkNode *P;
P=new LinkNode;
P->data=e;
P->next=top;
top=P;
}
T Stack::Pop()//栈顶元素出栈
{
T Temp;
LinkNode *P;
P=top;
top=top->next;
Temp=P->data;
delete P;
return Temp;
}
T Stack::GetPop()//取出栈顶元素
{
return top->data;
}
void Stack::Clear()//把栈清空
{
top=NULL;
}
bool Stack::empty()//判断栈是否为空，如果为空则返回1，否则返回0
{
if(top==NULL) return 1;
else return 0;
}
int move[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//定义当前位置移动的4个方向
void PrintPath(Stack p)//输出路径
{
cout<<"迷宫的路径为
";
cout<<"括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)
";
Stack t;//定义一个栈，按从入口到出口存取路径
int a,b;
T data;
LinkNode *temp;
temp=new LinkNode;//获取空间
temp->data=p.Pop();//取栈p的顶点元素，即第一个位置
t.Push(temp->data);//第一个位置入栈t
delete temp;//释放空间
while(!p.empty())//如果栈p非空，则反复转移
{
temp=new LinkNode;
temp->data=p.Pop();//获取下一个位置
//得到行走方向
a=t.GetPop().x-temp->data.x;//行坐标方向
b=t.GetPop().y-temp->data.y;//列坐标方向
if(a==1) temp->data.dir=1;//方向向下，用1表示
else if(b==1) temp->data.dir=2;//方向向右，用2表示
else if(a==-1) temp->data.dir=3;//方向向上，用3表示
else if(b==-1) temp->data.dir=4;//方向向左，用4表示
t.Push(temp->data);//把新位置入栈
delete temp;
}//输出路径，包括行坐标，列坐标，下一个位置方向
while(!t.empty())//栈非空，继续输出
{
data=t.Pop();
cout<<'('<<data.x<<','<<data.y<<','<<data.dir<<",";//输出行坐标，列坐标
switch(data.dir)//输出相应的方向
{
case 1:cout<<"↓)
";break;
case 2:cout<<"→)
";break;
case 3:cout<<"↑)
";break;
case 4:cout<<"←)
";break;
case 0:cout<<")
";break;
}
}
}
void Restore(int **maze,int m,int n)//恢复迷宫
{
int i,j;
for(i=0;i<m+2;i++)//遍历指针
for(j=0;j<n+2;j++)
{
if(maze[i][j]==-1)//恢复探索过位置，即把-1恢复为0
maze[i][j]=0;
}
}
int** GetMaze(int &m,int &n)//返回存取迷宫的二维指针
{
int **maze;//定义二维指针存取迷宫
int i=0,j=0;
cout<<"请输入迷宫的长和宽:";
int a,b;cin>>a>>b;//输入迷宫的长和宽
cout<<"请输入迷宫内容:(0为通路，1为墙)
";
m=a;
n=b;//m,n分别代表迷宫的行数和列数
maze=new int *[m+2];//获取长度等于行数加2的二级指针
for(i= 0;i<m+2;i++)//每个二维指针的空间
{
maze[i]=new int[n+2];
}
for(i=1;i<=m;i++)//输入迷宫的内容，0代表可通，1代表不通
for(j=1;j<=n;j++)
cin>>maze[i][j];
for(i=0;i<m+2;i++)
maze[i][0]=maze[i][n+1]=1;
for(i=0;i<n+2;i++)
maze[0][i]=maze[m+1][i]=1;
return maze;//返回存贮迷宫的二维指针maze
};
bool Mazepath(int **maze,int m,int n)//寻找迷宫maze中从（0，0）到（m,n）的路径
{
Stack q,p;//定义栈p、q,分别存探索迷宫的过程和存储路径
T Temp1,Temp2;
int x,y,loop;
Temp1.x=1;
Temp1.y=1;
q.Push(Temp1);//将入口位置入栈
p.Push(Temp1);
maze[1][1]=-1;//标志入口位置已到达过
while(!q.empty())//栈q非空，则反复探索
{
Temp2=q.GetPop();//获取栈顶元素
if(!(((p.GetPop().x)==(q.GetPop().x))&&((p.GetPop().y)==(q.GetPop().y))))
p.Push(Temp2);
//如果有新位置入栈，则把上一个探索的位置存入栈p
for(loop=0;loop<4;loop++)//探索当前位置的4个相邻位置
{
x=Temp2.x+move[loop][0];//计算出新位置x位置值
y=Temp2.y+move[loop][1];//计算出新位置y位置值
if(maze[x][y]==0)//判断新位置是否可达
{
Temp1.x=x;
Temp1.y=y;
maze[x][y]=-1;//标志新位置已到达过
q.Push(Temp1);//新位置入栈
}
if((x==(m))&&(y==(n)))//成功到达出口
{
Temp1.x=m;
Temp1.y=n;
Temp1.dir=0;
p.Push(Temp1);//把最后一个位置入栈
PrintPath(p);//输出路径
Restore(maze,m,n);//恢复路径
return 1;//表示成功找到路径
}
}
if(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y)//如果没有新位置入栈，则返回到上一个位置
{
p.Pop();
q.Pop();
}
}
return 0;//表示查找失败，即迷宫无路经
}
int main()
{
int m=0,n=0;//定义迷宫的长和宽
int **maze;//定义二维指针存取迷宫
maze=GetMaze(m,n);//调用GetMaze(int &m,int &n)函数，得到迷宫
if(Mazepath(maze,m,n))//调用Mazepath(int **maze,int m,int n)函数获取路径
cout<<"迷宫路径探索成功!
";
else cout<<"路径不存在!
";
return 0;
}
输入数据：
搜索的路径为：
你的描述跟图不一样啊。。反正这是按照你的描述写的
这是我的程序的限定：路径从左到右（你这里没有设定）
#include
#include
#include
using namespace std;
char map[55][55];
bool vis[55][55];
int dx[5]={0,0,0,-1,1},dy[5]={0,-1,1,0,0};
vector path;
int n,m;
char NO='X';
inline void dfs(int x,int y)
{
vis[x][y]=true;
path.push_back(map[x][y]);
if(y==m)
{
for(int i=0;i<path.size();i++)
printf("%c ",path[i]);
putchar('
');
return;
}
for(int i=1;i<=4;i++)
{
int nx=x+dx[i],ny=y+dy[i];
if(nx=1 && ny=1 && !vis[nx][ny] && map[nx][ny]!=NO)
dfs(nx,ny);
}
vis[x][y]=true;
path.pop_back();
}
int main()
{
n=15,m=15;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
map[i][j]=getchar();
while(map[i][j]=='
')
map[i][j]=getchar();
}
for(int i=1;i<=n;i++)
if(!vis[i][1] && map[i][1]!=NO)
dfs(i,1);
return 0;
}
#18616731080#
c++编写迷宫问题 .高手帮忙 - ******
#萧呢# #include#include#include using namespace std;/////////////////////////////////////////////////////////////////////////////////////////////////// typedef struct { int x; int y; int dir; }datatype; struct { int x; int y; }move[4];/////////////////////////////////////////////////////////////////////////////////////////////////// class Maze ...
#18616731080#
用C/C++编写迷宫,用A*算法 - ******
#萧呢# #include ＂stdafx.h＂#include using namespace std;//定义常数const int rows = 8,cols = 8;//声明全局变量HINSTANCE hInst;HBITMAP ball;HDC hdc,mdc,bufdc;HWND hWnd;DWORD tPre,tNow;char *str;//记录目前搜索状态的字符串指针int ...
#18616731080#
求C++迷宫问题代码,包括实验报告,急求,代码能有详细注释, ******
#萧呢# 程西代码(报告自己写): *迷宫问题是指在m*n的矩阵中,其中0表示“可以行走”的区域,1表示“不可行走”的区域,当你在迷宫的任何一个位置,除了不可行走的区域外,其余皆可以往上、右上、右、右下、下、左下、左、左上八个方向...
#18616731080#
C++老鼠迷宫 ******
#萧呢# 源程序如下:#include<iostream>#include<ctime>#include<stack>#include<windows.h>using namespace std;const int East = 0;const int South = 1;const int West = 2;const int North = 3;const int pause = 50; //老鼠走一步需要的...
#18616731080#
求个c++源码 走迷宫 程序开始运行时显示一个迷宫地图,迷宫中央有一只老鼠,迷宫的右下方有一个粮仓 - ******
#萧呢# 当你进入地图:1表示无法通行,0代表差强人意,自动增加边框(墙),网格的左侧和左上角到右下角的右侧的一个网格入口出口 编译的代码如下:#包括 #包括 #n 50 数组的迷宫; 诠释行; 整数关口;int的堆栈[50] ;/ /堆栈 无效createmaze...
#18616731080#
C++ 高手来,急!!帮忙写个c++的迷宫程序,标准在下面.追加分数!..在线等 - ******
#萧呢# 这是递归的:1表示墙,0表示通道 如: 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 0 1 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1#include <iostream>using namespace std;struct offsets{ int a,b; char *dir;};const int m=4,p=4;int maze[m+2][p+2];int mark[m+2][p...
#18616731080#
帮忙设计一个{数据结构C++}的【迷宫问题】~~谢谢各位!! - ******
#萧呢# #include ?#include#include#define LEFT 0x4b00 /*光...
#18616731080#
用C++编辑一个迷宫地图编辑器?用C++编辑一个迷宫地图编辑器 ******
#萧呢# 先把地图的文件结构设计好 然后按照设计的结构读写文件就行了 这是我的看法,请采纳.
#18616731080#
c++编迷宫设置通路的思路 ******
#萧呢# 你用的是回溯法,估计你是想要实现最短通路.我给出一种思路.在一幅无向图中,如果所有的边都有相同的权,要求解某点到其他点的最短路径可以用迪杰斯特拉算法,也可以用广度优先遍历的方法.广度优先遍历的生成树即为树根到其他顶点的最短路径.相对于迪杰斯特拉算法其时间复杂度为O(n).余下的问题就是怎么将迷宫抽象成无向图了.方法是对二维迷宫中的每一个“.”编号,从1起,采用邻接表法存储,对每个“.”其周围四个方向是“.”的记入中心“.”对应编号的邻接表项中,对每个“.”都这样一次,如此便形成了迷宫对应的无向图,用广度法或者迪法以出或入口为起点即可实现最短通路的求解.
#18616731080#
请问可以给我一份C++ 迷宫地图编辑器的程序代码吗,谢谢, - ******
#萧呢# /*编一迷宫游戏程序,迷宫生成有用户输入和程序自动生成两种方式(迷宫以矩阵表示),要求输出迷宫和走出迷宫的路径.*/#include#include#include#include#includeusing namespace std; struct item{int x,y; }; struct Datatype{int x,y,d; }; ...
