leetcode 778. Swim in Rising Water

On an N x N grid, each square grid[i][j] represents the elevation at that point (i,j).

Now rain starts to fall. At time t, the depth of the water everywhere is t. You can swim from a square to another 4-directionally adjacent square if and only if the elevation of both squares individually are at most t. You can swim infinite distance in zero time. Of course, you must stay within the boundaries of the grid during your swim.

You start at the top left square (0, 0). What is the least time until you can reach the bottom right square (N-1, N-1)?

Example 1:

Input: [[0,2],[1,3]]
Output: 3
Explanation:
At time 0, you are in grid location (0, 0).
You cannot go anywhere else because 4-directionally adjacent neighbors have a higher elevation than t = 0.

You cannot reach point (1, 1) until time 3.
When the depth of water is 3, we can swim anywhere inside the grid.

Example 2:

Input: [[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]]
Output: 16
Explanation:
 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

The final route is marked in bold.
We need to wait until time 16 so that (0, 0) and (4, 4) are connected.

先来理解一下题意，题目说在时刻t，各处水深为t；二维向量grid中的值为每个网格的高度，只有当水深不小于网格高度时才能游向下一个网格，求从左上角游向右下角所需最短时间；从左上角到右下角有多条路径，每条路径的值为这条路径中网格的最高高度，求所有路径中的最小值；

使用广度优先搜索算法遍历网格，但是使用的是priority_queue作为辅助队列；每个网格有两个属性：坐标和高度；因此每个网格可以用pair(-time(height),y*n+x)来表示；每个网格可以游向的（相邻）网格分别是上下左右四个，将当前网格与相邻网格的更大time值和坐标压入队列，表示从左上角到此坐标网格路径上的最大高度，但是priority_queue是一个大顶堆，在time前面加负号就变成了小顶堆，因此从所有路径的最小值出发继续搜索，直到遍历到右下角网格，返回当前网格和右下角网格高度的较大值；

class Solution {
public:
    int swimInWater(vector>& grid) 
    {
        int n = grid.size();
        priority_queue> q;//pair<-time,y*n+x>;
        vector visited(n*n);
        vector dirs{-1,0,1,0,-1};
        q.push({-grid[0][0],0});
        visited[0]=1;
        while(!q.empty())
        {
            pair node = q.top();
            q.pop();
            int time = -node.first;
            int x = node.second % n;
            int y = node.second / n;
            for(int i = 0;i<4;i++)
            {
                int tx = x + dirs[i];
                int ty = y + dirs[i+1];
                if(tx < 0 || ty < 0 || tx>=n || ty >= n) continue;
                if(visited[ty*n+tx]) continue;
                if(ty == n-1 && tx == n-1) return max(time,grid[n-1][n-1]);
                visited[ty*n+tx] = 1;
                q.push({-max(time,grid[ty][tx]),ty*n+tx});
            }
        }
        return -1;
    }
};

声明：这个算法是网上大神(花花酱)的算法,我还没法给出正确性证明。