【C++BFS算法 二分查找】1631. 最小体力消耗路径

本文涉及知识

C++BFS算法
C++二分查找

LeetCode1631. 最小体力消耗路径

你准备参加一场远足活动。给你一个二维 rows x columns 的地图 heights ，其中 heights[row][col] 表示格子 (row, col) 的高度。一开始你在最左上角的格子 (0, 0) ，且你希望去最右下角的格子 (rows-1, columns-1) （注意下标从 0 开始编号）。你每次可以往 上，下，左，右 四个方向之一移动，你想要找到耗费 体力 最小的一条路径。
一条路径耗费的 体力值 是路径上相邻格子之间 高度差绝对值 的 最大值 决定的。
请你返回从左上角走到右下角的最小 体力消耗值 。
示例 1：

输入：heights = [[1,2,2],[3,8,2],[5,3,5]]
输出：2
解释：路径 [1,3,5,3,5] 连续格子的差值绝对值最大为 2 。
这条路径比路径 [1,2,2,2,5] 更优，因为另一条路径差值最大值为 3 。
示例 2：

输入：heights = [[1,2,3],[3,8,4],[5,3,5]]
输出：1
解释：路径 [1,2,3,4,5] 的相邻格子差值绝对值最大为 1 ，比路径 [1,3,5,3,5] 更优。
示例 3：

输入：heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]
输出：0
解释：上图所示路径不需要消耗任何体力。

提示：
rows == heights.length
columns == heights[i].length
1 <= rows, columns <= 100
1 <= heights[i][j] <= 10⁶

二分查找

check(x )表示消耗i体力能否到达右下角。显然随着x从0$\to$ 10⁶，f(x)的结果从false变成true。
寻找第一个true。

BFS

根据x 建立邻接表。
BFS的状态表示：leves[i]记录通过i步可以到达的单格。
BFS的后续状态：通过(r1,c1)枚举(r,c)的邻接单格。
BFS的初始状态：leves[0]={{0,0}}。
BFS的状态：枚举到右下角，直接返回。每枚举到返回false。
BFS的重复处理：vis数组除重。

代码

核心代码

template<class INDEX_TYPE>
class CBinarySearch
{
public:
	CBinarySearch(INDEX_TYPE iMinIndex, INDEX_TYPE iMaxIndex):m_iMin(iMinIndex),m_iMax(iMaxIndex) {}
	template<class _Pr>
	INDEX_TYPE FindFrist( _Pr pr)
	{
		auto left = m_iMin - 1;
		auto rightInclue = m_iMax;
		while (rightInclue - left > 1)
		{
			const auto mid = left + (rightInclue - left) / 2;
			if (pr(mid))
			{
				rightInclue = mid;
			}
			else
			{
				left = mid;
			}
		}
		return rightInclue;
	}
protected:
	const INDEX_TYPE m_iMin, m_iMax;
};

class Solution {
		public:
			int minimumEffortPath(vector<vector<int>>& heights) {
				m_r = heights.size();
				m_c = heights[0].size();
				auto Check=[&](int mid) {
					vector<vector<pair<int,int>>> neiBo(m_r * m_c);
					auto AddNeiBo = [&](int r, int c, int r1, int c1) {
						if ((r1 < 0) || (r1 >= m_r)) { return; }
						if ((c1 < 0) || (c1 >= m_c)) { return; }
						if (abs(heights[r1][c1] - heights[r][c]) > mid) { return; }
						neiBo[Mask(r, c)].emplace_back(r1, c1);
					};
					for (int r = 0; r < m_r; r++) {
						for (int c = 0; c < m_c; c++) {
							AddNeiBo(r, c, r + 1, c);
							AddNeiBo(r, c, r - 1, c);
							AddNeiBo(r, c, r, c + 1);
							AddNeiBo(r, c, r, c - 1);
						}
					}
					vector<vector<bool>> vis(m_r, vector<bool>(m_c));
					queue<pair<int, int>> que;
					que.emplace(0, 0);
					vis[0][0] = true;
					while (que.size()) {
						const auto [r, c] = que.front();
						if ((r + 1 == m_r) && (c + 1 == m_c)) { return true; }
						que.pop();
						for (const auto& [r1, c1] : neiBo[Mask(r, c)]) {
							if (vis[r1][c1]) { continue; }
							vis[r1][c1] = true;
							que.emplace(r1, c1);
						}
					}
					return false;
				};
				CBinarySearch bs(0, 1000'000);
				return bs.FindFrist(Check) ;
			}	
			inline int Mask(int r, int c) { return m_c * r + c; }
			int m_r, m_c;
		};

单元测试

	vector<vector<int>> heights;
		TEST_METHOD(TestMethod11)
		{
			heights = { {1,2,2},{3,8,2},{5,3,5} };
			auto res = Solution().minimumEffortPath(heights);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod12)
		{
			heights = { {1,2,3},{3,8,4},{5,3,5} };
			auto res = Solution().minimumEffortPath(heights);
			AssertEx(1, res);
		}
		TEST_METHOD(TestMethod13)
		{
			heights = { {1,2,1,1,1},{1,2,1,2,1},{1,2,1,2,1},{1,2,1,2,1},{1,1,1,2,1} };
			auto res = Solution().minimumEffortPath(heights);
			AssertEx(0, res);
		}
	};

扩展阅读

我想对大家说的话
工作中遇到的问题，可以按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
学习算法：按章节学习《喜缺全书算法册》，大量的题目和测试用例，打包下载。重视操作
有效学习：明确的目标 及时的反馈 拉伸区（难度合适） 专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛
失败+反思=成功 成功+反思=成功

视频课程

先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771
如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

测试环境

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