最小体力消耗路径

/*
 * Problem: Find the minimum effort required to travel from the top-left to the bottom-right corner of a grid. 
 * The effort is defined by the maximum absolute difference in heights between two adjacent cells on the path.
 * Solution Approach: This solution uses the same approach as the previous one but leverages Java Streams.
 */
import java.util.*;
import java.util.stream.*;

class SolutionStream {
    public int minimumEffortPath(int[][] heights) {
        int rows = heights.length;
        int cols = heights[0].length;
        int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        int[][] effort = IntStream.range(0, rows).mapToObj(i -> IntStream.range(0, cols).map(j -> Integer.MAX_VALUE).toArray()).toArray(int[][]::new);
        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
        pq.offer(new int[]{0, 0, 0}); // effort, row, col
        effort[0][0] = 0;
        while (!pq.isEmpty()) {
            int[] current = pq.poll();
            int currentEffort = current[0];
            int row = current[1];
            int col = current[2];
            if (row == rows - 1 && col == cols - 1) {
                return currentEffort;
            }
            Arrays.stream(directions).forEach(direction -> {
                int newRow = row + direction[0];
                int newCol = col + direction[1];
                if (newRow >= 0 && newRow < rows && newCol >= 0 && newCol < cols) {
                    int nextEffort = Math.max(currentEffort, Math.abs(heights[newRow][newCol] - heights[row][col]));
                    if (nextEffort < effort[newRow][newCol]) {
                        effort[newRow][newCol] = nextEffort;
                        pq.offer(new int[]{nextEffort, newRow, newCol});
                    }
                }
            });
        }
        return 0; // Unreachable code, since the destination will always be reached
    }
}