【回溯 深度优先搜索】980. 不同路径 III

最新推荐文章于 2024-08-03 12:30:52 发布
最新推荐文章于 2024-08-03 12:30:52 发布
阅读量946 收藏 24
点赞数 16
分类专栏： 数据结构与算法 文章标签： 深度优先 算法 c++ 力扣 回溯 路径 障碍
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_zhidan/article/details/137916134
版权
本文介绍了在给定二维网格中，从一个特定的起始格到唯一结束格，避开障碍物并确保每个空格仅被走过一次的路径数计算问题，采用深度优先搜索策略和回溯法进行求解，展示了C++代码实现。
摘要由CSDN通过智能技术生成

本文涉及知识点

回溯 深度优先搜索

LeetCode980. 不同路径 III

在二维网格 grid 上，有 4 种类型的方格：
1 表示起始方格。且只有一个起始方格。
2 表示结束方格，且只有一个结束方格。
0 表示我们可以走过的空方格。
-1 表示我们无法跨越的障碍。
返回在四个方向（上、下、左、右）上行走时，从起始方格到结束方格的不同路径的数目。
每一个无障碍方格都要通过一次，但是一条路径中不能重复通过同一个方格。
示例 1：
输入：[[1,0,0,0],[0,0,0,0],[0,0,2,-1]]
输出：2
解释：我们有以下两条路径：

  1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2)
  2. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2)
    示例 2：
    输入：[[1,0,0,0],[0,0,0,0],[0,0,0,2]]
    输出：4
    解释：我们有以下四条路径：
  3. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2),(2,3)
  4. (0,0),(0,1),(1,1),(1,0),(2,0),(2,1),(2,2),(1,2),(0,2),(0,3),(1,3),(2,3)
  5. (0,0),(1,0),(2,0),(2,1),(2,2),(1,2),(1,1),(0,1),(0,2),(0,3),(1,3),(2,3)
  6. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2),(2,3)
    示例 3：
    输入：[[0,1],[2,0]]
    输出：0
    解释：
    没有一条路能完全穿过每一个空的方格一次。
    请注意，起始和结束方格可以位于网格中的任意位置。
    提示：
    1 <= grid.length * grid[0].length <= 20

回溯

m_iNeed 记录 起始格和可以通过的格子数量。
m_visit 记录那些单元格已经访问。
两轮循环：第一轮计算m_iNeed 。第二轮寻找起始格。
时间复杂度： O(rc*4rc) 由于存在大量不存在的路径，所以用时非常少。

每次回溯（深度优先）包括如下工作：
判断r,c是否合法。
r,c是否能通过。
如果是终点格，判断是否通过所有单格。并返回。
如果当前路径已经访问当前格，返回。
为当前格子设置已访问标记。
has++
DFS当前格的相邻格
has–
取消当前格已访问标记

代码

核心代码

class Solution {
public:
	int uniquePathsIII(vector<vector<int>>& grid) {
		m_visit.assign(grid.size(), vector<bool>(grid[0].size()));
		for (int r = 0; r < grid.size(); r++) {
			for (int c = 0; c < grid[0].size(); c++) {
				if (0 == grid[r][c]) {
					m_iNeed++;
				}
			}
		}
		for (int r = 0; r < grid.size(); r++) {
			for (int c = 0; c < grid[0].size(); c++) {
				if (1 == grid[r][c]) {
					DFS(grid, r, c, 0);
				}
			}
		}
		return m_iRet;
	}
	void DFS(const vector<vector<int>>& grid, int r, int c,int iHas) {
		if ((r < 0) || (r >= grid.size())) { return; }
		if ((c < 0) || (c >= grid[0].size())) { return; }
		if (-1 == grid[r][c]) { return; }
		if (2 == grid[r][c]) {
			if (m_iNeed == iHas) {
				m_iRet++;
			}
			return;
		}
		if (m_visit[r][c]) { return; }
		m_visit[r][c] = true;
		iHas++;
		for (int i = 0; i < sizeof(m_move) / sizeof(m_move[0]); i++) {
			DFS(grid, r + m_move[i][0], c + m_move[i][1],iHas);
		}
		iHas--;
		m_visit[r][c] = false;
	}
	vector<vector<bool>> m_visit;
	int m_iRet = 0;
	int m_move[4][2] = { {0,1},{0,-1},{1,0},{-1,0} };
	int m_iNeed = 1;
};

测试用例

template<class T>
void Assert(const T& t1, const T& t2)
{

    assert(t1 == t2);
}

