迷宫问题（maze problem）—— 深度优先与广度优先搜索求解

最新推荐文章于 2024-09-15 20:02:53 发布
最新推荐文章于 2024-09-15 20:02:53 发布
阅读量6.6w 收藏 365
点赞数 77
分类专栏： 算法与数据结构 文章标签： 深度优先 广度优先 迷宫问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/k346k346/article/details/51289478
版权

文章目录

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}
};

那么下面的迷宫就有两条可行的路径，分别为：

(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) ；

可见，迷宫可行路径可能有多条，且路径长度可能不一。

2.求解方法

迷宫问题的求解可以抽象为连通图的遍历，因此主要有两种方法。

第一种方法：深度优先搜索（DFS）加回溯。
优点： 无需像广度优先搜索那样（BFS）记录前驱结点。
缺点： 找到的第一条可行路径不一定是最短路径，如果需要找到最短路径，那么需要找出所有可行路径后，再逐一比较，求出最短路径。

第二种方法：广度优先搜索（BFS）。
优点： 找出的第一条路径就是最短路径。
缺点： 需要记录结点的前驱结点，来形成路径。

下面将给出上面两种方法的具体步骤和实现。

3.深度优先搜索加回溯法

3.1 求解第一条可行路径

实现步骤：
（1）给定起点和终点，判断二者的合法性，如果不合法，返回；
（2）如果起点和终点合法，将起点入栈；
（3）取栈顶元素，求其邻接的未被访问的无障碍结点。求如果有，记其为已访问，并入栈。如果没有则回溯上一结点，具体做法是将当前栈顶元素出栈。其中，求邻接无障碍结点的顺序可任意，本文实现是以上、右、下、左的顺序求解。
（4）重复步骤（3），直到栈空（没有找到可行路径）或者栈顶元素等于终点（找到第一条可行路径）。

实现示例：

#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[n];
	}
	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();
		}
	}
}

程序输出：

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 求解最短路径

根据上面的方法我们可以在此基础之上进行改进，求出迷宫的最短路径。具体做法如下：
（1）让已经访问过的结点可以再次被访问，具体做法是将mark标记改为当前结点到起点的距离，作为当前结点的权值。即从起点开始出发，向四个方向查找，每走一步，把走过的点的值+1；

（2）寻找栈顶元素的下一个可访问的相邻结点，条件就是栈顶元素的权值加1必须小于下一个节点的权值(墙不能走，未被访问的结点权值为0)；

（3）如果访问到终点，记录当前最短的路径。如果不是，则继续寻找下一个结点；

（4）重复步骤（2）和（3）直到栈空（迷宫中所有符合条件的结点均被访问）。

实现示例：

#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;
	}
};  

//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[n];
	}
	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] = 1;

	//栈不空并且栈顶元素不为结束节点
	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 存放的是逆序路径
				vecPath.push_back(pointStackTemp.top());
				pointStackTemp.pop();
			}
			pointStack.pop(); //将终点出栈
			continue;
		}
		
		//入栈并设置结点权值
		mark[adjacentNotVisitedNode.row][adjacentNotVisitedNode.col]=mark[pointStack.top().row][pointStack.top().col]+1;
		pointStack.push(adjacentNotVisitedNode);
	}
}

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}
};

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

程序输出最短路径如下：
这里写图片描述
如果将程序的迷宫改为如下:

int maze[5][3] = {
0, -1, 0, 
0, -1 ,0,
1, -1, 0 ,
0, -1, 0,
0 ,0,  0};

输出：
这里写图片描述
根据改进的办法，可以看到上段代码修改的地方主要有三个地方：
（1）mark 标记改为结点权值，记录起点到结点的路径长度。特殊地，起点的权值记为 1。
（2）为适应 mark 标记，将迷宫的墙改为 -1，以免与结点权值混淆。
（3）求解下一个访问的结点，判断条件是结点的权值要小于其当前权值。

4.广度优先搜索

广度优先搜索的优点是找出的第一条路径就是最短路径，所以经常用来搜索最短路径，思路和图的广度优先遍历一样，需要借助队列。

实现步骤：
（1）从入口元素开始，判断它上下左右的邻边元素是否满足条件，如果满足条件就入队列；
（2）取队首元素并出队列。寻找其相邻未被访问的元素，将其如队列并标记元素的前驱节点为队首元素；
（3）重复步骤（2），直到队列为空（没有找到可行路径）或者找到了终点。最后从终点开始，根据节点的前驱节点找出一条最短的可行路径。

