lc3341. 到达最后一个房间的最少时间 Ⅰ 算法解析

原题链接：3341. 到达最后一个房间的最少时间 I - 力扣（LeetCode）

一、题目描述

有一个地窖，地窖中有 n x m 个房间，呈网格状排布。给定一个大小为 n x m 的二维数组 moveTime，其中 moveTime[i][j] 表示在这个时刻以后，你才可以开始往这个房间移动。在时刻 t = 0 时从房间 (0, 0) 出发，每次可以移动到相邻（有公共边，水平或竖直方向）的一个房间，在相邻房间之间移动需要的时间为 1 秒。要求返回到达房间 (n - 1, m - 1) 所需要的最少时间。
 

二、BFS 算法思想

2.1 基本概念

广度优先搜索（BFS）是一种用于遍历或搜索树或图的算法。它从根节点（或起始节点）开始，逐层地访问节点，即先访问距离起始节点最近的所有节点，然后再依次访问距离更远的节点。在本题中，我们可以将地窖中的每个房间看作图中的一个节点，相邻房间之间的连接看作图中的边。

2.2 BFS 在本题中的应用

在本题中，我们要从房间 (0, 0) 出发，找到到达房间 (n - 1, m - 1) 的最少时间。BFS 的基本步骤如下：

1. 初始化：将起始节点 (0, 0) 加入队列，并标记该节点已经被访问。同时，使用一个二维数组 mark 来记录到达每个房间的最早时间，初始化为一个较大的值（这里用 0x3f3f3f3f 表示无穷大），将起始节点的最早时间设为 0。
2. 循环扩展：当队列不为空时，取出队列的队首元素，检查该元素是否为目标节点 (n - 1, m - 1)。如果是，则返回当前的时间；如果不是，则遍历该节点的所有相邻节点。
3. 相邻节点处理：对于每个相邻节点，检查是否可以在当前时间的基础上移动到该节点。如果可以，则更新该节点的最早时间，并将该节点加入队列。

2.3 代码体现

// 广度优先搜索函数
int bfs(vector<vector<int>> &mark, vector<vector<int>> &mt) {// 优先队列，存储 {时间, {x 坐标, y 坐标}}priority_queue<pll, vector<pll>, greater<pll>> q;// 将起始节点加入队列，起始时间为 0q.push({0, {0, 0}});// 标记起始节点的最早时间为 0mark[0][0] = 0;// 当队列不为空时while (!q.empty()) {// 取出队首元素的时间int t = q.top().first;// 取出队首元素的 x 坐标int x = q.top().second.first;// 取出队首元素的 y 坐标int y = q.top().second.second;// 弹出队首元素q.pop();// 如果到达目标节点，返回当前时间if (x == n - 1 && y == m - 1) return t;// 如果当前时间大于该节点的最早时间，跳过if (t > mark[x][y]) continue;// 遍历四个相邻方向for (int i = 0; i < 4; i++) {// 计算相邻节点的 x 坐标int nx = x + dx[i];// 计算相邻节点的 y 坐标int ny = y + dy[i];// 检查相邻节点是否在网格内，并且当前时间加 1 小于该节点的最早时间if (nx >= 0 && ny >= 0 && nx < n && ny < m && t + 1 < mark[nx][ny]) {// 如果当前时间加 1 大于该节点的可进入时间if (t + 1 > mt[nx][ny]) {// 将新的状态加入队列q.push({t + 1, {nx, ny}});// 更新该节点的最早时间mark[nx][ny] = t + 1;} // 如果当前时间加 1 小于等于该节点的可进入时间else if (mt[nx][ny] + 1 < mark[nx][ny]) {// 将新的状态加入队列q.push({mt[nx][ny] + 1, {nx, ny}});// 更新该节点的最早时间mark[nx][ny] = mt[nx][ny] + 1;}}}}// 返回目标节点的最早时间return mark[n - 1][m - 1];
}

三、优先队列优化思路

3.1 普通 BFS 的问题

在普通的 BFS 中，我们使用一个普通的队列来存储待扩展的节点。队列的特点是先进先出，即先加入队列的节点会先被扩展。但是在本题中，我们希望优先扩展那些到达时间更早的节点，因为这样可以更快地找到到达目标节点的最少时间。如果使用普通队列，可能会导致一些到达时间较晚的节点先被扩展，从而增加不必要的计算量。

