＜迷宫问题及最短路径问题（使用DFS与回溯法求解）＞——《算法》

已于 2022-09-02 22:41:49 修改
阅读量7.6k 收藏 205
点赞数 51
分类专栏： 《算法》 《项目》 文章标签： 算法 深度优先 c语言 逻辑回归 迭代加深
于 2022-09-02 22:37:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57859086/article/details/126665880
版权

目录

一、迷宫问题： 

1.迷宫问题链接：（牛客网）迷宫问题

1.1 问题描述：

1.2 问题分析：

1.3 功能函数实现：

1.4 栈的模拟实现：

1.5测试用例及演示：

1.6 完整源码：

二、迷宫最短路径问题： 

1. 迷宫最短路径问题链接：（牛客网）地下迷宫

1.1 问题描述：

1.2 问题分析：

1.3 功能函数实现：

1.4 栈的模拟实现：

1.5测试用例及演示：

1.6 完整源码：

三、总结：

后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                       ——By 作者：新晓·故知

一、迷宫问题： 

1.迷宫问题链接：（牛客网）迷宫问题

1.1 问题描述：

 

1.2 问题分析：

以上迷宫OJ题曾经是百度某一年的其中一个笔试题，迷宫问题本质就是一个图的遍历问题，从起点开始不断四个方向探索，直到走到出口，走的过程中我们借助栈记录走过路径的坐标，栈记录坐标有两方面的作用，一方面是记录走过的路径，一方面方便走到死路时进行回溯找其他的通路。这里涉及到四路递归。（上、下、左、右四个方向的递归）
我们在这里借助深度优先遍历（DFS）与回溯法进行分析、求解。
根据题目要求，分析后确定实现方式，模块化实现各部分功能，然后依据“高内聚，低耦合”的方式进行组织！

 

1.3 功能函数实现：

（1）首先定义迷宫坐标位置的结构体：

 

（2）写出调用逻辑（主函数）：

 

 

（3）判断路径坐标进行可以进行遍历：

 

 

（4）判断该坐标是否为有效可遍历的坐标

 （5） 输出栈里面的坐标路径：

由于栈的“FIFO”性质，又题目要求按照从最开始打印，则需要进行顺序调整。

 （6）打印遍历的路径坐标：

 1.4 栈的模拟实现：

（这里借助栈的“FIFO”性质，借用栈存储递归遍历的数据存储，不符合的坐标就出栈，再进行回溯遍历）

 1.5测试用例及演示：

示例1：

5 5
0 1 0 0 0
0 1 1 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

示例2：

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 1
0 1 1 1 0
0 0 0 0 0

 测试打印：

 1.6 完整源码：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<string.h>
//定义位置结构体
typedef struct Postion
{
	int row;
	int col;
}PT;
/
//栈的实现
typedef PT STDataType;

typedef struct Stack
{
	STDataType* a;   //通过数组实现栈的结构
	int top;
	int capacity;
}ST;
//初始化
void StackInit(ST* ps);
//释放内存、销毁空间
void StackDestory(ST* ps);
// 入栈
void StackPush(ST* ps, STDataType x);
// 出栈
void StackPop(ST* ps);
//取栈顶数据
STDataType StackTop(ST* ps);
//栈的大小
int StackSize(ST* ps);
//判空
bool StackEmpty(ST* ps);
//初始化
void StackInit(ST* ps)
{
	assert(ps);

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail!\n");
		exit(-1);
	}

	ps->capacity = 4;
	ps->top = 0; //这使得top最终指向的是栈顶的后一个位置。若top=-1,则最终指向的是栈顶。
}
//释放内存、销毁空间
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
// 入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	// 满了->增容
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp == NULL)
		{
			printf("realloc fail!\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}

	ps->a[ps->top] = x;
	ps->top++;
}

// 出栈
void StackPop(ST* ps)
{
	assert(ps);
	// 栈空了，再调用Pop，就会直接中止程序报错
	assert(ps->top > 0);

	//ps->a[ps->top - 1] = 0; //置为0只考虑了int型等，若为char、double等就不适用了。
	ps->top--;
}
//取栈顶数据
STDataType StackTop(ST* ps)
{
	assert(ps);
	// 栈空了，再调用Top，就会直接中止程序报错
	assert(ps->top > 0);

	return ps->a[ps->top - 1];
}
//求栈大小
int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}
//判空
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

