迷宫（蓝桥杯C/C++）dfs详解

最新推荐文章于 2024-04-23 14:32:20 发布
最新推荐文章于 2024-04-23 14:32:20 发布
阅读量2.2k 收藏 29
点赞数 9
分类专栏： 蓝桥杯 文章标签： 蓝桥杯 深度优先 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73750670/article/details/128880986
版权

题目描述
下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可以通行的地方。

010000
000100
001001
110000

110000迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。

对于上面的迷宫，从入口开始，可以按 DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式，其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。

请注意在字典序中 D<L<R<U。

01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000

运行限制
• 最大运行时间：1s
• 最大运行内存: 256M

题目过于复杂，接下来我将分为四步依次讲解，想直接看代码的直接点击目录哈~

第一步 简化迷宫，输出步数

我们先用dfs做，在迷宫中，建立坐标系，x轴正方向向下，y轴正方向向右，一共有上下左右四个方向，那么就可以建立三个数组，前两个表示在坐标中的位移，第三个表示方向，上下一一对应，比如R表示右，也就是x不变，y位移加一。

const int dirx[4]={0,0,1,-1};
const int diry[4]={1,-1,0,0};
const char dir[5]={'R','L','D','U'};

建立数组存迷宫，为了使起点为（1,1），补齐首行0，和首列0，所以row和col比实际的大1个

int maze[row+1][col+1]=
{
0,0,0,0,0,0,0,    
0,0,1,0,0,0,0,
0,0,0,0,1,0,0,
0,0,0,1,0,0,1,
0,1,1,0,0,0,0,
};

dfs(x,y,pos)，pos为起点到x,y的步数，从（x,y）到（tox,toy）需要一步，所以起点到(tox,toy)需要pos+1步。

接下来的讲解都在代码注释中：

#include<iostream>
#include<cstring>
using namespace std;
const int dirx[4]={0,0,1,-1};
const int diry[4]={1,-1,0,0};
const char dir[5]={'R','L','D','U'};
//4行6列
const int row =4,col =6;
const int maxrc=6; 
//以左上角第一个位置为起点，往下x方向，往右y方向
//因为C语言的数组从0开始计，此处为了易于理解，从maze[1][1]存放迷宫
//maze内容如下
int maze[row+1][col+1]=
{
0,0,0,0,0,0,0,    
0,0,1,0,0,0,0,
0,0,0,0,1,0,0,
0,0,0,1,0,0,1,
0,1,1,0,0,0,0,
};
int best;//从起点到出口的最小步数
int mins[maxrc+5][maxrc+5];//存从起点到该点的步数 

bool judge(int x,int y) {//判断这个点是否越界，是否可以走。
	if(x>0&&x<=row&&y>0&&y<=col&&!maze[x][y])
		return true;//这个点没越界，而且可以走。 
	return false; 
}
void dfs(int x,int y,int pos) {
	if(pos>best)//如果当前路径已经走的步长pos大于之前可行方案最短路径长度 ， 
		return ;//就无需沿着现有的路径继续走下去了，这个剪枝可以加快速度 
	if(x==row&&y==col) {//到达终点 
		if(pos<best) {//更短的路径记录下来
			best=pos; 
		}
		return ;
	}
	for(int i=0;i<4;i++) {//四个方向 
		int tox=x+dirx[i];//走向（tox，toy）位置 
		int toy=y+diry[i];
		if(judge(tox,toy)&&pos+1<=mins[tox][toy]) {
			//去往（tox，toy) 是合法的，没有越界，也是标记为0的可以行走的位置
			//并且当前的走法能够使得去到 (tox，toy) 步数更小 
			//就进入此if之内 
			maze[tox][toy]=1;//现在走到（tox，toy）了，走过了，就标记为障碍，那么下次就不能走了 
			mins[tox][toy]=pos+1;//当前的走法，到达（tox,toy）的步数比以前到过的步数更小
			//就把当前走法到达 （tox,toy）的步数更新 
			dfs(tox,toy,pos+1);//继续以(tox,toy,pos+1)深搜 
			maze[tox][toy]=0;//回溯找短的路，或者是字典序最小的。
			//恢复 （tox，toy）为0，即可行状态，好尝试其他位置在以后会走向它 
		}
	}
}
int main()
{
	memset(mins,0x3f,sizeof(mins));
	best=1<<28;
	//因为要求最小的，所以将mins数组和best初始化为很大的数 
	maze[1][1]=1;//标记起始点走过来，也就是变为障碍物，不再能走到它 
	dfs(1,1,1);//从起始点（1，1）1 开始深搜 
	cout<<best-1<<endl;// 因为bfs初始步数设为1，所以最后要减1 
	return 0;
}

