【图论 深度优先搜索 网格】2577. 在网格图中访问一个格子的最少时间

本文涉及知识点

图论 深度优先搜索 网格 图论知识汇总

LeetCode2577. 在网格图中访问一个格子的最少时间

给你一个 m x n 的矩阵 grid ，每个元素都为 非负 整数，其中 grid[row][col] 表示可以访问格子 (row, col) 的 最早 时间。也就是说当你访问格子 (row, col) 时，最少已经经过的时间为 grid[row][col] 。
你从 最左上角 出发，出发时刻为 0 ，你必须一直移动到上下左右相邻四个格子中的 任意 一个格子（即不能停留在格子上）。每次移动都需要花费 1 单位时间。
请你返回 最早 到达右下角格子的时间，如果你无法到达右下角的格子，请你返回 -1 。
示例 1：

输入：grid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]
输出：7
解释：一条可行的路径为：

• 时刻 t = 0 ，我们在格子 (0,0) 。
• 时刻 t = 1 ，我们移动到格子 (0,1) ，可以移动的原因是 grid[0][1] <= 1 。
• 时刻 t = 2 ，我们移动到格子 (1,1) ，可以移动的原因是 grid[1][1] <= 2 。
• 时刻 t = 3 ，我们移动到格子 (1,2) ，可以移动的原因是 grid[1][2] <= 3 。
• 时刻 t = 4 ，我们移动到格子 (1,1) ，可以移动的原因是 grid[1][1] <= 4 。
• 时刻 t = 5 ，我们移动到格子 (1,2) ，可以移动的原因是 grid[1][2] <= 5 。
• 时刻 t = 6 ，我们移动到格子 (1,3) ，可以移动的原因是 grid[1][3] <= 6 。
• 时刻 t = 7 ，我们移动到格子 (2,3) ，可以移动的原因是 grid[2][3] <= 7 。
  最终到达时刻为 7 。这是最早可以到达的时间。
  示例 2：

输入：grid = [[0,2,4],[3,2,1],[1,0,4]]
输出：-1
解释：没法从左上角按题目规定走到右下角。

提示：
m == grid.length
n == grid[i].length
2 <= m, n <= 1000
4 <= m * n <= 10⁵
0 <= grid[i][j] <= 10⁵
grid[0][0] == 0

网格最短路

令f(x)是x的奇偶性，即f(x) = x%2
推论一：f(x+2) = f(x)
推论二：根据推论一，f(x+2t)=f(x)
推论三：f(x+y)=f((x-y)+2y) ,根据推论一f(x+y) = f(x-y)
推论四:f(x+y)=f(x)+f(y)
如果y是偶数：f(x+2t) = f(x)+f(0) = f(x)+ f(y)
如果y是奇数：f(x+1)=f(x)+f(1)

如果grid[1][0]和gird[0][1] 都小于1，则无法到达。否则，一定能到达，在这三个格子打转，直到能通过。
令某个路径{$\cdots$ (r1,c1),(r2,c2)} 如果因为grid[r][c]的限制，在不断在(r1,c1),(r2,c2)徘徊。

性质一：到达gird[r][c]的时间的奇偶性一定和(r+c)的奇偶性相同

令某个路径到达grid[r][c] ，除了终点经过k个单格，则k和(r+c)的奇偶性相同。
令左移了k1次，右移了k2次，则k2-k1=c。根据推论三：f(k2+k1)=f©
令上移了k3次，下移了k4次，则k4-k3=r。根据推论三：f(k4+k3)=f®
根据推论四：f(k1+k2+k3+k4) = f(r+c)
令最早t时间到达(r,c)
$$\{\begin{array}{llc}t& & t>=grid[r][c]\\ grid[r][c]& & f(t)==f(grid[r][c])\\ grid[r][c]+1& & other\end{array}$$

如果多次到达(r,c)取时间最小的

如果没有grid[r][c]的限制t1,t2都可到达（r,c) ，t1< t2。不失一般性令t1(t2)和grid[r][c]奇偶性相同。
则到达的时间分别为：max(t1,grid[r][c]) max(t2,grid[r][c])
无论是t2 还是grid[r][c]都小于等于max(t1,grid[r][c])

思路

visit记录已经处理格子的最短时间。
小根堆记录最早到达时间，出堆，计算邻接点的时间。

代码

核心代码

class Solution {
public:
	int minimumTime(vector<vector<int>>& grid) {
		if ((grid[0][1] > 1) && (grid[1][0] > 1)) { return -1; }
		const int R = grid.size();
		const int C = grid[0].size();
		vector<vector<int>> vVisti(R, vector<int> (C,-1));
		priority_queue<tuple<int, int, int>, vector< tuple<int, int, int>>, greater<>> heap;
		auto Add = [&](int r, int c, int t) {
			if (-1 != vVisti[r][c]) { return; }
			if (t < grid[r][c]) {
				t = grid[r][c] + (t % 2 != grid[r][c] % 2);
			}
			heap.emplace(t, r, c);
			vVisti[r][c] = t;
		};
		Add(0, 0, 0);
		while (heap.size()) {
			auto [t, r, c] = heap.top();
			if (-1 != vVisti.back().back()) {
				return vVisti.back().back();
			}
			heap.pop();
			if (r + 1 < R) {
				Add( r + 1, c,t+1);
			}
			if (r > 0) {
				Add(r - 1, c, t + 1);
			}
			if (c + 1 < C) {
				Add(r, c + 1, t + 1);
			}
			if (c > 0) {
				Add(r, c - 1, t + 1);
			}
		}
		return -1;
	}
};

单元测试

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(TestMethod0)
		{
			grid = { {0,1,3,2},{5,1,2,5},{4,3,8,6} };
			auto res = Solution().minimumTime(grid);
			AssertEx(7, res);
		}
		TEST_METHOD(TestMethod1)
		{
			grid = { {0,2,4},{3,2,1},{1,0,4} };
			auto res = Solution().minimumTime(grid);
			AssertEx(-1 ,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++**实现。