template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
    if (v1.size() != v2.size())
    {
        assert(false);
        return;
    }
    for (int i = 0; i < v1.size(); i++)
    {
        Assert(v1[i], v2[i]);
    }

}

int main()
{
	vector<vector<int>> grid;
	{
		Solution sln;
		grid = { {0,1},{2,0} };
		auto res = sln.uniquePathsIII(grid);
		Assert(0, res);
	}
	{
		Solution sln;
		grid = { {1,0,0,0},{0,0,0,0},{0,0,2,-1} };
		auto res = sln.uniquePathsIII(grid);
		Assert(2, res);
	}
	{
		Solution sln;
		grid = { {1,0,0,0},{0,0,0,0},{0,0,0,2} };
		auto res = sln.uniquePathsIII(grid);
		Assert(4, res);
	}
	
}

2023年7月

class Solution {
public:
	int uniquePathsIII(vector<vector<int>>& grid) {
		m_r = grid.size();
		m_c = grid[0].size();
		
		int indexBegin;
		int index = 0;
		for (int r = 0; r < m_r; r++)
		{
			for (int c = 0; c < m_c; c++)
			{
				if (-1 == grid[r][c])
				{					
					continue;
				}
				if (1 == grid[r][c])
				{
					indexBegin = index;
				}
				else if (2 == grid[r][c])
				{
					m_indexEnd = index;
				}
				else
				{
					m_i02Num++;
				}
				grid[r][c] = index++;
			}
		}
		m_vNeiBo.resize(index);
		for (int r = 0; r < m_r; r++)
		{
			for (int c = 0; c < m_c; c++)
			{
				if (-1 == grid[r][c])
				{
					continue;
				}
				Add(m_vNeiBo[grid[r][c]], r + 1, c, grid);
				Add(m_vNeiBo[grid[r][c]], r - 1, c, grid);
				Add(m_vNeiBo[grid[r][c]], r , c + 1, grid);
				Add(m_vNeiBo[grid[r][c]], r , c - 1, grid);
			}
		}
		bool aHas[20] = { false };
		dfs(indexBegin, -1, 0, aHas);
		return m_iRet;
	}
	void dfs(int cur, int parent, int iNodeNum, bool* aHas)
	{
		if (aHas[cur])
		{
			return;//已经访问
		}
		if (cur == m_indexEnd)
		{
			if (m_i02Num == iNodeNum)
			{
				m_iRet++;
			}
			return;
		}
		aHas[cur] = true;
		for (const auto& next : m_vNeiBo[cur])
		{
			if (next == parent)
			{
				continue;
			}	
			dfs(next, cur, iNodeNum + 1, aHas);			
		}
		aHas[cur] = false;
	}
	void Add(vector<int>& vNeiBo, int r, int c,const vector<vector<int>>& grid)
	{
		if ((r < 0) || (r >= m_r))
		{
			return;
		}
		if ((c < 0) || (c >= m_c))
		{
			return;
		}
		if (-1 != grid[r][c])
		{
			vNeiBo.emplace_back(grid[r][c]);
		}
	}
	int m_r,m_c;
	int m_indexEnd;
	vector<vector<int>> m_vNeiBo;
	int m_i02Num = 1;
	int m_iRet = 0;
};

2023年4月

