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]);
}
执行结果
方法二：优先队列
解题思路
扫描二维码关注公众号，回复：
12519445 查看本文章
- 优先队列根据方格高度从小到大排序
- 从起点
(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，把 3 和 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;
}
执行结果
