778. Swim in Rising Water

https://leetcode.com/problems/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.

Note:

1. 2 <= N <= 50.
2. grid[i][j] is a permutation of [0, ..., N*N - 1].

算法：以静制动

时间是流动的，但是最终还是落在台阶的高度上，只要水位达到台阶高度，可以快速游过去，不计游动时间。

采用搜索，但是搜索的时候采用贪心策略，每次游到台阶高度最小处（因为不计游动时间，所有贪心局部最优解就是全局最优解），使用最小堆取出当前台阶最小的值和位置，堆保存一对pair，第一个是高度，第二个用来保存位置信息。

这里堆的比较方法采用自定义比较方法，采用仿函数定义比较函数。结合ordered_set用来记录是否访问过了，确保只访问一次。

struct cmp{ 
    bool operator() (const pair<int,int>& p1,const pair<int,int>& p2){
        return p1.first>p2.first;
    }
};

class Solution {   
public:
    int d[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
    int swimInWater(vector<vector<int>>& grid) {
        int n=grid.size();
        int res=0;
        unordered_set<int> visited({0});
        priority_queue<pair<int,int>,vector<pair<int,int>>,cmp> pq;  //自定义小堆
        pq.push(make_pair(grid[0][0],0));
        while(!pq.empty()){
            int i=pq.top().second/n;
            int j=pq.top().second%n;
            pq.pop();
            res=max(res,grid[i][j]);
            if(i==n-1 && j==n-1) break;
            for(int k=0;k<4;k++){
                int x=i+d[k][0],y=j+d[k][1];
                if(x<0 || x>=n || y<0 || y>=n || visited.count(x*n+y) ) continue;
                visited.insert(x*n+y);
                pq.push(make_pair(grid[x][y],x*n+y));
            }
        }
        return res;
    }
};

参考资料：

https://www.cnblogs.com/grandyang/p/9017300.html