迷宫问题(maze problem)——深度优先(DFS)与广度优先搜索(BFS)求解
2016-05-02 11:27
761 查看
1.问题简介
给定一个迷宫,指明起点和终点,找出从起点出发到终点的有效可行路径,就是迷宫问题(maze problem)。迷宫可以以二维数组来存储表示。0表示通路,1表示障碍。注意这里规定移动可以从上、下、左、右四方方向移动。坐标以行和列表示,均从0开始,给定起点(0,0)和终点(4,4),迷宫表示如下:
int maze[5][5]={ {0,0,0,0,0}, {0,1,0,1,0}, {0,1,1,0,0}, {0,1,1,0,1}, {0,0,0,0,0} };
那么下面的迷宫就有两条可行的路径,分别为:
(1)(0,0) (0,1) (0,2) (0,3) (0,4) (1,4) (2,4) (2,3) (3,3) (4,3) (4,4);
(2)(0,0) (1,0) (2,0) (3,0) (4,0) (4,1) (4,2) (4,3) (4,4) ;
可见,迷宫可行路径有可能是多条,且路径长度可能不一。
2.求解方法
迷宫问题的求解可以抽象为连通图的遍历,因此主要有两种方法。第一种方法是:深度优先搜索(DFS)加回溯。
其优点:无需像广度优先搜索那样(BFS)记录前驱结点。
其缺点:找到的第一条可行路径不一定是最短路径,如果需要找到最短路径,那么需要找出所有可行路径后,再逐一比较,求出最短路径。
第二种方法是:广度优先搜索(BFS)。
其优点:找出的第一条路径就是最短路径。
其缺点:需要记录结点的前驱结点,来形成路径。
下面将给出上面两种方法的具体步骤和实现。
3.方法详解与具体实现
3.1深度优先搜索(DFS)加回溯求解第一条可行路径
3.1.1实现步骤
(1)给定起点和终点,判断二者的合法性,如果不合法,返回;(2)如果起点和终点合法,将起点入栈;
(3)取栈顶元素,求其邻接的未被访问的无障碍结点。求如果有,记其为已访问,并入栈。如果没有则回溯上一结点,具体做法是将当前栈顶元素出栈。
其中,求邻接无障碍结点的顺序可任意,本文实现是以上、右、下、左的顺序求解。
(4)重复步骤(3),直到栈空(没有找到可行路径)或者栈顶元素等于终点(找到第一条可行路径)。
3.1.2具体实现
#include <iostream>
#include <stack>
using namespace std;
struct Point{
//行与列
int row;
int col;
Point(int x,int y){
this->row=x;
this->col=y;
}
bool operator!=(const Point& rhs){
if(this->row!=rhs.row||this->col!=rhs.col)
return true;
return false;
}
};
//func:获取相邻未被访问的节点
//para:mark:结点标记,point:结点,m:行,n:列
//ret:邻接未被访问的结点
Point getAdjacentNotVisitedNode(bool** mark,Point point,int m,int n){
Point resP(-1,-1);
if(point.row-1>=0&&mark[point.row-1][point.col]==false){//上节点满足条件
resP.row=point.row-1;
resP.col=point.col;
return resP;
}
if(point.col+1<n&&mark[point.row][point.col+1]==false){//右节点满足条件
resP.row=point.row;
resP.col=point.col+1;
return resP;
}
if(point.row+1<m&&mark[point.row+1][point.col]==false){//下节点满足条件
resP.row=point.row+1;
resP.col=point.col;
return resP;
}
if(point.col-1>=0&&mark[point.row][point.col-1]==false){//左节点满足条件
resP.row=point.row;
resP.col=point.col-1;
return resP;
}
return resP;
}
//func:给定二维迷宫,求可行路径
//para:maze:迷宫;m:行;n:列;startP:开始结点 endP:结束结点; pointStack:栈,存放路径结点
//ret:无
void mazePath(void* maze,int m,int n,const Point& startP,Point endP,stack<Point>& pointStack){
//将给定的任意列数的二维数组还原为指针数组,以支持下标操作
int** maze2d=new int*[m];
for(int i=0;i<m;++i){
maze2d[i]=(int*)maze+i*n;
}
if(maze2d[startP.row][startP.col]==1||maze2d[endP.row][endP.col]==1)
return ; //输入错误
//建立各个节点访问标记
bool** mark=new bool*[m];
for(int i=0;i<m;++i){
mark[i]=new bool
;
}
for(int i=0;i<m;++i){
for(int j=0;j<n;++j){
mark[i][j]=*((int*)maze+i*n+j);
}
}
//将起点入栈
pointStack.push(startP);
mark[startP.row][startP.col]=true;
//栈不空并且栈顶元素不为结束节点
while(pointStack.empty()==false&&pointStack.top()!=endP){
Point adjacentNotVisitedNode=getAdjacentNotVisitedNode(mark,pointStack.top(),m,n);
if(adjacentNotVisitedNode.row==-1){ //没有未被访问的相邻节点
pointStack.pop(); //回溯到上一个节点
continue;
}
//入栈并设置访问标志为true
mark[adjacentNotVisitedNode.row][adjacentNotVisitedNode.col]=true;
pointStack.push(adjacentNotVisitedNode);
}
}
int main(){
int maze[5][5]={ {0,0,0,0,0}, {0,1,0,1,0}, {0,1,1,0,0}, {0,1,1,0,1}, {0,0,0,0,0} };
Point startP(0,0);
Point endP(4,4);
stack<Point> pointStack;
mazePath(maze,5,5,startP,endP,pointStack);
//没有找打可行解
if(pointStack.empty()==true)
cout<<"no right path"<<endl;
else{
stack<Point> tmpStack;
cout<<"path:";
while(pointStack.empty()==false){
tmpStack.push(pointStack.top());
pointStack.pop();
}
while (tmpStack.empty()==false){
printf("(%d,%d) ",tmpStack.top().row,tmpStack.top().col);
tmpStack.pop();
}
}
getchar();
}
程序输出:path:(0,0) (0,1) (0,2) (0,3) (0,4) (1,4) (2,4) (2,3) (3,3) (4,3) (4,4)。
可见该条路径不是最短路径。因为程序中给定的迷宫还有一条更短路径为:(0,0) (1,0) (2,0) (3,0) (4,0) (4,1) (4,2) (4,3) (4,4) ;
如果我们调整调用寻找下一个未访问的相邻结点的顺序,可换成先左右,后上下,可能会得到更短的路径,但无法确保在任何情况下都能得到最短路径。
3.2改进深度优先搜索(DFS)加回溯求解最短路径
3.2.1改进办法
根据上面的方法我们可以在此基础之上进行改进,求出迷宫的最短的路径。具体做法如下:(1)让已经访问过的结点可以再次被访问,具体做法是将mark标记改为当前结点到起点的距离,作为当前结点的权值。即从起点开始出发,向四个方向查找,每走一步,把走过的点的值+1;
(2)寻找栈顶元素的下一个可访问的相邻结点,条件就是栈顶元素的权值加1必须小于下一个节点的权值(墙不能走,未被访问的结点权值为0);
(3)如果访问到终点,记录当前最短的路径。如果不是,则继续寻找下一个结点;
(4)重复步骤(2)和(3)直到栈空(迷宫中所有符合条件的结点均被访问)。
3.2.2具体实现
#include <iostream> #include <stack> #include <vector> using namespace std; struct Point{ //行与列 int row; int col; Point(int x,int y){ this->row=x; this->col=y; } bool operator!=(const Point& rhs){ if(this->row!=rhs.row||this->col!=rhs.col) return true; return false; } bool operator==(const Point& rhs) const{ if(this->row==rhs.row&&this->col==rhs.col) return true; return false; } }; int maze[5][5]={ {0, 0, 0, 0,0}, {0,-1, 0,-1,0}, {0,-1,-1, 0,0}, {0,-1,-1, 0,-1}, {0, 0, 0, 0, 0} }; //func:获取相邻未被访问的节点 //para:mark:结点标记;point:结点;m:行;n:列;endP:终点 //ret:邻接未被访问的结点 Point getAdjacentNotVisitedNode(int** mark,Point point,int m,int n,Point endP){ Point resP(-1,-1); if(point.row-1>=0){ if(mark[point.row-1][point.col]==0||mark[point.row][point.col]+1<mark[point.row-1][point.col]){//上节点满足条件 resP.row=point.row-1; resP.col=point.col; return resP; } } if(point.col+1<n){ if(mark[point.row][point.col+1]==0||mark[point.row][point.col]+1<mark[point.row][point.col+1]){//右节点满足条件 resP.row=point.row; resP.col=point.col+1; return resP; } } if(point.row+1<m){ if(mark[point.row+1][point.col]==0||mark[point.row][point.col]+1<mark[point.row+1][point.col]){//下节点满足条件 resP.row=point.row+1; resP.col=point.col; return resP; } } if(point.col-1>=0){ if(mark[point.row][point.col-1]==0||mark[point.row][point.col]+1<mark[point.row][point.col-1]){//左节点满足条件 resP.row=point.row; resP.col=point.col-1; return resP; } } return resP; } //func:给定二维迷宫,求可行路径 //para:maze:迷宫;m:行;n:列;startP:开始结点 endP:结束结点; pointStack:栈,存放路径结点;vecPath:存放最短路径 //ret:无 void mazePath(void* maze,int m,int n, Point& startP, Point endP,stack<Point>& pointStack,vector<Point>& vecPath){ //将给定的任意列数的二维数组还原为指针数组,以支持下标操作 int** maze2d=new int*[m]; for(int i=0;i<m;++i){ maze2d[i]=(int*)maze+i*n; } if(maze2d[startP.row][startP.col]==-1||maze2d[endP.row][endP.col]==-1) return ; //输入错误 //建立各个节点访问标记,表示结点到到起点的权值,也记录了起点到当前结点路径的长度 int** mark=new int*[m]; for(int i=0;i<m;++i){ mark[i]=new int ; } for(int i=0;i<m;++i){ for(int j=0;j<n;++j){ mark[i][j]=*((int*)maze+i*n+j); } } if(startP==endP){//起点等于终点 vecPath.push_back(startP); return; } //增加一个终点的已被访问的前驱结点集 vector<Point> visitedEndPointPreNodeVec; //将起点入栈 pointStack.push(startP); mark[startP.row][startP.col]=true; //栈不空并且栈顶元素不为结束节点 while(pointStack.empty()==false){ Point adjacentNotVisitedNode=getAdjacentNotVisitedNode(mark,pointStack.top(),m,n,endP); if(adjacentNotVisitedNode.row==-1){ //没有符合条件的相邻节点 pointStack.pop(); //回溯到上一个节点 continue; } if(adjacentNotVisitedNode==endP){//以较短的路劲,找到了终点, mark[adjacentNotVisitedNode.row][adjacentNotVisitedNode.col]=mark[pointStack.top().row][pointStack.top().col]+1; pointStack.push(endP); stack<Point> pointStackTemp=pointStack; vecPath.clear(); while (pointStackTemp.empty()==false){ vecPath.push_back(pointStackTemp.top());//这里vecPath存放的是逆序路径 pointStackTemp.pop(); } pointStack.pop(); //将终点出栈 continue; } //入栈并设置访问标志为true mark[adjacentNotVisitedNode.row][adjacentNotVisitedNode.col]=mark[pointStack.top().row][pointStack.top().col]+1; pointStack.push(adjacentNotVisitedNode); } } int main(){ Point startP(0,0); Point endP(4,4); stack<Point> pointStack; vector<Point> vecPath; mazePath(maze,5,5,startP,endP,pointStack,vecPath); if(vecPath.empty()==true) cout<<"no right path"<<endl; else{ cout<<"shortest path:"; for(auto i=vecPath.rbegin();i!=vecPath.rend();++i) printf("(%d,%d) ",i->row,i->col); } getchar(); }
程序输出最短路径如下:
如果将程序的迷宫改为如下:
int maze[5][3]={ 0, -1, 0, 0, -1 ,0, 1, -1, 0 , 0, -1, 0, 0 ,0, 0};
输出:
代码相关说明:
对比3.1.2的代码,根据改进的办法,可以看到上段代码修改的地方主要有三个地方:
(1)mark标记改为结点权值,记录起点到结点的路径长度。因此起点的权值为0。
(2)为适应mark标记,将迷宫的墙改为-1,以免与结点权值混淆。
(3)求解下一个访问的结点,判断条件是结点的权值要小于其当前权值。
3.3广度优先搜索(BFS)求解迷宫的最短路径
广度优先搜索的优点是找出的第一条路径就是最短路径,所以经常用来搜索最短路径,思路和图的广度优先遍历一样,需要借助于队列。具体步骤:
(1)从入口元素开始,判断它上下左右的邻边元素是否满足条件,如果满足条件就入队列;
(2)取队首元素并出队列。寻找其相邻未被访问的元素,将其如队列并标记元素的前驱节点为队首元素。
(3)重复步骤(2),直到队列为空(没有找到可行路径)或者找到了终点。最后从终点开始,根据节点的前驱节点找出一条最短的可行路径。
具体实现:
以C++为例:
#include <iostream> #include <queue> using namespace std; struct Point{ //行与列 int row; int col; //默认构造函数 Point(){ row=col=-1; } Point(int x,int y){ this->row=x; this->col=y; } bool operator==(const Point& rhs) const{ if(this->row==rhs.row&&this->col==rhs.col) return true; return false; } }; int maze[5][5]={ {0,0,0,0,0}, {0,1,0,1,0}, {0,1,1,1,0}, {0,1,0,0,1}, {0,0,0,0,0} }; void mazePath(void* maze,int m,int n, Point& startP, Point endP,vector<Point>& shortestPath){ int** maze2d=new int*[m]; for(int i=0;i<m;++i){ maze2d[i]=(int*)maze+i*n; } if(maze2d[startP.row][startP.col]==1||maze2d[startP.row][startP.col]==1) return ; //输入错误 if(startP==endP){ //起点即终点 shortestPath.push_back(startP); return; } //mark标记每一个节点的前驱节点,如果没有则为(-1,-1),如果有,则表示已经被访问 Point** mark=new Point*[m]; for(int i=0;i<m;++i){ mark[i]=new Point ; } queue<Point> queuePoint; queuePoint.push(startP); //将起点的前驱节点设置为自己 mark[startP.row][startP.col]=startP; while(queuePoint.empty()==false){ Point pointFront=queuePoint.front(); queuePoint.pop(); if(pointFront.row-1>=0 && maze2d[pointFront.row-1][pointFront.col]==0){//上节点连通 if(mark[pointFront.row-1][pointFront.col]==Point()){//上节点未被访问,满足条件,如队列 mark[pointFront.row-1][pointFront.col]=pointFront; queuePoint.push(Point(pointFront.row-1,pointFront.col)); //入栈 if(Point(pointFront.row-1,pointFront.col)==endP){ //找到终点 break; } } } if(pointFront.col+1<n && maze2d[pointFront.row][pointFront.col+1]==0){//右节点连通 if(mark[pointFront.row][pointFront.col+1]==Point()){//右节点未被访问,满足条件,如队列 mark[pointFront.row][pointFront.col+1]=pointFront; queuePoint.push(Point(pointFront.row,pointFront.col+1)); //入栈 if(Point(pointFront.row,pointFront.col+1)==endP){ //找到终点 break; } } } if(pointFront.row+1<m && maze2d[pointFront.row+1][pointFront.col]==0){//下节点连通 if(mark[pointFront.row+1][pointFront.col]==Point()){//下节点未被访问,满足条件,如队列 mark[pointFront.row+1][pointFront.col]=pointFront; queuePoint.push(Point(pointFront.row+1,pointFront.col)); //入栈 if(Point(pointFront.row+1,pointFront.col)==endP){ //找到终点 break; } } } if(pointFront.col-1>=0 && maze2d[pointFront.row][pointFront.col-1]==0){//左节点连通 if(mark[pointFront.row][pointFront.col-1]==Point()){//上节点未被访问,满足条件,如队列 mark[pointFront.row][pointFront.col-1]=pointFront; queuePoint.push(Point(pointFront.row,pointFront.col-1)); //入栈 if(Point(pointFront.row,pointFront.col-1)==endP){ //找到终点 break; } } } } if(queuePoint.empty()==false){ int row=endP.row; int col=endP.col; shortestPath.push_back(endP); while(!(mark[row][col]==startP)){ shortestPath.push_back(mark[row][col]); row=mark[row][col].row; col=mark[row][col].col; } shortestPath.push_back(startP); } } int main(){ Point startP(0,0); Point endP(4,4); vector<Point> vecPath; mazePath(maze,5,5,startP,endP,vecPath); if(vecPath.empty()==true) cout<<"no right path"<<endl; else{ cout<<"shortest path:"; for(auto i=vecPath.rbegin();i!=vecPath.rend();++i) printf("(%d,%d) ",i->row,i->col); } getchar(); }
程序输出:
代码的几点说明:
(1)BFS求迷宫最短路径,记录每个节点的前驱节点使用了mark标记。可见,三种方法中mark标记可以根据实际需求灵活为其赋予意义。
(2)特殊的,起始节点的前驱设置为其本身。
小结
告诫。看着别人的代码去理解问题是如何求解的,对于求解算法题来说,这种方法是错误的。正确的步骤是看别人的思路,理解如何求解后,给出自己的实现,才能够真正的深刻的掌握该题的求解。经过自己思考的才能真正成为自己的东西。不然的话,看着别人的代码痛苦不说,而且每个人的实现在很多细节都不相同,即是花了很长时间,暂时弄明白了,我想过不了多久就会忘记。这样,得不偿失啊!参考文献
[1]http://blog.csdn.net/a1259109679/article/details/48084951[2]http://blog.csdn.net/bone_ace/article/details/41283585
相关文章推荐
- HDU-ACM2050
- 设计模式——原型模式
- 利用脚本获取mysql的tps,qps等状态信息
- Spark-Avro学习4之使用AvroWritePartitioned存储AVRO文件时进行划分
- 第二周编程题-时间换算
- Win7下编译Qt5.4OCI驱动
- php支持断点续传、分块下载的类
- 重装Ubuntu配置编程环境LAMP,J2EE从0开始
- Spark RDD API详解Map和Reduce
- 3 C语言 流程控制 循环 跳转
- ios开发学习笔记--数据持久化之偏好设置(NSUserDefault)
- js的clearInterval()
- 第一周编程题-逆序的三位数
- ACS5.X -AD-tacacs+ authentication
- HDU-ACM2049--错排问题的应用
- 网络仿真工具TOTEM之——环境配置
- Oracle 11g R2 RAC高可用性连接
- vs2012新建项目产生的问题
- leetcode 258---Add Digits, 关于C++中负数取余
- poj2135 最小费用最大流模板