【01最短路 BFS】1368. 使网格图至少有一条有效路径的最小代价

如果有不明白的，请加文末QQ群。

本文涉及知识点

01最短路
C++BFS算法
图论知识汇总

LeetCode 1368. 使网格图至少有一条有效路径的最小代价

给你一个 m x n 的网格图 grid 。 grid 中每个格子都有一个数字，对应着从该格子出发下一步走的方向。 grid[i][j] 中的数字可能为以下几种情况：
1 ，下一步往右走，也就是你会从 grid[i][j] 走到 grid[i][j + 1]
2 ，下一步往左走，也就是你会从 grid[i][j] 走到 grid[i][j - 1]
3 ，下一步往下走，也就是你会从 grid[i][j] 走到 grid[i + 1][j]
4 ，下一步往上走，也就是你会从 grid[i][j] 走到 grid[i - 1][j]
注意网格图中可能会有 无效数字 ，因为它们可能指向 grid 以外的区域。
一开始，你会从最左上角的格子 (0,0) 出发。我们定义一条 有效路径 为从格子 (0,0) 出发，每一步都顺着数字对应方向走，最终在最右下角的格子 (m - 1, n - 1) 结束的路径。有效路径 不需要是最短路径 。
你可以花费 cost = 1 的代价修改一个格子中的数字，但每个格子中的数字 只能修改一次 。
请你返回让网格图至少有一条有效路径的最小代价。
示例 1：
输入：grid = [[1,1,1,1],[2,2,2,2],[1,1,1,1],[2,2,2,2]]
输出：3
解释：你将从点 (0, 0) 出发。
到达 (3, 3) 的路径为： (0, 0) --> (0, 1) --> (0, 2) --> (0, 3) 花费代价 cost = 1 使方向向下 --> (1, 3) --> (1, 2) --> (1, 1) --> (1, 0) 花费代价 cost = 1 使方向向下 --> (2, 0) --> (2, 1) --> (2, 2) --> (2, 3) 花费代价 cost = 1 使方向向下 --> (3, 3)
总花费为 cost = 3.
示例 2：
输入：grid = [[1,1,3],[3,2,2],[1,1,4]]
输出：0
解释：不修改任何数字你就可以从 (0, 0) 到达 (2, 2) 。
示例 3：
输入：grid = [[1,2],[4,3]]
输出：1
示例 4：
输入：grid = [[2,2,2],[2,2,2]]
输出：3
示例 5：
输入：grid = [[4]]
输出：0
提示：
m == grid.length
n == grid[i].length
1 <= m, n <= 100

01最短路

如果方向相同，则距离为0；否则为1。

代码

核心代码

class Solution {
public:
	int minCost(const vector<vector<int>>& grid) {
		const int R = grid.size();
		const int C = grid[0].size();
		const int iMaskCount = R * C;
		int moves[][2] = { {0,0},{0,1},{0,-1},{1,0},{-1,0} };
		int maskAdd[] = { 0,1,-1,C,-C };
		vector<vector<int>> vNeiBo0(iMaskCount), vNeiBo1(iMaskCount);		
		for (int r = 0; r < R; r++) {
			for (int c = 0; c < C; c++) {	
				const int mask = C * r + c;
				for (int move = 1; move <= 4; move++) {
					int r1 = r + moves[move][0];
					int c1 = c + moves[move][1];
					if ((r1 < 0) || (r1 >= R) || (c1 < 0) || (c1 >= C)) { continue; }
					auto& vNeiBo = (grid[r][c] == move) ? vNeiBo0 : vNeiBo1;
					vNeiBo[mask].emplace_back(mask + maskAdd[move]);
				}
			}
		}
		C01BFSDis bfs(vNeiBo0,vNeiBo1,0);
		return bfs.m_vDis.back();
	}
};

单元测试

template<class T1, class T2>
void AssertEx(const T1& t1, const T2& t2)
{
	Assert::AreEqual(t1, t2);
}

template<class T>
void AssertEx(const vector<T>& v1, const vector<T>& v2)
{
	Assert::AreEqual(v1.size(), v2.size());
	for (int i = 0; i < v1.size(); i++)
	{
		Assert::AreEqual(v1[i], v2[i]);
	}
}

template<class T>
void AssertV2(vector<vector<T>> vv1, vector<vector<T>> vv2)
{
	sort(vv1.begin(), vv1.end());
	sort(vv2.begin(), vv2.end());
	Assert::AreEqual(vv1.size(), vv2.size());
	for (int i = 0; i < vv1.size(); i++)
	{
		AssertEx(vv1[i], vv2[i]);
	}
}

namespace UnitTest
{
	vector<vector<int>> grid;
	TEST_CLASS(UnitTest)
	{
	public:
		TEST_METHOD(TestMethod00)
		{
			grid = { {1,1,1,1},{2,2,2,2},{1,1,1,1},{2,2,2,2} };
			auto res = Solution().minCost(grid);
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod01)
		{
			grid = { {1,1,3},{3,2,2},{1,1,4} };
			auto res = Solution().minCost(grid);
			AssertEx(0, res);
		}
		TEST_METHOD(TestMethod02)
		{
			grid = { {1,2},{4,3} };
			auto res = Solution().minCost(grid);
			AssertEx(1, res);
		}
		TEST_METHOD(TestMethod03)
		{
			grid = { {2,2,2},{2,2,2} };
			auto res = Solution().minCost(grid);
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod04)
		{
			grid = { {4} };
			auto res = Solution().minCost(grid);
			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++**实现。