//maze实现
ST path;  //定义全局变量
//打印
void PrintMaze(int** maze, int N, int M)
{
	for (int i = 0; i < N; ++i)
	{
		for (int j = 0; j < M; ++j)
		{
			printf("%d ", maze[i][j]);
		}
		printf("\n");
	}
	printf("\n");
}

// 输出栈里面的坐标路径
//要求从最开始的坐标先输出，而栈是后进先出，需要调整输出
void PirntPath(ST* ps)
{
	// path数据倒到rPath
	ST rPath;
	StackInit(&rPath);
	while (!StackEmpty(&path))
	{
		StackPush(&rPath, StackTop(&path));
		StackPop(&path);
	}

	while (!StackEmpty(&rPath))
	{
		PT top = StackTop(&rPath);
		printf("(%d,%d)\n", top.row, top.col);
		StackPop(&rPath);
	}

	StackDestory(&rPath);
}
//判断该坐标是否为有效可遍历的坐标
bool IsPass(int** maze, int N, int M, PT pos)
{
	if (pos.row >= 0 && pos.row < N
		&& pos.col >= 0 && pos.col < M
		&& maze[pos.row][pos.col] == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//判断路径坐标进行可以进行遍历
bool GetMazePath(int** maze, int N, int M, PT cur)
{
	StackPush(&path, cur);

	// 如果走到出口
	if (cur.row == N - 1 && cur.col == M - 1)
		return true;

	// 探测cur位置得上、下、左、右四个方向
	PT next;
	maze[cur.row][cur.col] = 2;  //已经遍历过的（包括当前）位置，标记为2

	//向上遍历
	next = cur;
	next.row -= 1;
	if (IsPass(maze, N, M, next))
	{
		if (GetMazePath(maze, N, M, next))
			return true;
	}

	//向下遍历 
	next = cur;
	next.row += 1;
	if (IsPass(maze, N, M, next))
	{
		if (GetMazePath(maze, N, M, next))
			return true;
	}

	//向左遍历
	next = cur;
	next.col -= 1;
	if (IsPass(maze, N, M, next))
	{
		if (GetMazePath(maze, N, M, next))
			return true;
	}

	//向右遍历
	next = cur;
	next.col += 1;
	if (IsPass(maze, N, M, next))
	{
		if (GetMazePath(maze, N, M, next))
			return true;
	}

	StackPop(&path);  //不通，这个坐标不能使用，就出栈

	return false; //四个方向都不通，就返回false,递归会回溯，探索其他通路
}

int main()
{
	int N = 0, M = 0;
	while (scanf("%d%d", &N, &M) != EOF)
	{
		// int a[n][m]; // vs2013 不支持
		// 动态开辟二维数组
		int** maze = (int**)malloc(sizeof(int*) * N);
		for (int i = 0; i < N; ++i)
		{
			maze[i] = (int*)malloc(sizeof(int) * M);
		}

		// 二维数组的输入
		for (int i = 0; i < N; ++i)
		{
			for (int j = 0; j < M; ++j)
			{
				scanf("%d", &maze[i][j]);
			}
		}

		StackInit(&path);
		// PrintMaze(maze, N, M);
		PT entry = { 0, 0 };       //入口
		if (GetMazePath(maze, N, M, entry))
		{
			//printf("找到通路\n");
			PirntPath(&path);
		}
		else
		{
			printf("没有找到通路\n");
		}

		StackDestory(&path);

		for (int i = 0; i < N; ++i)
		{
			free(maze[i]);
		}
		free(maze);
		maze = NULL;
	}

	return 0;
}

二、迷宫最短路径问题： 

1. 迷宫最短路径问题链接：（牛客网）地下迷宫

1.1 问题描述：

 1.2 问题分析：

本题在曾经是美团某一年的笔试题，本题在上一个题的基础上计入了体力值的概念，但是本题还有一个隐藏条件，就是要找出迷宫的最短路径，如下图的两个测试用例，需要找出最短路径，才能通过全部测试用例。本题依旧借助深度优先遍历（DFS）和回溯法解决。这里涉及到四路递归，（上、下、左、右四个方向的递归）。
分析问题，确定求解方法：
根据题目可知：相比于“迷宫问题”，这题在上题的基础上进行了“变种”，即引入了“体力值”和最短路径，而且路径也从“只有一条”变为了“多条路径”，因此，要进行分析，将各个功能模块封装后，依据“高内聚，低耦合”的设计原则进行组织。

1.3 功能函数实现：

（1）定义迷宫坐标的结构体：

（2）写出调用逻辑（主函数）：

（3）获取有效遍历的有效路径坐标： 

（4）解决浅拷贝的两次释放空间会报错问题：

 

（5）判断该坐标是否为有效可遍历的坐标：

 

（6）输出栈里存储的路径坐标：

由于栈的“FIFO”性质，又题目要求按照从最开始打印，则需要进行顺序调整。

 

（7）打印遍历的有效路径坐标：

 

 1.4 栈的模拟实现：

（这里借助栈的“FIFO”性质，借用栈存储递归遍历的数据存储，不符合的坐标就出栈，再进行回溯遍历）

 1.5测试用例及演示：

示例1：

1.6 完整源码：

//2.迷宫最短路径问题
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<string.h>
//定义迷宫坐标的结构体
typedef struct Postion
{
	int row;
	int col;
}PT;
/
//栈的实现
typedef PT STDataType;

typedef struct Stack
{
	STDataType* a;   //通过数组实现栈的结构
	int top;
	int capacity;
}ST;
//初始化
void StackInit(ST* ps);
//释放内存、销毁空间
void StackDestory(ST* ps);
// 入栈
void StackPush(ST* ps, STDataType x);
// 出栈
void StackPop(ST* ps);
//取栈顶数据
STDataType StackTop(ST* ps);
//栈的大小
int StackSize(ST* ps);
//判空
bool StackEmpty(ST* ps);
//初始化
void StackInit(ST* ps)
{
	assert(ps);

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail!\n");
		exit(-1);
	}

	ps->capacity = 4;
	ps->top = 0; //这使得top最终指向的是栈顶的后一个位置。若top=-1,则最终指向的是栈顶。
}
//释放内存、销毁空间
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
// 入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	// 满了->增容
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp == NULL)
		{
			printf("realloc fail!\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}

	ps->a[ps->top] = x;
	ps->top++;
}

// 出栈
void StackPop(ST* ps)
{
	assert(ps);
	// 栈空了，再调用Pop，就会直接中止程序报错
	assert(ps->top > 0);

	//ps->a[ps->top - 1] = 0; //置为0只考虑了int型等，若为char、double等就不适用了。
	ps->top--;
}
//取栈顶数据
STDataType StackTop(ST* ps)
{
	assert(ps);
	// 栈空了，再调用Top，就会直接中止程序报错
	assert(ps->top > 0);

	return ps->a[ps->top - 1];
}
//求栈大小
int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}
//判空
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

