算法练习帖--66--最小体力消耗路径(Java)

最小体力消耗路径(Java)

一、题目简介

你准备参加一场远足活动。给你一个二维 rows x columns 的地图 heights ，其中 heights[row][col] 表示格子 (row, col) 的高度。一开始你在最左上角的格子 (0, 0) ，且你希望去最右下角的格子 (rows-1, columns-1) （注意下标从 0 开始编号）。你每次可以往 上，下，左，右 四个方向之一移动，你想要找到耗费 体力 最小的一条路径。

一条路径耗费的 体力值 是路径上相邻格子之间 高度差绝对值 的 最大值 决定的。

请你返回从左上角走到右下角的最小 体力消耗值 。
(题目来源：力扣（LeetCode）)
示例 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. 二分+bfs(官方题解)

package com.lxf.test3;import java.util.LinkedList;
import java.util.Queue;class Solution {int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};public int minimumEffortPath(int[][] heights) {int m = heights.length;//行数int n = heights[0].length;//列数//因为1=<heights[i][j]<=1000000,所以体力消耗值最小值在0-999999中//所以我们在这区间二分查找就可以了int left = 0, right = 999999, ans = 0;while (left <= right) {//当left==right时，left和right和mid都是最小体力消耗值int mid = (left + right) / 2;//取中间值Queue<int[]> queue = new LinkedList<int[]>();//加入初始点queue.offer(new int[]{0, 0});//记录当前顶点是否被访问boolean[] seen = new boolean[m * n];seen[0] = true;//bfs遍历整张图，把体力消耗值<=mid的全部走一边while (!queue.isEmpty()) {int[] cell = queue.poll();//取出当前点坐标int x = cell[0], y = cell[1];for (int i = 0; i < 4; ++i) {//将当前顶点的上下左右顶点遍历int nx = x + dirs[i][0];int ny = y + dirs[i][1];//如果上下左右顶点没越界，并且体力消耗值<=mid//我们就走这个点，并标志为已访问过if (nx >= 0 && nx < m && ny >= 0 && ny < n && !seen[nx * n + ny] && Math.abs(heights[x][y] - heights[nx][ny]) <= mid) {queue.offer(new int[]{nx, ny});seen[nx * n + ny] = true;}}}//遍历完图之后判断最后一个顶点访问过没有if (seen[m * n - 1]) {//访问到了，说明最小体力消耗值在当前区间mid中点的左区间ans = mid;right = mid - 1;} else {//没有访问到了，说明最小体力消耗值在当前区间mid中点的右区间left = mid + 1;}}return ans;}
}

2. 并查集+克鲁斯卡尔算法（参照官方题解）

package com.lxf.bfs;import java.util.PriorityQueue;public class MinimumEffortPath {public static void main(String[] args) {MinimumEffortPath m = new MinimumEffortPath();m.minimumEffortPath(new int[][]{{1,2,2},{3,8,2},{5,3,5}});}int[] parent;int[] rank;public int minimumEffortPath(int[][] heights) {int row=heights.length;int col=heights[0].length;parent=new int[row*col];//父结点数组rank=new int[row*col];//秩结点数组//数组存储两个结点和两结点的权值，并用小根堆存储PriorityQueue<int[]> pq = new PriorityQueue<>((arr1, arr2) -> arr1[2] - arr2[2]);for (int i = 0; i < row; i++) {for (int j = 0; j < col; j++) {//二维数组一维化int index=i*col+j;parent[index]=index;//父结点数组初始化//将当前结点的上和左结点移动到当前结点的体力值记录到数组中，并存储到小根堆if(i>0){pq.offer(new int[]{index-col,index,Math.abs(heights[i][j]-heights[i-1][j])});}if(j>0){pq.offer(new int[]{index-1,index,Math.abs(heights[i][j]-heights[i][j-1])});}}}int min=0;//最小体力值while(!pq.isEmpty()){//依次取出小根堆中的值，也就是已经从体力值最小一直取int[] nums = pq.poll();//合并结点union(nums[0],nums[1]);if(find(0)==find(row*col-1)){//如果开始结点和最后结点相通，说明已经连通了，当前体力值就是最小花费体力值min=nums[2];break;}}return min;}/*** 查找父结点方法* @param index* @return*/public int find(int index){while(index!=parent[index]){parent[index]=parent[parent[index]];index=parent[index];}return index;}/*** 合并集合方法* @param index1* @param index2*/public void union(int index1,int index2){int root1=find(index1);int root2=find(index2);if(root1==root2){return;}if(rank[root1]>rank[root2]){parent[root2]=root1;}else if(rank[root1]<rank[root2]){parent[root1]=root2;}else{parent[root2]=root1;rank[root1]++;}}
}

3. 迪杰斯特拉算法(官方题解)

package com.lxf.dijstra;import java.util.Arrays;
import java.util.PriorityQueue;public class MinimumEffortPath {//方向计算数组：上右下左int[][] dirs=new int[][]{{-1,0},{0,1},{1,0},{0,-1}};public int minimumEffortPath(int[][] heights) {int row=heights.length;//heights数组行int col=heights[0].length;//heights数组列int length=row*col;//heights数组用一维数组存储的长度//存储从(0,0)顶点到当前顶点所需要花费的最小体力值数组int[] dists = new int[length];//设置数组初始值为int的最大值Arrays.fill(dists,Integer.MAX_VALUE);//设置起点最小体力值为0dists[0]=0;//记录顶点是否访问过的数组boolean[] visited = new boolean[length];//存储边的优先队列PriorityQueue<int[]> pq = new PriorityQueue<>((arr1, arr2) -> arr1[2] - arr2[2]);pq.offer(new int[]{0,0,0});//添加起始数组while (!pq.isEmpty()) {int[] poll = pq.poll();int x = poll[0], y = poll[1], d = poll[2];//当前顶点的一维坐标int index=x*col+y;if(visited[index]){//如果当前顶点已经访问过，直接取下一个顶点continue;}visited[index]=true;//标记当前下标已被访问if(index==length-1){//如果到达了最后顶点，直接跳出循环break;}for (int i = 0; i < dirs.length; i++) {int nx=x+dirs[i][0];int ny=y+dirs[i][1];if(nx>=0&&ny>=0&&nx<row&&ny<col&&Math.max(d,Math.abs(heights[nx][ny]-heights[x][y]))<dists[nx*col+ny]){//当向上右下左走一个顶点，并且走完这个顶点花费的体力值要比其它路径花费的小//更新结点的体力值，并将结点加入队列dists[nx*col+ny]=Math.max(d,Math.abs(heights[nx][ny]-heights[x][y]));pq.offer(new int[]{nx,ny,dists[nx*col+ny]});}}}return dists[length-1];}
}