【LeetCode】1631. Path With Minimum Effort 最小体力消耗路径（Medium）（JAVA）每日一题

最新推荐文章于 2021-06-20 10:12:38 发布

吴中乐

最新推荐文章于 2021-06-20 10:12:38 发布

阅读量205

点赞数

分类专栏： LeetCode 每日一题

本文链接：https://blog.csdn.net/qq_16927853/article/details/113365979

版权

Dijkstra算法最小体力消耗路径 LeetCode 路径规划 Java实现

关键词由CSDN通过智能技术生成

LeetCode 每日一题专栏收录该内容

67 篇文章 0 订阅

订阅专栏

【LeetCode】1631. Path With Minimum Effort 最小体力消耗路径（Medium）（JAVA）

题目描述：

You are a hiker preparing for an upcoming hike. You are given heights, a 2D array of size rows x columns, where heights[row][col] represents the height of cell (row, col). You are situated in the top-left cell, (0, 0), and you hope to travel to the bottom-right cell, (rows-1, columns-1) (i.e., 0-indexed). You can move up, down, left, or right, and you wish to find a route that requires the minimum effort.

A route’s effort is the maximum absolute difference in heights between two consecutive cells of the route.

Return the minimum effort required to travel from the top-left cell to the bottom-right cell.

Example 1:

Input: heights = [[1,2,2],[3,8,2],[5,3,5]]
Output: 2
Explanation: The route of [1,3,5,3,5] has a maximum absolute difference of 2 in consecutive cells.
This is better than the route of [1,2,2,2,5], where the maximum absolute difference is 3.

Example 2:

Input: heights = [[1,2,3],[3,8,4],[5,3,5]]
Output: 1
Explanation: The route of [1,2,3,4,5] has a maximum absolute difference of 1 in consecutive cells, which is better than route [1,3,5,3,5].

Example 3:

Input: heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]
Output: 0
Explanation: This route does not require any effort.

Constraints:

rows == heights.length
columns == heights[i].length
1 <= rows, columns <= 100
1 <= heights[i][j] <= 10^6

题目大意

你准备参加一场远足活动。给你一个二维 rows x columns 的地图 heights ，其中 heights[row][col] 表示格子 (row, col) 的高度。一开始你在最左上角的格子 (0, 0) ，且你希望去最右下角的格子 (rows-1, columns-1) （注意下标从 0 开始编号）。你每次可以往上，下，左，右四个方向之一移动，你想要找到耗费体力最小的一条路径。

一条路径耗费的体力值是路径上相邻格子之间高度差绝对值的最大值决定的。

请你返回从左上角走到右下角的最小体力消耗值。

解题方法

采用求最短路径的Dijkstra算法（Dijkstra算法的原理：最短路径 | 深入浅出Dijkstra算法（一））

class Solution {
    public int minimumEffortPath(int[][] heights) {
        if (heights.length == 0 || heights[0].length == 0) return 0;
        int[][] ori = new int[][]{{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
        int m = heights.length;
        int n = heights[0].length;
        PriorityQueue<int[]> queue = new PriorityQueue<>((a, b) -> (a[2] - b[2]));
        int[] distance = new int[m * n];
        boolean[] checked = new boolean[distance.length];
        Arrays.fill(distance, Integer.MAX_VALUE);
        queue.offer(new int[]{0, 0, 0});
        distance[0] = 0;
        while (queue.size() > 0) {
            int[] cur = queue.poll();
            int x = cur[0];
            int y = cur[1];
            int d = cur[2];
            int index = x * n + y;
            if (checked[index]) continue;
            checked[index] = true;
            for (int i = 0; i < ori.length; i++) {
                int nextX = x + ori[i][0];
                int nextY = y + ori[i][1];
                if (nextX < 0 || nextX >= m || nextY < 0 || nextY >= n) continue;
                int nextIndex = nextX * n + nextY;
                int temp = Math.max(d, Math.abs(heights[x][y] - heights[nextX][nextY]));
                if (temp < distance[nextIndex]) {
                    distance[nextIndex] = temp;
                    queue.offer(new int[]{nextX, nextY, temp});
                }
            }
        }
        return distance[m * n - 1];
    }
}

执行耗时:86 ms,击败了68.69% 的Java用户
内存消耗:38.9 MB,击败了77.82% 的Java用户