3.2 优先队列的使用

优先队列（也称为堆）是一种特殊的队列，它可以根据元素的优先级来决定出队的顺序。在本题中，我们使用一个小顶堆（优先队列）来存储待扩展的节点，堆中的元素按照到达时间从小到大排序。这样，每次从堆中取出的节点都是当前到达时间最早的节点，从而保证我们可以更快地找到到达目标节点的最少时间。
 

// 定义优先队列，存储 {时间, {x 坐标, y 坐标}}，按照时间从小到大排序
priority_queue<pll, vector<pll>, greater<pll>> q;

在每次扩展节点时，我们将新的状态 {时间, {x 坐标, y 坐标}} 加入优先队列。优先队列会自动根据时间对元素进行排序，保证每次取出的元素都是当前到达时间最早的节点。

四、完整代码

class Solution {
public:int n, m;// 方向数组，用于表示四个方向的偏移量int dx[4] = {0, 1, 0, -1};int dy[4] = {1, 0, -1, 0};// 定义三元组类型using pll = pair<int, pair<int, int>>;// 广度优先搜索函数int bfs(vector<vector<int>> &mark, vector<vector<int>> &mt) {// 优先队列，存储 {时间, {x 坐标, y 坐标}}priority_queue<pll, vector<pll>, greater<pll>> q;// 将起始节点加入队列，起始时间为 0q.push({0, {0, 0}});// 标记起始节点的最早时间为 0mark[0][0] = 0;// 当队列不为空时while (!q.empty()) {// 取出队首元素的时间int t = q.top().first;// 取出队首元素的 x 坐标int x = q.top().second.first;// 取出队首元素的 y 坐标int y = q.top().second.second;// 弹出队首元素q.pop();// 如果到达目标节点，返回当前时间if (x == n - 1 && y == m - 1) return t;// 如果当前时间大于该节点的最早时间，跳过if (t > mark[x][y]) continue;// 遍历四个相邻方向for (int i = 0; i < 4; i++) {// 计算相邻节点的 x 坐标int nx = x + dx[i];// 计算相邻节点的 y 坐标int ny = y + dy[i];// 检查相邻节点是否在网格内，并且当前时间加 1 小于该节点的最早时间if (nx >= 0 && ny >= 0 && nx < n && ny < m && t + 1 < mark[nx][ny]) {// 如果当前时间加 1 大于该节点的可进入时间if (t + 1 > mt[nx][ny]) {// 将新的状态加入队列q.push({t + 1, {nx, ny}});// 更新该节点的最早时间mark[nx][ny] = t + 1;} // 如果当前时间加 1 小于等于该节点的可进入时间else if (mt[nx][ny] + 1 < mark[nx][ny]) {// 将新的状态加入队列q.push({mt[nx][ny] + 1, {nx, ny}});// 更新该节点的最早时间mark[nx][ny] = mt[nx][ny] + 1;}}}}// 返回目标节点的最早时间return mark[n - 1][m - 1];}// 主函数，计算到达目标节点的最少时间int minTimeToReach(vector<vector<int>>& moveTime) {// 获取网格的行数n = moveTime.size();// 获取网格的列数m = moveTime[0].size();// 初始化 mark 数组，用于记录到达每个节点的最早时间vector<vector<int>> mark(n, vector<int>(m));// 初始化 mark 数组的每个元素为无穷大for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {mark[i][j] = 0x3f3f3f3f;}}// 调用 bfs 函数计算最少时间return bfs(mark, moveTime);}
};

五、总结

通过使用 BFS 算法和优先队列优化，我们可以有效地解决在有时间限制条件下到达目标房间的最少时间问题。BFS 算法保证了我们可以逐层扩展节点，而优先队列优化则保证了我们可以优先扩展到达时间更早的节点，从而减少不必要的计算量。在实际应用中，遇到类似具有时间依赖或权值限制的路径搜索问题，都可以考虑使用这种方法来解决。

希望这篇博客能帮助大家理解这道算法题的解法和代码实现思路。欢迎大家在评论区交流讨论！