有了这个代码，就可以把代码中的迷宫换成30行50列的迷宫，将row和col的值修改，可以得出步数。

第二步 加路径

定义string ans,temp和char a[row*col+5]，在深搜的时候，数组a记录第pos步的方位，到达终点时，从1遍历到pos，把所有的方位连接到temp字符串中，如果pos<best，则更新。

完整代码

#include<iostream>
#include<cstring>
using namespace std;
const int dirx[4]={0,0,1,-1};
const int diry[4]={1,-1,0,0};
const char dir[5]={'R','L','D','U'};
//4行6列
const int row =4,col =6;
const int maxrc=6; 
//以左上角第一个位置为起点，往下x方向，往右y方向
//maze内容如下
int maze[row+1][col+1]=
{0,0,0,0,0,0,0,    
0,0,1,0,0,0,0,
0,0,0,0,1,0,0,
0,0,0,1,0,0,1,
0,1,1,0,0,0,0,
};
int mins[maxrc+5][maxrc+5];
char a[row*col+5];
int best;
string ans;
bool judge(int x,int y) {//判断这个点是否越界，是否可以走。
	if(x>0&&x<=row&&y>0&&y<=col&&!maze[x][y])
		return true;//这个点没越界，而且可以走。 
	return false; 
}
void dfs(int x,int y,int pos) {
	if(pos>best)//如果当前路径已经走的步长pos大于之前可行方案最短路径长度 ， 
		return ;//就无需沿着现有的路径继续走下去了，这个剪枝可以加快速度 
	if(x==row&&y==col) {//到达终点 
		string temp;//用temp把每次存的方向连接起来 
			for(int i=1;i<pos;i++)
				temp+=a[i];//路径 
		if(pos<best) {//更短的路径记录下来
			ans=temp;
			best=pos; 
		}
		else if(pos==best&&temp<ans)	ans=temp;//在实现路时最短的同时，保证字典序最小。
		return ;
	}
	for(int i=0;i<4;i++) {//四个方向 
		int tox=x+dirx[i];//走向（tox，toy）位置 
		int toy=y+diry[i];
		if(judge(tox,toy)&&pos+1<=mins[tox][toy]) {
			//去往（tox，toy) 是合法的，没有越界，也是标记为0的可以行走的位置
			//并且当前的走法能够使得去到 (tox，toy) 步数更小 
			//就进入此if之内 
			maze[tox][toy]=1;//现在走到（tox，toy）了，走过了，就标记为障碍，那么下次就不能走了 
			mins[tox][toy]=pos+1;//当前的走法，到达（tox,toy）的步数 比以前到过的步数更小
			//就把当前走法到达 （tox,toy）的步数更新 
			a[pos]=dir[i];//记录第pos步的方位 
			dfs(tox,toy,pos+1);//继续以(tox,toy,pos+1)深搜 
			maze[tox][toy]=0;//回溯找短的路，或者是字典序最小的。
			//恢复 （tox，toy）为0，即可行状态，好尝试其他位置在以后会走向它 
		}
	}
}
int main()
{

	memset(mins,1,sizeof(mins));
	best=1<<28;
	maze[1][1]=1;//标记起始点走过来，也就是变为障碍物，不再能走到它 
	dfs(1,1,1);//从起始点（1，1）1步 开始深搜 
	cout<<ans<<endl;
	cout<<best-1<<endl;
	return 0;
}

第三步 本题完整代码

