LeetCode 每日一題778. 水位上升的泳池中游泳

阿新 • • 發佈：2021-01-31

778. 水位上升的泳池中游泳

在一個 N x N 的座標方格 grid 中，每一個方格的值 grid[i][j] 表示在位置 (i,j) 的平臺高度。

現在開始下雨了。當時間為 t 時，此時雨水導致水池中任意位置的水位為 t 。你可以從一個平臺遊向四周相鄰的任意一個平臺，但是前提是此時水位必須同時淹沒這兩個平臺。假定你可以瞬間移動無限距離，也就是預設在方格內部遊動是不耗時的。當然，在你游泳的時候你必須待在座標方格里面。

你從座標方格的左上平臺 (0，0) 出發。最少耗時多久你才能到達座標方格的右下平臺 (N-1, N-1)？

示例 1:

輸入: [[0,2],[1,3]]
輸出: 3
解釋:
時間為0時，你位於座標方格的位置為 (0, 0)。
此時你不能遊向任意方向，因為四個相鄰方向平臺的高度都大於當前時間為 0 時的水位。

等時間到達 3 時，你才可以遊向平臺 (1, 1). 因為此時的水位是 3，座標方格中的平臺沒有比水位 3 更高的，所以你可以遊向座標方格中的任意位置

示例2:

輸入: [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]
輸出: 16
解釋:
 0  1  2  3  4
24 23 22 21  5
12 13 14 
 15 16
11 17 18 19 20
10  9  8  7  6

最終的路線用加粗進行了標記。
我們必須等到時間為 16，此時才能保證平臺 (0, 0) 和 (4, 4) 是連通的

提示:

2 <= N <= 50。
grid[i][j] 是 [0, ..., N*N - 1] 的排列。

方法一：二分查詢

解題思路

昨天的題換了一個馬甲～

因為高度的上下限是確定的即 [0, N × N - 1]，結果一定是這個區間內。
可以採用二分查詢搜尋整個區間，找出結果值。
每次查詢依然採用 BFS 遍歷全圖，看是否能從起點游到終點。

參考程式碼

public int swimInWater 
(int[][] grid) {
    int N = grid.length;
    // 左右邊界
    int left = 2 * N - 2, right = N * N - 1;
    int[][] dirs = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
    while (left < right) {
        int mid = (left + right) / 2;
        // 採用 BFS 遍歷全圖，看 mid 高度是否能游到終點來確定下一次搜尋的區間
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{0, 0});
        boolean[][] vis = new boolean[N][N];
        vis[0][0] = true;
        while (!queue.isEmpty()) {
            int[] point = queue.poll();
            int x = point[0], y = point[1];
            for (int i = 0; i < 4; i++) {
                int nx = x + dirs[i][0], ny = y + dirs[i][1];
                if (nx >= 0 && nx < N && ny >= 0 && ny < N && !vis[nx][ny] && grid[nx][ny] <= mid) {
                    queue.offer(new int[]{nx, ny});
                    vis[nx][ny] = true;
                }
            }
        }
        if (vis[N - 1][N - 1]) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    // 最高點可能在初始位置
    return Math.max(left, grid[0][0]);
}

執行結果
在這裡插入圖片描述

方法二：優先佇列

解題思路

優先佇列根據方格高度從小到大排序
從起點 (0, 0) 開始，把每次能訪問到的點加入優先佇列
每次都選擇最低的點游過去，直到游到終點 (N - 1, N - 1)

這麼說比較抽象，看如下示例：

0 1 3
4 8 7
2 5 6
顯然， 0 -> 4 -> 2 -> 5 -> 6 是最優解。

按照上述流程，是這樣的：
步驟一：初始 0，能游到 1 和 4，把 1 和 4 加入佇列。隊內元素 -> [1, 4]
步驟二：游到 1，能游到 3 和 8，把 2 和 8 加入佇列。隊內元素 -> [3, 4, 8]
步驟三：游到 3，能游到 7，把 7 加入佇列。對內元素 -> [4, 7, 8]
步驟四：游到 4，能游到 2，把 2 加入佇列。對內元素 -> [2, 7, 8]

明顯，此時已經游回“正軌”，接下來按照 4 -> 2 -> 5 -> 6 的順序就能游到終點。

優先佇列就是用來保證無論怎麼“偏航”，最終都會游回“正軌”

參考程式碼

public int swimInWater(int[][] grid) {
    int N = grid.length;
    Queue<int[]> queue = new PriorityQueue<>(Comparator.comparingInt(a -> grid[a[0]][a[1]]));
    queue.offer(new int[]{0, 0});
    boolean[][] vis = new boolean[N][N];
    vis[0][0] = true;

    int[][] dirs = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
    int ans = 0;
    while (!queue.isEmpty()) {
        int[] point = queue.poll();
        int x = point[0], y = point[1];
        ans = Math.max(ans, grid[x][y]);
        if (x == N - 1 && y == N - 1) {
            break;
        }
        for (int[] dir : dirs) {
            int nx = x + dir[0], ny = y + dir[1];
            if (nx >= 0 && nx < N && ny >= 0 && ny < N && !vis[nx][ny]) {
                queue.offer(new int[]{nx, ny});
                vis[nx][ny] = true;
            }
        }
    }
    return ans;
}