力扣热题——到达最后一个房间的最少时间 I-CSDN博客

问题建模：将地窖视为图，每个房间是一个节点，相邻房间之间的移动视为边。移动到相邻房间的耗时取决于当前时间和目标房间的 moveTime。
动态权重：每个边的权重不是固定的，而是动态的，由 max(当前时间, 目标房间的 moveTime) + 1 决定。
Dijkstra 算法：由于我们需要最短时间路径，使用优先队列（最小堆）实现的 Dijkstra 算法能高效处理动态权重问题，确保每次处理当前最优路径。

解决步骤

初始化：记录每个房间的最短到达时间 dist，起点设为 0，其他设为无穷大。
优先队列：存储三元组（到达时间, 行坐标, 列坐标），按到达时间升序排列。
处理节点：每次取出队列中时间最小的节点，若到达终点则返回时间；否则遍历相邻房间，计算新到达时间并更新队列。
更新策略：若新时间更优，则更新 dist 并将该邻居加入队列，确保后续处理始终最优。

Java写法：

class Solution {
    public int minTimeToReach(int[][] moveTime) {
        int n = moveTime.length;
        int m = moveTime[0].length;
        int[][] dist = new int[n][m];
        for (int i = 0; i < n; i++) {
            Arrays.fill(dist[i], Integer.MAX_VALUE);
        }
        dist[0][0] = 0;
        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] - b[0]);
        pq.offer(new int[]{0, 0, 0});
        int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        
        while (!pq.isEmpty()) {
            int[] current = pq.poll();
            int time = current[0], i = current[1], j = current[2];
            
            if (i == n - 1 && j == m - 1) {
                return time;
            }
            
            if (time > dist[i][j]) {
                continue;
            }
            
            for (int[] dir : dirs) {
                int x = i + dir[0];
                int y = j + dir[1];
                if (x >= 0 && x < n && y >= 0 && y < m) {
                    int newTime = Math.max(time, moveTime[x][y]) + 1;
                    if (newTime < dist[x][y]) {
                        dist[x][y] = newTime;
                        pq.offer(new int[]{newTime, x, y});
                    }
                }
            }
        }
        return -1; // 根据题目描述，应保证有解，此处仅为占位
    }
}

C++写法：

#include <vector>
#include <queue>
#include <climits>
#include <algorithm>

using namespace std;

class Solution {
public:
    int minTimeToReach(vector<vector<int>>& moveTime) {
        int n = moveTime.size();
        if (n == 0) return -1;
        int m = moveTime[0].size();
        if (m == 0) return -1;
        
        vector<vector<int>> dist(n, vector<int>(m, INT_MAX));
        dist[0][0] = 0;
        
        // 优先队列存储 {time, x, y}，按时间从小到大排列
        priority_queue<vector<int>, vector<vector<int>>, greater<vector<int>>> pq;
        pq.push({0, 0, 0});
        
        // 四个移动方向
        vector<vector<int>> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        
        while (!pq.empty()) {
            vector<int> current = pq.top();
            pq.pop();
            int time = current[0], i = current[1], j = current[2];
            
            // 到达终点直接返回
            if (i == n-1 && j == m-1) return time;
            
            // 当前路径非最优，跳过
            if (time > dist[i][j]) continue;
            
            // 遍历四个方向
            for (auto& dir : dirs) {
                int x = i + dir[0];
                int y = j + dir[1];
                if (x >= 0 && x < n && y >= 0 && y < m) {
                    // 计算新时间：必须等待到moveTime[x][y]后才能移动
                    int newTime = max(time, moveTime[x][y]) + 1;
                    // 更新最短路径
                    if (newTime < dist[x][y]) {
                        dist[x][y] = newTime;
                        pq.push({newTime, x, y});
                    }
                }
            }
        }
        return -1; // 输入保证有解，此处仅为语法需要
    }
};

运行时间

时间复杂度和空间复杂度

时间复杂度

O(nm log(nm))

节点总数：网格共有 n*m 个节点（房间）。
优先队列操作：每个节点可能被多次加入队列，但每次队列操作（插入和弹出）的时间复杂度为 O(log(nm))。最坏情况下，每个节点会被处理一次，每条边（共 4nm 条边）会被遍历一次。
总操作次数：每条边对应一次队列插入操作，总操作次数为 O(nm log(nm))，由优先队列的 log(nm) 时间主导。