#include<iostream>
#include<cstring>
using namespace std;
const int dirx[4]={0,0,1,-1};
const int diry[4]={1,-1,0,0};
const char dir[5]={'R','L','D','U'};
//4行6列
const int row =30,col =50;
const int maxrc=50; 
//以左上角第一个位置为起点，往下x方向，往右y方向
//因为C语言的数组从0开始计，此处为了易于理解和讲授，从maze[1][1]存放迷宫//左上角的内容。所以补齐首行0，和首列0，所以row和col比实际的大1个，//maze内容如下
int maze[row+1][col+1]=
{
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,1,0,1,0,1,0,1,0,0,1,0,1,1,0,0,1,0,0,1,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,
0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1,0,1,0,0,1,0,1,
0,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,
0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,0,0,1,0,1,1,
0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,
0,1,1,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,1,0,1,0,1,1,0,0,0,1,1,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,0,1,1,1,
0,0,0,0,1,1,0,1,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,1,0,0,0,0,0,0,0,
0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0,
0,0,0,1,1,1,0,0,0,0,0,1,0,1,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,0,0,0,0,1,0,0,1,
0,1,1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0,0,1,0,0,0,1,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,
0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,0,1,0,1,
0,1,1,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,
0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,1,1,0,0,1,1,1,1,0,1,0,0,0,1,1,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,1,1,
0,1,0,1,0,1,0,1,0,0,1,1,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,1,1,0,0,1,1,1,1,0,1,1,0,1,0,0,0,0,1,0,0,0,
0,1,0,1,0,1,0,1,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,1,1,0,1,1,1,0,1,0,0,1,
0,1,0,0,0,0,0,0,0,1,0,1,1,0,0,0,1,0,0,0,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,
0,1,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,1,1,1,1,0,1,0,1,0,0,1,
0,0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,0,1,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,1,0,1,1,0,1,1,1,0,0,0,0,1,1,0,1,0,1,
0,1,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,1,0,
0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,1,1,0,1,0,1,1,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,
0,1,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,0,0,0,0,1,
0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,
0,1,0,1,0,0,0,0,1,0,0,0,1,1,0,0,1,0,0,0,1,0,0,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,0,1,0,
0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,
0,1,1,0,1,0,0,0,0,0,0,1,0,0,1,1,1,0,1,1,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,0,0,1,0,1,1,0,1,1,1,0,1,0,0,0,
0,0,0,0,0,0,1,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0,0,0,0,0,0,1,1,0,0,1,1,
0,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,1,0,0,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,
0,1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,1,0,1,1,1,0,1,0,0,0,
0,0,0,1,1,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,
0,1,0,0,0,0,0,0,1,1,0,0,1,1,1,0,1,0,1,1,1,0,1,0,0,0,1,0,0,0,1,1,0,1,1,1,0,1,0,1,0,1,1,0,1,1,1,1,0,0,0,
};
//int best;//从起点到出口的最小步数
//int mins[maxrc+5][maxrc+5];

