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

news2024/11/14 10:29:08

本文涉及知识

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 $\rightarrow$ 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);
		}
	};

扩展阅读

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