实现示例：

#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[n];
	}

	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] 迷宫最短路径问题解析
[2] 迷宫问题

恋喵大鲤鱼
关注
专栏目录
数据结构实践——迷宫问题之图深度优先遍历解法
Katie466的博客
11-09 815
问题及描述： /* * Copyright (c) 2015, 烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称： LiString.cpp,main.cpp,LiString.h * 作者：高哲 * 完成日期：2015年11月9日 * 版本号：codeblocks * * 问
迷宫求解算法（栈DFS以及队列BFS）
日复一日，年复一年
11-03 4785
我们首先给出一个迷宫，它的规格是5 * 5，在这里我使用int的二维数组表示迷宫，其中1表示障碍，0表示可以通行的道路，要求从（0，0）坐标走到（4， 4）坐标，并输出走过的坐标路径。int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0,}
BFS——迷宫问题（求最短路）
biongbiongdou的博客
04-14 1790
题目：给定一个大小为 N×M 的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四格的通道移动。请求出从起点到终点所需的最小步数。请注意，本题假定从起点一定可以移动到终点。限制条件;N, M ≤ 100Input：Output：22代码：// // main.cpp // BFS（迷宫问题自己写） // // Created by showlo on 2018/4/13. // Co...
以深度优先搜索算法完成迷宫寻路，超简单！！！
最新发布
yhw52066的博客
09-15 560
‌‌深度优先搜索算法DFS）是一种用于遍历或搜索树或‌图的算法。‌ 它沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所有边都已被探寻过，或者节点不满足条件时，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行，直到所有节点都被访问为止。‌
经典算法----迷宫问题（找出所有路径）
m0_73633088的博客
10-07 4504
经典算法-----迷宫问题（栈的应用）-CSDN博客），但是这个方法只可以找到一条路径，那么今天我们就进一步去讲解迷宫问题，通过回溯算法来找到全部的路径，下面就一起来看看吧！同样的，每走到一个位置就要想该往哪一个方向去走，所以有东南西北这4个方向，每次往一个方向走之后就标记好当前方向和当前位置，然后同样的去进行分享的试探，当走到没路走的时候就进行原路返回。//试探方向存储结构int xx, yy;}Direction;//东南西北。
迷宫问题解决方法：分别基于深度搜索和广度搜索的思想来实现
weixin_30367543的博客
05-08 329
本文针对迷宫问题，探讨解决思路并给出实现代码。在本文中，采用的图的深度优先搜索和广度优先搜索两种方法分别对迷宫的路径进行了求解。 首先来看迷宫问题的描述，可以参考此处，简而言之就是，通过一个二维数组（int型）来表示迷宫，迷宫中0表示可行，1表示不可行。在本文的实现中，可以输入给定迷宫，定义迷宫入口和出口，并查找迷宫路径。 总体的描述：在...
第12周项目5-迷宫问题之图深度优先遍历解法
进击的葱
11-19 736
问题： /* * Copyright(c)2015,烟台大学计算机学院 * All right reserved. * 文件名称：项目5.cbp * 作者： * 完成日期；2015年11月19日 * 版本号；v1.0 * 问题描述： 设计一个程序，采用深度优先遍历算法的思路，解决迷宫问题。 　　（1）建立迷宫对应的图数据结构，并建立其邻接表表示。
利用深度优先搜索算法和广度优先搜索算法解迷宫问题
believexfr的博客
10-22 2721
本来应该是在大一就该掌握的内容，我却迟迟没有去了解，最近比较闲，今天就好好讨论一下图搜索算法的两个分支，深度优先算法与广度优先算法。本篇博客将分别利用深度优先算法和广度优先算法解决迷宫问题。 　　所谓迷宫问题，这里我们用一个二维数组 map[5][5]={ 　　　　　　　　0,1,0,0,1 　　　　　　　　0,0,0,0,0 　　　　　　　　1,0,0,0,1
第十二周--迷宫问题之图深度优先遍历
sunsunzice的博客
11-17 360
/ 作 者：孙子策 完成日期：2016.11.17 问题描述：设计一个程序，采用深度优先遍历算法的思路，解决迷宫问题。 　　（1）建立迷宫对应的图数据结构，并建立其邻接表表示。 　　（2）采用深度优先遍历的思路设计算法，输出从入口(1,1)点到出口(M,N)的所有迷宫路径。 [模型建立] 　　将迷宫中的每一格作为一个顶点，相邻格子可以到达，则对应的顶点之间存在边
【A*搜索在迷宫中的应用】：提升效率与实现技巧
迷宫问题与A*搜索算法概述 迷宫问题历来是计算机科学中的一个经典问题，它不仅是算法理论和人工智能教学的常用案例，也是许多实际应用中的一个抽象模型。迷宫求解的核心是寻找从起点到终点的有效路径，并保证路径...
DFS/BFS 关于迷宫问题
cyh452014310的博客
10-11 779
DFS和BFS是两种不同的搜索方法。DFS是深度优先，即沿着一条链走直到走不通了为止。BFS是广度优先，搜索的链是以距离向外辐射的。 以一道经典的迷宫图为例来说明这两种搜索方法的用处。 BFS不考虑结果的可能位置，彻底地搜索整张图，而在迷宫问题中，可以求出一个点到另外一个点的最短距离。 而DFS在迷宫的问题中，搜索每一条可能能到的路径，对应的即搜索一个点到另外一个点所有可能的路径。 给定一
C/C++经典算法深度解析与实战指南
5. **老鼠走迷宫（Mouse Maze）**：动态规划或广度优先搜索（BFS）的实际运用，模拟寻找最短路径。 6. **骑士走棋盘**：探索回溯法或曼哈顿距离在棋类游戏中的策略。 7. **八皇后问题**：经典问题，用回溯法或位...
经典算法实例详解：从河内之塔到约瑟夫问题
5. **老鼠走迷宫 (Maze Traversal)**：这是路径搜索问题的一个例子，通常使用深度优先搜索或广度优先搜索来解决。 6. **骑士走棋盘 (Knight's Tour)**：骑士在棋盘上移动，要求每个格子只访问一次，涉及到状态空间...
广度优先搜索和深度优先搜索（迷宫）
rain_island的博客
05-04 916
广度优先搜索和深度优先搜索 诶，思来想去，还是要关于这个写一篇博客的。（毕竟当初为了看懂这两个东西并且自己写出代码，花了好长好长的时间。）上次蓝桥杯中出现了一道关于迷宫的题目，当时写了好久写不出来，很气，于是下定决心要把这两个东西看看懂。而最近又回到了图论的问题，于是这两玩意又出来了。。 第一次接触DFS，是在《啊哈，C》中 解救小哈 一问题的解决。 先来讲一下这两者的算法思想吧。（这里感谢我...
利用深度优先搜索（dfs）来解决迷宫问题
weixin_45843077的博客
02-22 2558
#include<bits/stdc++.h> using namespace std; int r,c,num=1000000; char a[41][41]; int u[4]={1,-1,0,0},v[4]={0,0,1,-1}; void search(int x,int y,int k){ if(x==r-1&&y==c-1){ if(num>k){ n...
迷宫求解(深度优先)
qq_51544319的博客
03-24 2553
迷宫求解 **问题初始条件：**给定一副地图，一个开始坐标，一个结束坐标，寻找一条可以从开始坐标到结束坐标的路径 **问题分析：**可以用栈存储路径的坐标且坐标应有横纵两个属性来对应迷宫二维数组中的位置，此外还需要一个属性来确定方向下一个走到的路径的坐标，定义坐标结构体如下： typedef struct { int row; int col; int walk;//判断方向 }PosType; **问题关键：**如何走迷宫，首先不能走自己已经走过的路，其次不能走地图中不可走的路，当排除这两个条件后
深度优先搜索和广度优先搜索及典例分析(走迷宫问题(BFS)和棋盘问题(DFS))
木牛的博客
04-27 1455
搜索算法在实际编程应用中起着举足轻重的作用，学会掌握搜索算法并熟练应用搜索算法来解决实际问题不得不说是一件相当COOL的事，所以我将深度搜索和广度搜索认真地做了详细的总结，与诸君共勉，也方便以后查阅复习 广度优先搜索(BFS) 顾名思义，追求的是”覆盖面积”， 现在来一张简单的有向图，广度搜索就是按照那个顺序搜索的，像有句话所说，道生一，一生二，二生万物！ 具体思想：从图中某顶点a出发，在访问了a之后依次访问a的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使得“先被访问的
Maze Problem（求最短距离）BFS
weixin_34130269的博客
01-06 167
题目链接：http://openoj.awaysoft.com/JudgeOnline/problem.php?id=1107 不多说，求最短距离~BFS 1 #include<stdio.h> 2 #include<string.h> 3 char ma[110][110]; 4 int vis[110][110],dist[110][110],...
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值