778. Swim in Rising Water（使用最小堆的优先级队列，BFS）

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.
思路：根据题目描述的当时间递增达到所需水位高度才可以游到周围小方格中，这相当于选择该方块上下左右四个位置中权值最小的一个入队，而搜索每次四个方向因此可以使用BFS，将搜索到的方格加入优先级队列中（最小堆），这里注意入队之前需要将周围元素的值与该元素的值两两对比，将周围元素的权值设置为较大者。

struct Node{
    public:
        int val;
        int x;
        int y;
    public:
    Node(int val,int x,int y){
        this->val = val;
        this->x = x;
        this->y = y;
    }
    ~Node(){}
    bool operator < (const Node& node) const {
        return val>node.val;
    } 
};
bool isInGrid(int x, int y, int n, int m) {
        if(x >= 0 && x < n && y >= 0 && y < m) return true;
        return false;
}
class Solution {
public:
    int swimInWater(vector>& grid) {
        int n = grid.size();
        int m = grid[0].size();
        vector> visited(n, vector(m, 0));
        priority_queue q;
        int dx[4] = {1, -1, 0, 0};
        int dy[4] = {0, 0, 1, -1};
        Node node(grid[0][0], 0, 0);
        q.push(node);
        visited[0][0] = 1;
        while(!q.empty()) {
            Node cur = q.top();
            q.pop();
            if(cur.x == n - 1 && cur.y == m - 1) return cur.val;
            for(int k = 0; k < 4; k++) {
                int nx = cur.x + dx[k];
                int ny = cur.y + dy[k];
                if(isInGrid(nx, ny, n, m) && visited[nx][ny] == 0 ) {
                    grid[nx][ny] = max(grid[cur.x][cur.y], grid[nx][ny]);
                    q.push(Node(grid[nx][ny], nx, ny));
                    visited[nx][ny] = 1;
                }
            }
        }
        return 0;
    }
};