最小体力消耗路径（DFS+优化）

 该题我的第一思路比较简单，按照题目意思用dfs写即可，在搜索路径的同时计算相邻格子之间 高度差绝对值 的 最大值  ，到达终点之后比较得到最小体力消耗值 

class Solution {
public:
 int book[105][105] = { 0 };
    int nextt[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
    int ans;
    void dfs(vector<vector<int> >& heights, int x, int y, int n, int m, int maxn)
    {
        if (x == n - 1 && y == m - 1)//到达终点
        {
            ans = min(ans, maxn);
            return;
        }
        for (int i = 0; i < 4; i++)
        {
            int tx = x + nextt[i][0];
            int ty = y + nextt[i][1];
            if (tx < 0 || ty < 0 || tx == n || ty == m||book[tx][ty])//越界或者走过了
            {
                continue;
            }
            book[tx][ty] = 1;
            int sub = abs(heights[x][y] - heights[tx][ty]);//计算差值
            maxn = max(maxn, sub);//找最大
            dfs(heights, tx, ty, n, m, maxn);
            book[tx][ty] = 0;//记得恢复book
            maxn = -1;//注意由于使用max之后不能恢复，这里我直接重新赋值了
        }
    }
    int minimumEffortPath(vector<vector<int>>& heights) {
        int n = heights.size();
        int m = heights[0].size();
        if(n==1&&m==1)return 0;
        ans = 1000005;
        int maxn = -1;
        book[0][0] = 1;
        dfs(heights, 0, 0, n, m, maxn);
        return ans;
    }

};

该思路容易想到，不过并不能AC该题，因为超时了

之后看提示可以通过二分法结合搜索的方法来优化，不难想到题目要求的答案最小体力消耗值肯定是存在的，而且范围就在0和100000（1 <= heights[i][j] <= 106），
对这个范围做二分查找，看能否以二分的体力消耗值作为最小体力消耗值从起点走到终点，而判断从起点能否走到终点有两大思路，一是搜索（dfs和bfs），二是考察图的连通性可以用并查集

bool visit[101][101] = {0};

bool checkValid(int x, int y, int m, int n)//是否越界
{
    if ((x < 0) || (x >= m) || (y < 0) || (y >= n)) {
        return false;
    }
    return true;
}

bool isCanCrossBySpecValue(int maxPathCost, int **heights, int x, int y, int m, int n)
{
    if (x == m - 1 && y == n - 1) {//能够到达终点
        return true;
    }

    visit[x][y] = true;

    int dx[] = {-1, 1, 0, 0};
    int dy[] = {0, 0, -1, 1};
    int i = 0;
    for (; i < sizeof(dx) / sizeof(int); i++) {
        if ((!(checkValid(x + dx[i], y + dy[i], m, n))) || visit[x +dx[i]][y + dy[i]]) {
            continue;//越界或者走过了
        }
        if (abs(heights[x +dx[i]][y + dy[i]] - heights[x][y]) > maxPathCost) {
            continue;//不能满足<=最大体力消耗
        }
        if (isCanCrossBySpecValue(maxPathCost, heights, x + dx[i], y + dy[i], m, n)) {
            return true;
        }
    }

    return false;
}

int minimumEffortPath(int** heights, int heightsSize, int* heightsColSize)
{
    int m = heightsSize;
    int n = heightsColSize[0];
    int left = 0;
    int right = 1000000;
//看能否以二分的体力消耗值作为最小体力消耗值从起点走到终点
    while (left < right) {//二分寻找
        int mid = left + ((right - left) >> 1);
        memset(visit, 0, sizeof(visit));
        if (isCanCrossBySpecValue(mid, heights, 0, 0, m, n)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}