leetcode 1631. 最小体力消耗路径二分+BFS、并查集、Dijkstra算法

最小体力消耗路径

在这里插入图片描述
题目与水位上升的泳池中游泳类似

二分查找+BFS

首先，采用二分查找，确定一个体力值，再从左上角，进行BFS，查看能否到达右下角，如果不行，二分查找就往大的数字进行查找，如果可以，还要继续往小的数字进行查找，比如示例1，数字10肯定可以到达右下角，但不是最小的体力。

class Solution {
public:int dx[4] = { 0,0,-1,1 };int dy[4] = { -1,1,0,0 };int m, n;bool bfs(vector<vector<int>>& heights, vector<vector<int>> exist, int sub)//二分+BFS{exist[0][0] = 1;queue<pair<int, int>> q;q.emplace(0, 0);while (!q.empty()){auto [i, j] = q.front();q.pop();for (int k = 0; k < 4; ++k)//上下左右四个方向{int newi = i + dx[k];int newj = j + dy[k];if (newi >= 0 && newi < m && newj >= 0 && newj < n && !exist[newi][newj] && sub >= abs(heights[i][j] - heights[newi][newj])){exist[newi][newj] = 1;if (newi == m - 1 && newj == n - 1)//到达右下角{return true;}q.emplace(newi, newj);}}}return false;}int minimumEffortPath(vector<vector<int>>& heights){m = heights.size(), n = heights[0].size();vector<vector<int>> exist(m, vector<int>(n, 0));int begin = 0, end = 999999;//最大值，由题目给的边界值得出int result = 0;while (begin <= end){int mid = (begin + end) >> 1;if (bfs(heights, exist, mid)){result = mid;end = mid - 1;}else{begin = mid + 1;}}return result;}
};

二分+BFS一样适合于水位上升的题目。

二分+并查集
依然采用二分查找，确定一个值，只不过BFS换成了并查集

并查集：开辟一个数组，存储每个结点的父节点，当二分查找的某一个值，大于某两个点的差值，就将将其中一个点作为另外一个点的父节点，最后，如果可以到达右下角，那么，左上角的父节点就是右下角，此时，二分查找的值就可能是体力最小值。

这里用到了二维转一维

//并查集
class DSU
{
public:DSU(int n):parent(vector<int>(n, 0)){for (int i = 0; i < n; ++i)//父节点先初始化为自己{parent[i] = i;}}int Find(int pos){if (parent[pos] != pos)parent[pos] = Find(parent[pos]);//赋值为祖宗结点，减少搜索次数//return Find(parent[pos])parent[pos]为父节点return parent[pos];}void Union(int i, int j){parent[Find(i)] = Find(j);}bool check(int i, int j){return Find(i) == Find(j);}
private:vector<int> parent;
};class Solution {
public:int minimumEffortPath(vector<vector<int>>& heights){int m = heights.size(), n = heights[0].size();int result = 0;int begin = 0, end = 999999;//这里每次都得重新连接一遍，所以用二分，跟水池上升的游泳的题目相比while (begin <= end){int mid = (begin + end) >> 1;DSU dsu(m * n);//二维转一维for (int i = 0; i < m; ++i){for (int j = 0; j < n; ++j){if (i + 1 < m && abs(heights[i + 1][j] - heights[i][j]) <= mid)//下标方格可以到达{dsu.Union(i * n + j, (i + 1) * n + j);}if (j + 1 < n && abs(heights[i][j + 1] - heights[i][j]) <= mid)//右边方格可以到达{dsu.Union(i * n + j, i * n + j + 1);}}}if (dsu.check(0, m * n - 1)){result = mid;end = mid - 1;}else{begin = mid + 1;}}return result;}
};

在这里插入图片描述
相比水位上升的题目的并查集，这里的并查集并没有那么有趣，因为水位上升的题目的是采用从0遍历到最大值而不是二分查找，再对某一个值进行并查集。因为，由于水位上升的题目的数据是不重复的，所以可以采用哈希表记录每个值的位置，从0到最大值，只要在某个值，左上角和左下角已经连通，就是答案。比如示例一，分别使用哈希表的记录每个数字的位置，遍历水位，当水位为0时，没有可以连接的，但是水位为1时，可以连接0-》1，水位为2时，连接0-》2，水位为3时，连接1-》3，2-》3。如果这里采用二分的话，假如结果是10时，全部都被连通了，要往下查找更小的值的话，就要重新开辟parent数组。

如果，在最小体力消耗路径的题目依然采用遍历，而不是二分查找的话，虽然还是一个parent数组，当体力来到2，体力1可以连接的点已经连接好了，但是你还是避免不了两层循环遍历heights，查看哪里还可以连接，而不是像上面题目那样，直接哈希表确认2的位置，进行上下左右判断是否可以连接。

Dijkstra算法

开辟一个数组，记录源顶点（左上角）到达某一个点的最小体力
当来到一个新的顶点，消耗的体力比记载的小，就要存储起来，并且以这一个点为新起点，更新上下左右的体力值

//Dijkstra算法
class Solution {
public:int minimumEffortPath(vector<vector<int>>& heights){int m = heights.size(), n = heights[0].size();int INF = INT_MAX / 2;vector<int> dist(m * n, INF);//记录从源顶点，到达某个顶点的最小体力消耗dist[0] = 0;//顶点为0queue<tuple<int, int, int>> q;q.emplace(0, 0, 0);//分别表示最小体力差值，坐标while (!q.empty()){auto [physical, i, j] = q.front();q.pop();if (dist[i * n + j] < physical)//已经被处理过里，并且可以用更少的体力到达该位置continue;if (j + 1 < n){int nextPhysical = max(physical, abs(heights[i][j] - heights[i][j + 1]));//到达左边的方格需要的体力if (nextPhysical < dist[i * n + j + 1]){dist[i * n + j + 1] = nextPhysical;q.emplace(nextPhysical, i, j + 1);}}if (i + 1 < m){int nextPhysical = max(physical, abs(heights[i][j] - heights[i + 1][j]));//到达下边的方格需要的体力if (nextPhysical < dist[(i + 1) * n + j]){dist[(i + 1) * n + j] = nextPhysical;q.emplace(nextPhysical, i + 1, j);}}if (i - 1 >= 0){int nextPhysical = max(physical, abs(heights[i][j] - heights[i - 1][j]));//到达上边方格需要的体力if (nextPhysical < dist[(i - 1) * n + j]){dist[(i - 1) * n + j] = nextPhysical;q.emplace(nextPhysical, i - 1, j);}}if (j - 1 >= 0){int nextPhysical = max(physical, abs(heights[i][j] - heights[i][j - 1]));//到达左边方格需要的体力if (nextPhysical < dist[i * n + j - 1]){dist[i * n + j - 1] = nextPhysical;q.emplace(nextPhysical, i, j - 1);}}}return dist[m * n - 1];}
};