int mins[maxrc+5][maxrc+5];
char a[row*col+5];
int best;
string ans;
bool judge(int x,int y) {//判断这个点是否越界，是否可以走。
	if(x>0&&x<=row&&y>0&&y<=col&&!maze[x][y])
		return true;//这个点没越界，而且可以走。 
	return false; 
}
void dfs(int x,int y,int pos) {
	if(pos>best)//如果当前路径已经走的步长pos大于之前可行方案最短路径长度 ， 
		return ;//就无需沿着现有的路径继续走下去了，这个剪枝可以加快速度 
	if(x==row&&y==col) {//到达终点 
		string temp;
			for(int i=1;i<pos;i++)
				temp+=a[i];//路径 
		if(pos<best) {//更短的路径记录下来
			ans=temp;
			best=pos; 
		}
		else if(pos==best&&temp<ans)	ans=temp;//在实现路时最短的同时，保证字典序最小。
		return ;
	}
	for(int i=0;i<4;i++) {//四个方向 
		int tox=x+dirx[i];//走向（tox，toy）位置 
		int toy=y+diry[i];
		if(judge(tox,toy)&&pos+1<=mins[tox][toy]) {
			//去往（tox，toy) 是合法的，没有越界，也是标记为0的可以行走的位置
			//并且当前的走法能够使得去到 (tox，toy) 步数更小 
			//就进入此if之内 
			maze[tox][toy]=1;//现在走到（tox，toy）了，走过了，就标记为障碍，那么下次就不能走了 
			mins[tox][toy]=pos+1;//当前的走法，到达（tox,toy）的步数 比以前到过的步数更小
			//就把当前走法到达 （tox,toy）的步数更新 
			a[pos]=dir[i];//记录第pos步的方位 
			dfs(tox,toy,pos+1);//继续以(tox,toy,pos+1)深搜 
			maze[tox][toy]=0;//回溯找短的路，或者是字典序最小的。
			//恢复 （tox，toy）为0，即可行状态，好尝试其他位置在以后会走向它 
		}
	}
}
int main()
{

	memset(mins,1,sizeof(mins));
	best=1<<28;
	maze[1][1]=1;//标记起始点走过来，也就是变为障碍物，不再能走到它 
	dfs(1,1,1);//从起始点（1，1）1步 开始深搜 
	cout<<ans<<endl;
	//cout<<best-1<<endl;
	return 0;
}
季商二三
关注
  • 9
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
C语言/C++课程实践期末大作业黑暗迷宫游戏源码.zip
05-29
C语言课程实践期末大作业黑暗迷宫游戏源码。迷宫游戏（英文：Maze），是一种益智类的探索游戏，由于人类建造迷宫已有5000年的历史。在世界的不同文化发展时期，这些奇特的建筑物始终吸引人们沿着弯弯曲曲、困难重重...
蓝桥杯迷宫
天气
03-16 531
【问题描述】 下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式， 其使用的步数最少，在步数最
DFS练习-迷宫（最短路径）问题详解 一波三折 图片+文字
2301_79599253的博客
01-17 2308
dfs迷宫问题的详细解析，图文并茂，包含洛谷acwing上的两题。
【NOI】C++算法设计入门之深度优先搜索
最新发布
qq_39180358的博客
04-23 2605
深度优先搜索（Depth-First Search, DFS）作为一种基础而强大的图遍历算法，在信息学奥林匹克竞赛（NOI）及广泛的计算机科学应用中占据重要地位。本章节专为C++初学者设计，旨在系统性地介绍深度优先搜索的基本原理、实现方法及其在实际问题中的应用，为后续深入学习更复杂的算法和数据结构打下坚实基础。在学习过程中，我们将以直观易懂的迷宫问题为切入点，引导读者理解DFS如何模拟人类在迷宫中寻找出路的过程，从而掌握其核心思想和操作步骤。
DFS递归之迷宫问题
Tom的博客
04-09 3829
DFS递归之迷宫问题： 1.能否逃出迷宫； 2.逃出迷宫的最短路径； 3.缺口迷宫。
DFS求解迷宫问题
m0_69326632的博客
03-06 2099
DFS求解迷宫问题
蓝桥杯精选赛题算法系列——迷宫——DFS
wzy的博客
03-04 6093
已收录此专栏。 今天我们会全面学习 DFS 的相关知识，包括理论、模板、真题等。 深度优先搜索（DFS, Depth-First Search）和宽度优先搜索（BFS, Breadth-First Search，或称为广度优先搜索）是基本的暴力技术，常用于解决图、树的遍历问题。 我们以老鼠走迷宫为例说明 BFS 和 DFS 的原理吧。迷宫内的路错综复杂，老鼠从入口进去后，怎么才能找到出口？有两种方案： 1.一只老鼠走迷宫。它在每个路口，都选择先走右边（当然，选择先走左边也可以），能走多远就走多远；直到碰壁无
迷宫算法（DFS）
热门推荐
m0_53157173的博客
03-07 1万+
1.如果采用堆栈进行迷宫探测，则称之为深度优先搜索（DFS），它和递归的探测思路是基本一致的，可以看成是递归方式的非递归版本； 2.采用队列进行迷宫探测，则是广度优先搜索（BFS），广度优先搜索法利用队列的特点，一层层向外扩展查找可走的方块，直到找到出口为止，最先找到的这个答案就必然是最短的。 如果打比喻来说，DFS更适合模拟机器人走迷宫的方式，看到一个方向是通的，就一直走下去，遇到死胡同就退回；BFS则好比一个人站在迷宫入口处，拿出一堆小探测器，每个小探测器帮他搜索一个可能的路径去寻找，第一个找到出口的
用dfs解决迷宫问题最简单易懂的方法
2201_75867204的博客
08-21 508
DFS（深度优先搜索）是一种用于图或树的遍历和搜索的算法。它从一个起始节点开始，沿着路径尽可能深地访问节点，直到无法继续前进。然后回溯到上一个节点，选择另一条路径继续访问。这个过程会递归进行，直到所有节点都被访问或搜索条件满足。
C语言/C++课程实践期末大作业迷宫游戏源码.zip
03-04
C语言课程实践期末大作业黑暗迷宫游戏源码。迷宫游戏（英文：Maze），是一种益智类的探索游戏，由于人类建造迷宫已有5000年的历史。在世界的不同文化发展时期，这些奇特的建筑物始终吸引人们沿着弯弯曲曲、困难重重...
迷宫.zip_C/C++_
08-09
一个简单普通的小游戏，对于C语言初学者有一定的帮助
C语言/C++EGE图形库编程推箱子游戏
03-22
游戏中通常有一个迷宫地图，玩家需要控制一个角色在地图上移动，并将箱子推到指定的位置上。推箱子游戏的规则通常是箱子只能被推动而不能被拉动，同时箱子也不能被推到墙壁或其他障碍物上。玩家需要巧妙地利用地图上...
C++小游戏 完整迷宫（DFS生成）
10-28
C++小游戏 迷宫 C++程序设计
DFS/BFS搜索迷宫路径
长期更新Java自学笔记
05-11 1388
文章目录一、DFS搜索迷宫路径二、BFS搜索迷宫路径 一、DFS搜索迷宫路径 DFS依赖栈结构 先把左上角节点入栈，然后依次查看栈顶元素的右、下、左、上四个方向是否可以走，如果能走就把节点入栈，然后再依次查看依次查看栈顶元素的右、下、左、上四个方向；如果四个方向都不能走，就把栈顶元素出栈 最终栈空，则说明退回到了左上角的节点；右下角的节点入栈，则表示找到了出口 需要注意的是，每入栈一个节点： 需要将当前节点到入栈节点的方向置为NO，保证如果走进死胡同回退后，不会再次往这个错误的方向走 需要将刚入栈节
蓝桥杯2022年第十三届省赛真题-回忆迷宫
Gojavaee的博客
11-16 2645
蓝桥杯2022年第十三届省赛真题-回忆迷宫 100%过测试 个人解法
蓝桥杯——迷宫
weixin_45688536的博客
01-23 1793
题目来源：2019，省赛 知识点：BFS，C++文件读写 题目描述 本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。 下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按 DRRURRDDDR的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表
迷宫（蓝桥杯c/c++组）
weixin_47511190的博客
02-20 738
下图给出了一个迷宫的平面图，其中标记为1 的为障碍，标记为0 的为可 以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共10 步。其中D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行50 列），请找出一种通过迷宫的方式， 其使用的步数最少，在步数最少的前提下，请找出字典序
小白思路：DFS走迷宫
qq_56089122的博客
04-02 368
小白崩溃9999次写出DFS走迷宫问题，参考了无数大佬的写法，受到了大佬的修改帮助，心累、迷茫
【迷宫问题：DFS（栈）】
qq_73121793的博客
11-01 843
同时可知DFS的实现类似于递归，而栈可以进行非递归的转换.这次专题主要是对栈的应用进行分析。所以首先我先简要描述一下DFS方便大家对下文的例子有更清晰的认识。当我们开始走迷宫的时候，每次都往同一个方向行走，直到遇到走不通的，就回退一格往另一个方向试探。空间复杂度：DFS使用的空间往往比BFS大。DFS求解迷宫问题的关键是利用回溯来找到最短路径，在代码实现上即是递归。时间复杂度：大多数情况下，两者的是时间复杂度差不多，需要搜索整个空间。针对迷宫问题，我们可以根据题目的要求来选择BFS或者DFS来解决。
迷宫出口c++dfs
01-17
以下是使用C++的DFS算法来找到迷宫的出口的示例代码： ```cpp #include #include using namespace std; // 定义迷宫的大小 const int N = 5; const int M = 5; // 定义迷宫的起点和终点 const int start_x = 0...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值