[LeetCode] 1631. Path With Minimum Effort (Medium) (JAVA)
Title description:
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
General idea
You are going to participate in a hike. Give you a two-dimensional rows x columns map heights, where heights[row][col] represents the height of the grid (row, col). At first you are in the top left corner (0, 0), and you want to go to the bottom right corner (rows-1, columns-1) (note that the subscripts start numbering from 0). You can move up, down, left, and right in one of the four directions each time, and you want to find the path that consumes the least amount of energy.
The physical energy consumed by a path is determined by the maximum absolute value of the height difference between adjacent grids on the path.
Please return the minimum physical exertion value for walking from the upper left corner to the lower right corner.
Problem-solving method
- Using Dijkstra's algorithm for finding the shortest path (the principle of Dijkstra's algorithm: the shortest path | Dijkstra's algorithm in simple language (1) )
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];
}
}
Execution time: 86 ms, beating 68.69% of Java users
Memory consumption: 38.9 MB, beating 77.82% of Java users