1631 最小体力消耗路径
题目描述：
你准备参加一场远足活动。给你一个二维 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.length
columns == heights[i].length
1 <= rows, columns <= 100
1 <= heights[i][j] <= 106
方法1：
主要思路：
（1）二分查找+dfs；
（2）将可能的体力值的范围作为二分查找的范围，找出其中的中间值，作为当前判断从左上角到右下角的可行路径的标准值；
（3）若在当前的中间值下，不存在可能的路径，则说明需要更大的中间值，故调整左边界， 既left=mid+1，若能到达右下角，则说明可能存在更小的值，则更新右边界， 既right=mid;
class Solution {
public:
const int step[4][2]={
{
1,0},{
-1,0},{
0,1},{
0,-1}};//每次前进的步骤
int minimumEffortPath(vector<vector<int>>& heights) {
//确定的初始的二分范围
int left=0;
int right=999999;
while(left<right){
//二分搜索
//标识访问过的路径
vector<vector<bool>> sign(heights.size(),vector<bool>(heights[0].size(),false));
//当前的体力中间值
int mid=left+(right-left)/2;
if(dfs(heights,sign,mid,0,0)){
//深度搜索，判断当前中间值下，是否可能到达右下角
right=mid;
}
else{
left=mid+1;
}
}
//返回
return left;
}
//深度搜索
bool dfs(vector<vector<int>>& heights,vector<vector<bool>>& sign,int& mid,int x,int y){
if(x==sign.size()-1&&y==sign[0].size()-1){
//说明到达了右下角，直接返回true
return true;
}
sign[x][y]=true;//标识当前访问过的路径
//可能前进的方向
for(int i=0;i<4;++i){
//当期可能踏出的下一步
int cur_x=x+step[i][0];
int cur_y=y+step[i][1];
//前四个条件满足该位置有效，第五个条件保证当前点之前没有访问过，第六个条件保证两点之间满足体力值要求
if(cur_x>=0&&cur_x<sign.size()&&cur_y>=0&&cur_y<sign[0].size()&&!sign[cur_x][cur_y]&&(abs(heights[x][y]-heights[cur_x][cur_y])<=mid)){
if(dfs(heights,sign,mid,cur_x,cur_y)){
//在新的位置进行深度搜索
return true;
}
}
}
return false;//跳出循环，说明不能到达右下角
}
};
方法2：
主要思路：
（1）二分查找+bfs;
（2）和方法1的主要差异点是将深度搜索变换成了广度搜索；
class Solution {
public:
int minimumEffortPath(vector<vector<int>>& heights) {
//确定的初始的二分范围
int left=0;
int right=999999;
const int step[4][2]={
{
1,0},{
-1,0},{
0,1},{
0,-1}};//每次前进的步骤
while(left<right){
//二分搜索
queue<pair<int,int>> q;//存储广度路径
q.push({
0,0});
//标识访问过的路径
vector<vector<bool>> sign(heights.size(),vector<bool>(heights[0].size(),false));
sign[0][0]=true;
//当前的体力中间值
int mid=left+(right-left)/2;
while(!q.empty()){
pair<int,int> cur_p=q.front();
q.pop();
for(int i=0;i<4;++i){
int cur_x=cur_p.first+step[i][0];
int cur_y=cur_p.second+step[i][1];
if(cur_x>=0&&cur_x<sign.size()&&cur_y>=0&&cur_y<sign[0].size()&&!sign[cur_x][cur_y]&&abs(heights[cur_p.first][cur_p.second]-heights[cur_x][cur_y])<=mid){
q.push({
cur_x,cur_y});//存储广度路径
sign[cur_x][cur_y]=true;//标识
}
}
}
//更新范围
if(sign.back().back()){
right=mid;
}
else{
left=mid+1;
}
}
//返回
return left;
}
};