链接：https://leetcode-cn.com/problems/path-with-minimum-effort/
你准备参加一场远足活动。给你一个二维 rows x columns 的地图 heights ，其中 heights[row][col] 表示格子 (row, col) 的高度。一开始你在最左上角的格子 (0, 0) ，且你希望去最右下角的格子 (rows-1, columns-1) （注意下标从 0 开始编号）。你每次可以往 上，下，左，右 四个方向之一移动，你想要找到耗费 体力 最小的一条路径。
一条路径耗费的 体力值 是路径上相邻格子之间 高度差绝对值 的 最大值 决定的。
请你返回从左上角走到右下角的最小 体力消耗值 。
示例 1：
输入：heights = [[1,2,2],[3,8,2],[5,3,5]]
输出：2
解释：路径 [1,3,5,3,5] 连续格子的差值绝对值最大为 2 。
这条路径比路径 [1,2,2,2,5] 更优，因为另一条路径差值最大值为 3 。
示例 2：
输入：heights = [[1,2,3],[3,8,4],[5,3,5]]
输出：1
解释：路径 [1,2,3,4,5] 的相邻格子差值绝对值最大为 1 ，比路径 [1,3,5,3,5] 更优。
示例 3：
输入：heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]
输出：0
解释：上图所示路径不需要消耗任何体力。
提示：
rows == heights.lengthcolumns == heights[i].length1 <= rows, columns <= 1001 <= heights[i][j] <= 10^6
思路1：最朴素的做法当然就是遍历出每一条路径，找出最终路径。我们尝试做一个剪枝，如果说我们设定一个阈值上限，当查找路径时发现当前边权值大于上限，就可以直接剪去当前的遍历；当整个图中存在一条满足阈值要求的边时，就可以认为该阈值可以满足，我们的任务就变成了找到一条满足这个阈值的最小值。因为1 <= heights[i][j] <= 10^6，所以题目所求的阈值上限不会超过10^6，这就是直接搜索答案的算法。我们可以加一个二分优化，设阈值A>B，若存在一条路径，使得路径上所有的边的权值都满足<=A，自然也就可以满足<=B。路径的搜索可以用DFS或BFS，当然BFS的遍历次数更少，更推荐BFS。不知道会不会有读者有疑惑，因为BFS是一种层次扩展的方式，可能在失败的路径上存在我们需要使用的边，直接在BFS过程中剪枝会不会丢掉可能满足要求的边呢，我们看一个图便知:
在上图中，A-B为红边，表示超过的阈值不满足要求，但是从A->B可以走满足要求的A-C-D-B，也就是说，从B出发到终点（因为能到达B，说明前面的路径都满足要求了）的路径可以被考虑，自然也就不会漏掉任何一个可能路径了。
class Solution {
public:
bool visited[110][110];
typedef pair<int,int> Node;
bool BFS(vector<vector<int>>& heights,int n,int m,int M){
memset(visited,0,sizeof(visited));
queue<pair<int,int>> Que;
Node node = Node{0,0};
visited[0][0] = true;
int i, j;
Que.push(node);
while(!Que.empty()){
node = Que.front();
Que.pop();
i = node.first, j = node.second;
if(i == n - 1 && j == m - 1) return true;
if(i > 0 && !visited[i - 1][j] && abs(heights[i - 1][j] - heights[i][j]) <= M ){
visited[i - 1][j] = true;
Que.push(Node{i - 1,j});
}
if(i + 1 < n && !visited[i + 1][j] && abs(heights[i + 1][j] - heights[i][j]) <= M ){
visited[i + 1][j] = true;
Que.push(Node{i + 1,j});
}
if(j > 0 && !visited[i][j - 1] && abs(heights[i][j - 1] - heights[i][j]) <= M ){
visited[i][j - 1] = true;
Que.push(Node{i,j - 1});
}
if(j + 1 < m && !visited[i][j + 1] && abs(heights[i][j + 1] - heights[i][j]) <= M ){
visited[i][j + 1] = true;
Que.push(Node{i,j + 1});
}
}
return false;
}
int minimumEffortPath(vector<vector<int>>& heights) {
int n = heights.size(), m = heights[0].size(), i, j, L = 0, R = 1000000, M, ans = -1;
while(L <= R){
M = (L + R) >> 1;
if(BFS(heights, n, m, M)){
ans = M;
R = M - 1;
}else{
L = M + 1;
}
}
return ans;
}
};思路2：贪心思路构图。题意要求路径上的权值尽可能地小，我们就尽可能地多用小边；将所有的边权按照大小排序，并依次加入并查集中，当边权为value的边加入并查集后，发现左上角与右下角连通，则value为答案（因为我们加入的边权是单调非减的）。构建边集合的时候，我们只需要从左上遍历到右下，考虑右和下的边即可，而不需要对每个点都考虑上下左右（防止重复运算）。
class Solution {
public:
int Father[10010], Index[110][110];
struct Edge{
int u, v, w;
bool operator < (const Edge edge) const {
return w < edge.w;
}
};
Edge edge[20010];
int LocateToIndex(int x,int y,int n,int m){
return x * m + y;
}
int Find(int x){
if(x == Father[x]) return x;
return Father[x] = Find(Father[x]);
}
void Union(int A,int B){
A = Find(A);
B = Find(B);
if(A != B){
Father[A] = B;
}
}
int minimumEffortPath(vector<vector<int>>& heights) {
memset(Father,0,sizeof(Father));
int n = heights.size(), m = heights[0].size(), i, j, cnt = 0, s, o;
for(i = 0; i < n; ++ i){
for(j = 0; j < m; ++ j){
Index[i][j] = LocateToIndex(i, j, n, m);
Father[Index[i][j]] = Index[i][j];
}
}
for(i = 0; i < n; ++ i){
for(j = 0; j < m; ++ j){
if(i + 1 < n) edge[cnt ++] = Edge{Index[i][j], Index[i + 1][j], abs(heights[i][j] - heights[i + 1][j])};
if(j + 1 < m) edge[cnt ++] = Edge{Index[i][j], Index[i][j + 1], abs(heights[i][j] - heights[i][j + 1])};
}
}
sort(edge, edge + cnt);
s = 0, o = n * m - 1;
for(i = 0; i < cnt; ++ i){
Union(edge[i].u, edge[i].v);
if(Find(s) == Find(o)) return edge[i].w;
}
return 0;
}
};思路3：其实本题是对最短路的定义进行的更改，最短路的长度定义为路径上的边的最大长度。那如果我们使用最短路算法呢？单源最短路的经典算法Dijkstra，维护一个从源点S到当前点v的最短路径长度数组dist[v]，每次基于已有的最短路径对其他路径进行更新。Dijkstra基于这样一种想法，每次dist数组内部最小的值对应的点v（不考虑已经成为过中继点的点），从S到它的最短距离是确定为dist[v]。
| i | 1 | 2 | 3 | 4 | 5 | 6 |
| dist[i] | 1 | 5 | 2 | 6 | 3 | 4 |
| visited[i] | yes | no | yes | no | yes | no |
在如上表格中，可以确定源点到1、3、5，当前要称为中继点的点是5，2、4、6已经分别使用经过1、3考虑，现在需要考虑的是是否能够通过5使得他们的路径长度变小。
这一想法的成立基础是更新逻辑保持单点不减，也就是说，考虑更多的点，答案不会变小。而对于max操作，也是一样的，考虑更多的点，答案也不会变小，因此Dijkstra可以解决这个问题。我们使用带单调队列优化的Dijkstra：
class Solution {
public:
struct Dist{
int i, j, w; // (i,j):到达点 w:dist[v]
bool operator < (const Dist dist) const{
return w > dist.w;
}
};
bool visited[110][110]; // 已经确定dist[v]的点
int minimumEffortPath(vector<vector<int>>& heights) {
memset(visited,0,sizeof(visited));
int n = heights.size(), m = heights[0].size(), i, j, cnt = 0, w, v, o = n * m - 1, index;
priority_queue<Dist> pri_que;
Dist dist;
pri_que.push(Dist{0, 0, 0});
while(!pri_que.empty()){
dist = pri_que.top();
pri_que.pop();
i = dist.i, j = dist.j, w = dist.w;
visited[i][j] = true;
if(i == n - 1 && j == m - 1) return w;
if(i > 0 && !visited[i - 1][j]){
pri_que.push(Dist{i - 1, j, max(w, abs(heights[i][j] - heights[i - 1][j]) )});
}
if(i + 1 < n && !visited[i + 1][j]){
pri_que.push(Dist{i + 1, j, max(w, abs(heights[i][j] - heights[i + 1][j]) )});
}
if(j > 0 && !visited[i][j - 1]){
pri_que.push(Dist{i, j - 1, max(w, abs(heights[i][j] - heights[i][j - 1]) )});
}
if(j + 1 < m && !visited[i][j + 1]){
pri_que.push(Dist{i, j + 1, max(w, abs(heights[i][j] - heights[i][j + 1]) )});
}
}
return 0;
}
};