778. Swim in Rising Water

▶ 给定方阵 grid，其元素的值为 D₀^n-1，代表网格中该点处的高度。现在网格中开始积水，时刻 t 的时候所有值不大于 t 的格点被水淹没，当两个相邻格点（上下左右四个方向）的值都不超过 t 的时候我们称他们连通，即可以通过游泳到达，请问能将主对角两顶点（(0, 0) 和 (n-1, n-1)）连通的最小时刻是多少？例如 下图的最小连通时间为 16 。

　　

● 自己的代码，22 ms，简单 BFS，普通队列

 class Solution
 {
 public:
     int swimInWater(vector<vector<int>>& grid)//set a binary search to find a proper moment
     {
         const int n = grid.size();
         int lp, rp, mp;
         for (lp = max( * n - , max(grid[][], grid[n - ][n - ])) - , rp = n * n, mp = (lp + rp) / ; lp < rp && mp > lp; mp = (lp + rp) / )
         {                       // 时间最小是 2n-2，最大是 n^2-1
             if (swim(grid, mp))
                 rp = mp;
             else
                 lp = mp;
         }
         return rp;
     }
     bool swim(vector<vector<int>>& grid, int time)// swimming at the moment 'time', can I reach the point (n-1, n-1)?
     {
         const int n = grid.size();
         vector<vector<bool>> table(n, vector<bool>(n, false));
         queue<vector<int>> qq;
         vector<int> temp;
         int row, col;
         for (qq.push({ ,  }), table[][] = true; !qq.empty();)
         {
             temp = qq.front(), qq.pop(), row = temp[], col = temp[];
             if (row == n -  && col == n - )
                 return true;
 
             if (row >  && grid[row - ][col] <= time && !table[row - ][col])// up
                 qq.push({ row - , col }), table[row - ][col] = true;
             if (col >  && grid[row][col - ] <= time && !table[row][col - ])// left
                 qq.push({ row, col -  }), table[row][col - ] = true;
             if (row < n -  && grid[row + ][col] <= time && !table[row + ][col])// down
                 qq.push({ row + , col }), table[row + ][col] = true;
             if (col < n -  && grid[row][col + ] <= time && !table[row][col + ])// right
                 qq.push({ row, col +  }), table[row][col + ] = true;
         }
         return false;
     }
 };

● 大佬的代码，13 ms，DFS，注意这里使用了一个数组 dir 来决定搜索方向，比较有趣的用法

 class Solution
 {
 public:
     int swimInWater(vector<vector<int>>& grid)
     {
         const int n = grid.size();
         int lp, rp, mp;
         for (lp = grid[][], rp = n * n - ; lp < rp;)
         {
             mp = lp + (rp - lp) / ;
             if (valid(grid, mp))
                 rp = mp;
             else
                 lp = mp + ;
         }
         return lp;
     }
     bool valid(vector<vector<int>>& grid, int waterHeight)
     {
         const int n = grid.size();
         const vector<int> dir({ -, , , , - });
         vector<vector<bool>> visited(n, vector<bool>(n, ));
         return dfs(grid, visited, dir, waterHeight, , , n);
     }
     bool dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, vector<int>& dir, int waterHeight, int row, int col, int n)
     {
         int i, r, c;
         visited[row][col] = true;
         for (i = ; i < ; ++i)
         {
             r = row + dir[i], c = col + dir[i + ];
             if (r >=  && r < n && c >=  && c < n && visited[r][c] == false && grid[r][c] <= waterHeight)
             {
                 if (r == n -  && c == n - )
                     return true;
                 if (dfs(grid, visited, dir, waterHeight, r, c, n))
                     return true;
             }
         }
         return false;
     }
 };