class Solution {
public:
	int uniquePathsIII(vector<vector<int>>& grid) {
		m_r = grid.size();
		m_c = grid[0].size();
		int iNeedVisit = 0;
		int iStartR = 0,iStartC=0, iEndMask = 0;
		for (int r = 0; r < m_r; r++)
		{
			for (int c = 0; c < m_c; c++)
			{
				const int iRowColMask = m_c*r + c;
				if (-1 != grid[r][c])
				{
					iNeedVisit |= (1 << iRowColMask);
				}
				if (1 == grid[r][c])
				{
					iStartR = r;
					iStartC = c;
				}
				else if (2 == grid[r][c])
				{
					iEndMask = iRowColMask;
				}
			}
		}

		std::queue<int> que;
		std::unordered_set<int> setHasDo;
		auto Add = [&](const int r, const int c, int iVisite)
		{
			if ((r < 0) || (r >= m_r))
			{
				return;
			}
			if ((c < 0) || (c >= m_c))
			{
				return;
			}
			if (-1 == grid[r][c])
			{
				return;
			}
			const int iRowColMask = m_c*r + c;
			if (iVisite &(1 << iRowColMask))
			{
				return;//已经访问
			}
			const int iMask = (iVisite | (1 << iRowColMask)) * 100 + iRowColMask;
			if (setHasDo.count(iMask))
			{
			//	return;
			}
			setHasDo.emplace(iMask);
			que.emplace(iMask);
		};
		Add(iStartR, iStartC, 0);
		int iRet = 0;
		while (que.size())
		{
			const int iRowColMask = que.front() % 100;
			const int iVisite = que.front() / 100;
			que.pop();
			if ((iRowColMask == iEndMask) && (iVisite == iNeedVisit))
			{
				iRet++;
				continue;
			}
			const int r = iRowColMask / m_c;
			const int c = iRowColMask % m_c;
			Add(r + 1, c, iVisite);
			Add(r - 1, c, iVisite);
			Add(r, c + 1, iVisite);
			Add(r, c - 1, iVisite);
		}
		return iRet;
	}
	int m_r, m_c;
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业
。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。

闻缺陷则喜何志丹
关注
  • 16
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
深度优先搜索算法探索路径与解决难题
一键难忘的博客
05-22 1083
深度优先搜索算法作为一种经典的图搜索算法，在解决各种实际问题时发挥着重要作用。通过理解其原理、掌握其实现方法，并结合具体问题的特点进行优化，我们可以更好地利用深度优先搜索算法解决实际问题。在未来的学习和工作中，我们可以继续探索深度优先搜索算法以及其他相关算法，不断提升自己的算法设计和问题解决能力。
python实现全排列代码(回溯、深度优先搜索)
09-17
在本文中，我们将深入探讨如何使用Python编程语言实现全排列算法，主要涉及两种方法：回溯和深度优先搜索（DFS）。全排列是指从n个不同的元素中取出m个元素，并按照特定顺序排列的所有可能性。当m等于n时，称为...
【算法基础实验】图论-深度优先搜索和深度优先路径
Greyplayground
04-26 1062
深度优先搜索是一个递归的过程，它尝试深入到每一个分支直到不能再深入为止，然后通过回溯继续探索其他分支。它的核心在于尝试所有可能的路径直到找到解决方案或覆盖所有的节点。DFS 的记忆点在于它的递归性质和回溯机制，这使得它非常适合处理需要探索所有可能性的问题。
回溯法与深度优先搜索的关系
qq_44471588的博客
03-04 1252
回溯简介 回溯是搜索算法中的一种控制策略，它的基本思想是：为了求得问题的解，先选择一种可能的情况向前探索，如果在探索过程中发现原来的选择是错误的，就退回一步重新选择，如此反复进行，直到穷举出所有情况，可以证明该问题无解。 不同点 （1）数据结构 回溯算法的解空间若是有限的，则可将解空间映射成树结构。 深度优先搜索算法跟图结构紧密相关，任何涉及深度度优先搜索的问题，都伴随着图。 因为实施算法的数据结构都是图（树也是一种特殊的图），所以，两者存在一些共性，回溯算法在搜索时使用深度优先算法。 回溯算法 = 树的深
深度优先搜索解决迷宫最短路径问题
Leaderxin的博客
11-20 5570
在之前的文章里我们介绍了深度优先遍历的思想，并且以数组全排列为例子实现了算法编码，本篇我们通过深度优先搜索解决迷宫路径问题。用程序实现查询所有从迷宫入口到终点的路径，需要越过障碍物，并且不能超出迷宫界限。 ...
【刷题版】掌握算法的一揽子计划——深度优先搜索和回溯
克克克克业业的学习记录
03-18 1100
深搜深度优先搜索（Depth First Search，DFS）属于图论中的概念。在图论中主要用于遍历树或者图上的节点，其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。而在搜索算法中主要通过递归方便地实现暴力枚举。回溯属于一种深搜的技巧，常常用在深搜中。
python栈迷宫路径搜索_深度优先搜索（DFS）
热门推荐
HYSliuliuliu的博客
11-04 1万+
python链栈算法，DFS深度优先搜索 算法通过尝试四个方向（上、下、左、右）来探索迷宫。它使用一个栈来记录当前路径。如果到达终点，它会打印路径并返回True。如果找不到路径，它会打印"走不通！"并返回False。 # 1. 当前所在节点四个方向分别为 x+1,y; x-1,y; x,y+1; x,y-1 # 2. 当前节点，也就是栈里的最后一个节点 stack[-1] # 3. 当走到终点时，就可以输出栈了 # 4. 没走到终点并且下一节点能走时，把该下一节点加入栈并标记为2，表示走过了
广度优先搜索和深度优先搜索
liulanba的博客
03-09 1410
以邻接矩阵表示时，查找每个顶点的邻接点所需的时间为0(V)，故总的时间复杂度为0（V²).以邻接表表示时，查找所有顶点的邻接点所需的时间为O(E)，访问顶点所需的时间为0（V)），此时，总的时间复杂度为O(V+|E|)。采用邻接表存储方式时，每个顶点均需搜索一次（或入队一次)，故时间复杂度为0(V)，在搜索任一顶点的邻接点时，每条边至少访问一次，故时间复杂度为 0(E)，算法总的时间复杂度为0(V+E)。注意：图的邻接矩阵表示是唯一的，但对于邻接表来说，若边的输入次序不同，生成的邻接表也不同。
广度优先搜索算法和深度优先搜索算法——关于路径搜索的问题解决
weixin_49578216的博客
07-26 569
两种遍历搜索都需要一个或者多个数组存贮搜索状态是否经过，或者存储一些别的要求。这个是很重要的。
算法学习 | 回溯算法之深度优先搜索常见题型练习
qq_58284486的博客
11-27 1009
深度优先搜索(Depth First Search)：深度优先搜索属于图算法的一种，其过程主要是对每一个可能的分支路径深入到不能再深入到为止，而且每个节点只能访问一次。深度优先搜索本质上就是暴力搜索，遍历了所有可能的情况，必然能得到解。DFS搜索的流程是一个树的形式，每次一条路走到黑。
回溯算法-深度优先遍历
longzu233的博客
02-28 1131
文章目录1 回溯什么问题适合用回溯回溯与深度优先遍历回溯与递归回溯与枚举2 回溯问题解决思路解决方式优化（剪枝）代码范式3 回溯例题--最多可达的换楼请求回溯路径可行性检验前进和回溯的过程代码剪枝另一种解法：枚举4 其他题目括号生成组合总和组合总和2组合 1 回溯 什么问题适合用回溯 回溯适合解决排列组合的问题。例如从集合A中选出哪些元素组成的集合B（找出子集B），使得B可行/求可行的B个数/最佳方案/所有方案。 回溯的目的是遍历所有组合的可能性。比如有3个元素，如何遍历出所有组合方式（所有子集）？ 回溯与
递归回溯深度优先搜索DFS练习题（含C++源码）
02-10
深度优先搜索（Depth First Search，简称DFS）是一种用于遍历或搜索树或图的算法，它按照“尽可能深”的原则访问节点，直到达到叶节点或回溯到无新节点可访问时为止。在这个过程中，DFS通常与递归和回溯策略结合使用...
贪婪算法-回溯-深度优先搜索.pdf
05-16
《贪婪算法、回溯法与深度优先搜索》 贪婪算法，顾名思义，是一种求解问题时采取贪心策略的算法。在面对问题时，它总是做出当前看起来最优的选择，而不是全局最优。贪婪算法通常用于解决部分最优问题，虽然不能保证...
贪婪算法-回溯-深度优先搜索.docx
05-27
深度优先搜索（DFS）是回溯法的一种常见实现方式，它沿着树的深度优先顺序遍历树的节点，尽可能深地搜索子树。DFS通常采用递归的方式来实现，对于每个节点，如果其未被访问过，就将其标记为已访问，并继续访问其未被...
matlab源码-深度优先搜索.zip
07-13
深度优先搜索(DFS, Depth-First Search)是一种用于遍历或搜索树或图的算法，其基本思想是从起点开始，沿着某一条路径一直探索到尽可能深的层次，如果这条路径不能到达目标，就回溯到上一个节点，再选择另一条路径...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5138
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
[知识点]-[最短路]
m0_52398496的博客
07-31 485
【代码】[知识点]-[最短路]
算法笔记|Day15二叉树V
m0_57632621的博客
08-03 491
算法笔记|Day15二叉树V
c++入门
最新发布
wujianghh的博客
08-03 677
定义命名空间需要用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。// M1是命名空间的名字，一般开发中是用项目名字做命名空间名。// 1. 正常的命名空间定义// 命名空间中可以定义变量/函数/类型int val;//2. 命名空间可以嵌套int a;int b;int c;int d;//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
回溯法：深度优先搜索与解空间树
回溯法是一种有结构的穷举搜索方法，通过在解空间树中进行深度优先遍历来寻找问题的解。它以递归的方式进行，每当遇到一个可能的解时，会先检查该解是否满足所有条件。如果不满足，则退回至上一层，尝试其他分支，...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闻缺陷则喜何志丹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值