避免淹死并到达目的地的最短时间

// Leetcode 2814: 最短时间避免淹死并到达目的地
// 题目思路:
// 使用Java Stream处理相同的任务，重点在于流式处理集合数据。我们还是用Dijkstra算法，但通过流的方式管理优先队列。

import java.util.*;
import java.util.stream.*;

class Solution {
    public int minimumTimeToAvoidDrowning(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
        int[][] time = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; n; j++) {
                time[i][j] = Integer.MAX_VALUE;
            }
        }
        time[0][0] = grid[0][0];
        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[2]));
        pq.add(new int[]{0, 0, grid[0][0]});
        
        while (!pq.isEmpty()) {
            int[] curr = pq.poll();
            int x = curr[0], y = curr[1], t = curr[2];
            
            if (x == m - 1 && y == n - 1) {
                return t;
            }
            
            Arrays.stream(directions)
                  .map(dir -> new int[]{x + dir[0], y + dir[1]})
                  .filter(pos -> pos[0] >= 0 && pos[0] < m && pos[1] >= 0 && pos[1] < n)
                  .forEach(pos -> {
                      int nx = pos[0], ny = pos[1];
                      int newTime = Math.max(t, grid[nx][ny]);
                      if (newTime < time[nx][ny]) {
                          time[nx][ny] = newTime;
                          pq.add(new int[]{nx, ny, newTime});
                      }
                  });
        }
        
        return -1; // If no path is found
    }
}