● 大佬的代码，185 ms，DP + DFS，维护一个方阵 dp，理解为“沿着当前搜索路径能够到达某一格点的最小时刻”，初始假设 dp = [INT_MAX] ，即所有的格点都要在 INT_MAX 的时刻才能到达，深度优先遍历每个点，不断下降每个点的值（用该点原值和用于遍历的临时深度值作比较，两者都更新为他们的较小者）

 class Solution
 {
 public:
     int swimInWater(vector<vector<int>> &grid)
     {
         const int m = grid.size();
         vector<vector<int>> dp(m, vector<int>(m, INT_MAX));
         helper(grid, , , , dp);
         return dp[m - ][m - ];
     }
     void helper(vector<vector<int>> &grid, int row, int col, int deep, vector<vector<int>> &dp)
     {
         const int m = grid.size();
         int i, x, y;
         deep = max(deep, grid[row][col]);
         if (dp[row][col] <= deep)
             return;
         for (dp[row][col] = deep, i = ; i < direction.size(); i++)
         {
             x = row + direction[i][], y = col + direction[i][];
             if (x >=  && x < m && y >=  && y < m)
                 helper(grid, x, y, dp[row][col], dp);
         }
     }
     vector<vector<int>> direction = { { -,  },{ ,  },{ ,  },{ , - } };
 };

● 大佬的代码，18 ms，DFS，优先队列，Dijkstra算法，相当于在搜索队列中，总是优先研究最小时刻的点

 class Solution
 {
 public:
     int swimInWater(vector<vector<int>>& grid)
     {
         const int n = grid.size();
         const vector<int> dir({ -, , , , - });
         int ans, i, r, c;
         priority_queue<vector<int>, vector<vector<int>>, greater<vector<int>>> pq;
         vector<vector<bool>> visited(n, vector<bool>(n, false));
         vector<int> cur;
         for (visited[][] = true, ans = max(grid[][], grid[n - ][n - ]), pq.push({ ans, ,  }); !pq.empty();)
         {
             cur = pq.top(),pq.pop(), ans = max(ans, cur[]);
             for (i = ; i < ; i++)
             {
                 r = cur[] + dir[i], c = cur[] + dir[i + ];
                 if (r >=  && r < n && c >=  && c < n && visited[r][c] == false)
                 {
                     visited[r][c] = true;
                     if (r == n -  && c == n - )
                         return ans;
                     pq.push({ grid[r][c], r, c });
                 }
             }
         }
         return -;
     }
 };

● 大佬的代码，11 ms，使用那个 DP + DFS 解法的深度更新思路，把搜索方式换成 BFS

 class Solution
 {
 public:
     int swimInWater(vector<vector<int>>& grid)
     {
         const int n = grid.size();
         const vector<int> dir({ -, , , , - });
         int ans, i, r, c;
         vector<vector<bool>> visited(n, vector<bool>(n, false));
         priority_queue<vector<int>, vector<vector<int>>, greater<vector<int>>> pq;
         vector<int> cur;
         queue<pair<int, int>> myq;
         pair<int, int> p;
         for (visited[][] = true, ans = max(grid[][], grid[n - ][n - ]), pq.push({ ans, ,  }); !pq.empty();)
         {
             cur = pq.top(), pq.pop(), ans = max(ans, cur[]);
             for (myq.push({ cur[], cur[] }); !myq.empty();)
             {
                 p = myq.front(), myq.pop();
                 if (p.first == n -  && p.second == n - )
                     return ans;
                 for (i = ; i < ; ++i)
                 {
                     r = p.first + dir[i], c = p.second + dir[i + ];
                     if (r >=  && r < n && c >=  && c < n && visited[r][c] == )
                     {
                         visited[r][c] = true;
                         if (grid[r][c] <= ans)
                             myq.push({ r, c });
                         else
                             pq.push({ grid[r][c], r, c });
                     }
                 }
             }
         }
         return -;
     }
 };

▶ 附上一个测试数据，答案为 266

 {
     {, , , , , , , , , , , , , , , , , , , },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , ,, , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  },
     { , , , , , , , , , , , , , , , , , , ,  }
 };