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<vector<int>>& grid) {
        int n = grid.size();
        int m = grid[0].size();
        vector<vector<int>> visited(n, vector<int>(m, 0));
        priority_queue<Node> 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;
    }
};