//maze实现
ST path;  //定义全局变量
ST minpath;  //定义最短路径
//打印
void PrintMaze(int** maze, int N, int M)
{
	for (int i = 0; i < N; ++i)
	{
		for (int j = 0; j < M; ++j)
		{
			printf("%d ", maze[i][j]);
		}
		printf("\n");
	}
	printf("\n");
}

// 输出栈里面的坐标路径
//要求从最开始的坐标先输出，而栈是后进先出，需要调整输出
void PirntPath(ST* ps)
{
	// path数据倒到rPath
	ST rPath;
	StackInit(&rPath);
	while (!StackEmpty(ps))
	{
		StackPush(&rPath, StackTop(ps));
		StackPop(ps);
	}
	//输出分为两种，仅因为题目要求，这里没有什么特定含义
	while (StackSize(&rPath)>1)
	{
		PT top = StackTop(&rPath);
		printf("[%d,%d],", top.row, top.col);
		StackPop(&rPath);
	}
	PT top = StackTop(&rPath);
	printf("[%d,%d]", top.row, top.col);
	StackPop(&rPath);
	StackDestory(&rPath);
}
//判断该坐标是否为有效可遍历的坐标
bool IsPass(int** maze, int N, int M, PT pos)
{
	if (pos.row >= 0 && pos.row < N
		&& pos.col >= 0 && pos.col < M
		&& maze[pos.row][pos.col] == 1)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//解决浅拷贝的两次释放空间报错问题
void StackCopy(ST* ppath, ST* pcopy)
{
	pcopy->a = (STDataType*)malloc(sizeof(STDataType*) * ppath->capacity);
	memcpy(pcopy->a, ppath->a, sizeof(STDataType) * ppath->top);
	pcopy->top = ppath->top;
	pcopy->capacity = ppath->capacity;
}
//获取可有效遍历的路径坐标
void GetMazePath(int** maze, int N, int M, PT cur,int P)
{
	StackPush(&path, cur);
	// 如果走到出口
	if (cur.row == 0 && cur.col == M - 1)
	{
		// 找到了更短的路径，更新minpath；  //P是题目要求的体力值，要求在有效范围内
		if (P >= 0 && StackEmpty(&minpath) 
			|| StackSize(&path) < StackSize(&minpath))
		{
			StackDestory(&minpath);
			StackCopy(&path, &minpath);
		}
	}

	// 探测cur位置得上下左右四个方向
	PT next;
	maze[cur.row][cur.col] = 2;  //已经走过得，标记为2

	//向上遍历
	next = cur;
	next.row -= 1;
	if (IsPass(maze, N, M, next))
	{
		 (GetMazePath(maze, N, M, next, P - 3));
			
	}

	//向下遍历
	next = cur;
	next.row += 1;
	if (IsPass(maze, N, M, next))
	{
		 (GetMazePath(maze, N, M, next, P));
			
	}

	//向左遍历
	next = cur;
	next.col -= 1;
	if (IsPass(maze, N, M, next))
	{
		(GetMazePath(maze, N, M, next, P - 1));
			
	}

	//向右遍历
	next = cur;
	next.col += 1;
	if (IsPass(maze, N, M, next))
	{
		(GetMazePath(maze, N, M, next, P - 1));
			
	}

	//递归会回溯，探索其他通路
	//需要恢复
	maze[cur.row][cur.col] = 1;
	StackPop(&path);
}

int main()
{
	int N = 0, M = 0, P = 0;
	while (scanf("%d%d%d", &N, &M,&P) != EOF)
	{
		//创建迷宫，获取迷宫地图
		// int a[n][m]; // vs2013 不支持
		// 动态开辟二维数组
		int** maze = (int**)malloc(sizeof(int*) * N);
		for (int i = 0; i < N; ++i)
		{
			maze[i] = (int*)malloc(sizeof(int) * M);
		}

		// 二维数组的输入
		for (int i = 0; i < N; ++i)
		{
			for (int j = 0; j < M; ++j)
			{
				scanf("%d", &maze[i][j]);
			}
		}

		StackInit(&path);
		StackInit(&minpath);

		// PrintMaze(maze, N, M);
		PT entry = { 0, 0 };        // 默认[0,0]是入口，[N-1][M-1]是出口
		GetMazePath(maze, N, M, entry, P);  //获取遍历到的有效路径
		if (!StackEmpty(&minpath))
		{
			PirntPath(&minpath);
		}
		else
		{
			printf("Can not escape!\n");
		}
		
		StackDestory(&path);
		StackDestory(&minpath);
		//销毁迷宫
		for (int i = 0; i < N; ++i)
		{
			free(maze[i]);
		}
		free(maze);
		maze = NULL;
	}

	return 0;
}

三、总结：

 通过迷宫问题及最短路径问题，借助深度优先遍历（DFS）和回溯法求解，这里涉及到四路递归（上、下、左、右四个方向的递归），然而解决方法是一方面，解决工具也是另一方面。这里采用C语言实现求解，借助数据结构中栈的性质，实现深度遍历过程中的数据存储，然后回溯。使用C语言，涉及到二维数组的操作，这里使用了二级指针和指针数组，而在最短路径的比较更新中，涉及到了深浅拷贝问题，这里也需要注意，否则程序将会崩溃！

解决这些题的方法还有很多，解决的工具也有很多，这里不再一一列举！

最后，向前人的智慧结晶致敬！学者，亦有敬畏之心！亦当珍惜学习的机会与时光！

后记：
●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                       ——By 作者：新晓·故知

新晓·故知
关注
  • 51
    点赞
  • 踩
  • 205
    收藏
    觉得还不错? 一键收藏
  • 35
    评论
专栏目录
最经典的走迷宫最短路径算法（深度优先搜索BFS的典型实例）
guo97的博客
12-11 6542
迷宫的最短路径 问题描述 给定一个大小为N×M的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四个的通道移动。请求出从起点到终点所需的最小步数。请注意，本题假定从起点一定可以移动到终点。（N,M≤100） （’#’, ‘.’ , ‘S’, 'G’分别表示墙壁、通道、起点和终点） 样例输入： 10 10 #S######.# ......#..# .#.##.##.# .#........ ##.##.#### ....#....# .#######.# ....#..... .####.###. .
【算法】（BFS/DFS）迷宫路径问题（C语言）
weixin_51450101的博客
05-01 7308
题目：现有一迷宫如下图所示，蓝色部分为墙壁，白色部分为通路，入口在左上角（1,1）处，出口在右下角（8,8）处，试找出一条路径以通过该迷宫（路径不能重叠）。
最全迷宫最短路径问题（BFS、DFS）
隔壁老陈的博客
06-02 6805
给你一个m*n的迷宫，迷宫中有障碍物（1表示障碍物），你可以上下左右移动，但不能走走过的迷宫，给出指定的起点（x,y）和指定的终点（x_l,y_l）,求最短路径长度是多少，或者打印其中一个最短路径，最段路径为： 1 0，2 0，3 0，4 0，4 1，4 2，4 3，4 4。2.使用BFS层序遍历，一层一层往外扩张，使用结构体简化操作。思路：1.使用DFS深度优先遍历来到达终点的所有路径，选择最短的路径。输出：最短路径长度：8。
迷宫最短路径（迪杰斯特拉算法）
wyydsohoo的博客
12-11 559
【代码】迷宫最短路径（迪杰斯特拉算法）
迷宫问题（最短路径问题）
2301_80344616的博客
05-08 1226
我们接着之前讲过的初阶迷宫问题，这次我们来说说高阶迷宫问题，高阶的迷宫问题难在有多条路径去选择，所以我们现在需要做的不是找到路径而是找到最短的路径地下迷宫_牛客题霸_牛客网 (nowcoder.com)小青蛙有一天不小心落入了一个地下迷宫,小青蛙希望用自己仅剩的体力值P跳出这个地下迷宫。为了让问题简单,假设这是一个n*m的格子迷宫,迷宫每个位置为0或者1,0代表这个位置有障碍物,小青蛙达到不了这个位置;1代表小青蛙可以达到的位置。
小白学BFS：迷宫最短路径
qq_56089122的博客
05-19 1169
小白慢悠悠写一天的BFS寻找最短路径条数的问题
DFS递归之迷宫问题
Tom的博客
04-09 3890
DFS递归之迷宫问题： 1.能否逃出迷宫； 2.逃出迷宫的最短路径； 3.缺口迷宫。
广度优先搜索(BFS)算法解决迷宫最短路径问题
CDSNT的博客
08-15 2137
广度优先搜索算法实践：迷宫的最短路径问题
迷宫最短路径问题 数据结构
07-21
在IT领域，迷宫最短路径问题是一个经典且重要的算法问题，它涉及到数据结构和算法的设计与应用。本文将深入探讨这一主题，并结合链接提供的博客文章进行详细解释。 首先，迷宫最短路径问题通常使用两种主要的数据...
C语言 数据结构中求解迷宫问题实现方法
08-30
首先，迷宫问题的基本思想是穷举法，也就是广度优先搜索（BFS）或深度优先搜索（DFS）。在本例中，采用了深度优先搜索的方法，通过栈来保存当前位置和方向信息。迷宫可以用二维数组表示，其中0表示通道，1表示墙壁。...
c语言支持自己创建迷宫，并求解最短路径.zip
09-09
在C语言中创建一个迷宫并寻找最短路径是一个经典的计算机科学问题，涉及到算法设计、数据结构以及递归等编程技巧。在这个项目中，我们可能会遇到以下知识点： 1. **迷宫表示法**：通常，迷宫可以用二维数组或者矩阵...
迷宫最短路径算法（dfs）
02-26
这是一个求迷宫最短路径的算法，用的是dfs的思想～～～～～～～～～～～～～
迷宫 最短路径及所有路径的问题
12-06
迷宫问题，完成的是一个现实中的迷宫游戏求最短路径及所有路径的问题，本程序相对于航班信息查询系统比较简单，主要包含使用系统迷宫（可以选择迷宫的入口和出口，并输出所有路径和最短路径），使用新建迷宫（可以自己设计迷宫的大小，及所有通路，可以选择迷宫的入口和出口，并输出所有路径和最短路径），用到了栈的使用，如栈的创建、入栈、出栈等函数功能。
c语言支持自己创建迷宫，并求解最短路径.rar
最新发布
06-18
在C语言中，创建迷宫并寻找最短路径是一个经典的算法问题，涉及到数据结构和算法设计。本项目可能包含一个C程序，它允许用户自定义迷宫布局，并使用某种算法来寻找从起点到终点的最短路径。下面将详细介绍这个过程中...
18720 迷宫问题 （最短路径）
weixin_63551790的博客
04-15 1251
Description 迷宫是一个n*m的矩阵，玩家需要迷宫入口（坐标1,1）出发，寻找路径走到出口（n,m）。 请判断玩家能否从迷宫中走出，如果能走出迷宫输出，输出最短的路径长度，否则输出-1。 题目图像链接 ​​​​​​​http://172.26.14.60:8000/uoj/pic/18720_1585577001195_77685.jpg 输入格式 第一行两个整数n和m，代表n行m列。(1<=n,m<=10) 下面n行每行m个字符,0代表可以通行，1代表不可以通行。
回溯法找迷宫最短路径
再不努力我们就老了
09-21 8125
有一个二维数组，0表示路，-1表示墙，求其中任意两点的最短路径 我们先看，怎么求一条路径：求两点路径是一个数据结构上的典型的迷宫问题，解决办法如下： 从一点开始出发，向四个方向查找（上，右，下，左），每走一步，把走过的点的值+1，防止重复行走，并把走过的点压入堆栈(表示路径)，如果遇到墙、或者已走过的点则不能前进，如果前方已经无路可走，则返回，路径退栈，这样递归调用，直到找到终点为止。
搜索算法 18720 迷宫问题2（最短路径）（BFS）
zqihm的博客
04-01 588
搜索算法 18720 迷宫问题2（最短路径）（BFS）
基于栈的数据结构实现走迷宫最短路径（java）
ran_kuroba的博客
03-27 2294
基于栈的数据结构实现走迷宫的最短路径 语言：JAVA 开发平台：Eclipse 目的 一个迷宫如图所示，它有一个入口和出口，其中白色单元表示通路，黑色单元表示路不通。寻找一条从入口到出口的路径，每步只能从一个白色单元走到相邻的白色单元，直至出口。使用栈实现走迷宫的功能，演示走迷宫的过程。 数据结构设计 用ArrayList 作为栈的数据结。ArrayList是java中Collection集合中...
迷宫问题 —— 最短路径条数
Scar_Halo
11-08 1350
&nbsp;&nbsp;&nbsp;&nbsp;求迷宫的最短路径条数有多少条，一般方法会超时，这里记录一下模板 &nbsp;&nbsp;&nbsp;&nbsp;简要思路：用ansansans记录到每个点的条数，当新到达的点的新距离小于就旧的距离时，更新新点的ansansans；若新距离等于旧距离，也就是可能是最短路径的时候，就ans新+=ans旧ans_{新} += ans_{旧}ans新​+=a...
分治算法应用：回文日期与最短路径解析
代码定义了`dx`和`dy`数组表示四个可能的移动方向，并通过深度优先搜索（DFS）算法来查找从起点到终点的最短路径。`search`函数递归地探索所有可能的路径，更新最小时间和到达状态。使用`vi`二维数组记录已访问的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值