2023-2-28 刷题情况

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

题目描述

给你一个 m x n 的矩阵 grid ，每个元素都为 非负 整数，其中 grid[row][col] 表示可以访问格子 (row, col) 的 最早 时间。也就是说当你访问格子 (row, col) 时，最少已经经过的时间为 grid[row][col] 。

你从 最左上角 出发，出发时刻为 0 ，你必须一直移动到上下左右相邻四个格子中的 任意 一个格子（即不能停留在格子上）。每次移动都需要花费 1 单位时间。

请你返回 最早 到达右下角格子的时间，如果你无法到达右下角的格子，请你返回 -1 。

样例

样例输入

grid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]
grid = [[0,2,4],[3,2,1],[1,0,4]]

样例输出

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 。这是最早可以到达的时间。

-1
解释：没法从左上角按题目规定走到右下角。

提示

• $m==grid.length$
• $n==grid[i].length$
• $2<=m,n<=1000$
• $4<=m\ast n<=10^5$
• $0<=grid[i][j]<=10^5$
• $grid[0][0]==0$

思路

可以使用dijkstra算法求最短路，且如果当前值并没有更新最短路就不需要入队，避免bfs陷入死循环。还有一个就是可以最短通过时间，这个可以通过两个格子的反复横跳，来拖时间，所以所有结点一定是可以到达的（除非出现第二种测试用例那种情况，这个需要特判）。

代码实现

class Solution {
    private static final int[][] dir = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

    public int minimumTime(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        if(grid[1][0] > 1 && grid[0][1] > 1) 
            return -1;
        int[][] dis = new int[m][n];
        // 初始化dis数组。
        for(int i = 0; i < m; i++) 
            Arrays.fill(dis[i], Integer.MAX_VALUE);
        dis[0][0] = 0;
        // 按照到达当前结点的最短时间排序，因为每次移动，或者说每条路的权值为1，就只需要按照最短时间排序就可
        PriorityQueue<int[]> pq = new PriorityQueue<int[]>((a, b) -> a[0] - b[0]);
        pq.add(new int[]{0, 0, 0});
        while(true){
            var cur = pq.poll();
            int d = cur[0], i = cur[1], j = cur[2];
            if(i == m - 1 && j == n - 1) 
                return d;
            for(var q : dir){
                int x = i + q[0], y = j + q[1];
                if(0 <= x && x < m && 0 <= y && y < n){
                    int val = Math.max(d + 1, grid[x][y]);
                    // 因为反复横跳需要判断奇偶性，所以加个语句看看是否需要加1.
                    val += (val - x - y) % 2;
                    // 当只有当前结点的最短路被更新才能去更新与当前结点有关的最短路
                    if(val < dis[x][y]){
                        dis[x][y] =val;
                        pq.add(new int[]{val, x, y});
                    }
                }
            }
        }
    }
}

还有一种解法，我明天去看明白。