LeetCode——778. 水位上升的泳池中游泳(Swim in Rising Water)——分析及代码（Java）

一、题目

在一个 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] 的排列。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/swim-in-rising-water
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析及代码

1. 并查集

（1）思路

用并查集记录方格间的连通性，将各平台按高度进行排序，依次取出较低的方格，若其上、下、左、右有不高于该高度的方格，则将它们连通。当起点平台和终点平台连通时，对应高度即为最小高度。

（2）代码

class Solution {
    public int swimInWater(int[][] grid) {
        int n = grid.length, last = n * n - 1;
        List<int[]> heights = new ArrayList<int[]>();//将平台按高度排序
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                heights.add(new int[]{i * n + j, grid[i][j]});
        Collections.sort(heights, new Comparator<int[]>() {
            public int compare(int[] h1, int[] h2) {
                return h1[1] - h2[1];
            }
        });

        int [] parent = new int[n * n];//并查集初始化
        for (int i = 0; i < parent.length; i++)
            parent[i] = i;
        for (int[] g : heights) {//将上、下、左、右不超过当前高度的平台连通
            int i = g[0] / n, j = g[0] % n, h = g[1];
            if (i > 0 && grid[i - 1][j] <= h)
                union(parent, g[0], g[0] - n);
            if (i < n - 1 && grid[i + 1][j] <= h)
                union(parent, g[0], g[0] + n);
            if (j > 0 && grid[i][j - 1] <= h)
                union(parent, g[0], g[0] - 1);
            if (j < n - 1 && grid[i][j + 1] <= h)
                union(parent, g[0], g[0] + 1);
            if (find(parent, 0) == find(parent, last))
                return h;
        }
        return -1;
    }

    public int find(int[] parent, int i) {
        if (parent[i] != i)
            parent[i] = find(parent, parent[i]);
        return parent[i];
    }

    public void union(int[] parent, int h1, int h2) {
        parent[find(parent, h2)] = find(parent, h1);
    }
}

（3）结果

执行用时 ：17 ms，在所有 Java 提交中击败了 52.90% 的用户；
内存消耗 ：38.2 MB，在所有 Java 提交中击败了 91.42% 的用户。

三、其他

本题还可 结合堆用类似 Dijkstra 算法 或 结合二分查找用广度优先搜索 方法求解，三种方法时间复杂度均为 O(n^2 log n)，空间复杂度均为 O(n^2)。