Leetcode1631最小体力消耗路径--三种思路
Leetcode1634最小体力消耗路径
思路一、暴力(回溯法)
说明:此方法时间复杂度太大,不能通过测试,仅仅作为参考
class Solution {
public int minimumEffortPath(int[][] heights) {
m=heights.length;
n=heights[0].length;
visited=new int[m][n];
res=Integer.MAX_VALUE;
dfs(0,0,heights[0][0],0,heights);
return res;
}
//回溯法
void dfs(int x,int y,int lastNum,int curMax,int[][] heights) {
curMax=Math.max(Math.abs(heights[x][y]-lastNum),curMax);
if(x==m-1 && y==n-1) {
res=Math.min(res, curMax);
return;
}
for(int i=0;i<4;i++) {
if(x+dfsX[i]>=0 && x+dfsX[i]<m &&y+dfsY[i]>=0 && y+dfsY[i]<n && visited[x+dfsX[i]][y+dfsY[i]]==0) {
visited[x][y]=1;
dfs(x+dfsX[i],y+dfsY[i],heights[x][y],curMax,heights);
visited[x][y]=0;
}
}
return;
}
int res;
int[][] visited;
int m,n;
int[] dfsX=new int[] {
0,1,0,-1};
int[] dfsY=new int[] {
1,0,-1,0};
}
思路二、Dijkstra算法
众所周知，网格本身就是一张图,求图中两点间的最短距离dj算法首当其冲,虽然这种算法复杂度比较高，但是其通用性却是显而易见的。
代码在leetcode中刚好通过测试
class Solution {
public int minimumEffortPath(int[][] heights) {
//dj算法
int m=heights.length;
int n=heights[0].length;
int[] visited=new int[m*n];
int[] weight=new int[m*n];
for(int i=1;i<m*n;i++) {
weight[i]=Integer.MAX_VALUE;
}
//初始化权值
for(int i=1;i<m*n;i++) {
int minNode=0,min=Integer.MAX_VALUE;
//寻找最小边
for(int j=0;j<m*n;j++) {
if(visited[j]==0 && weight[j]<min) {
min=weight[j];
minNode=j;
}
}
if(minNode==m*n-1) break;
visited[minNode]=1;
//将结点化为2维坐标
int x=minNode/n;
int y=minNode%n;
//更新权值
for(int j=0;j<4;j++) {
int nextX=x+dfsX[j]; int nextY=y+dfsY[j];
if(nextX>=0 && nextX<m && nextY>=0 && nextY<n) {
int index=nextX*n+nextY;
if(visited[index]==1) continue;
int w=Math.abs(heights[x][y]-heights[nextX][nextY]);
w=Math.max(min, w);
weight[index]=Math.min(weight[index], w);
}
}
}
return weight[m*n-1];
}
int[] dfsX=new int[] {
0,1,0,-1};
int[] dfsY=new int[] {
1,0,-1,0};
}
思路三、贪心+并查集
说明:此思路是基于贪心+并查集解决的,想法很巧妙。我们首先将网格抽象成一张图，对于图的边的权值即为两节点间的体力值。我们可以将所有的边存入优先队列中，然会逐渐按权值从小到大合并边所对应的两个结点，直到起点和终点可以恰好连通，则让起点终点恰好连通的边的权即为消耗的最小体力值。
代码(代码摘录自leetcode官方):
class Solution {
public int minimumEffortPath(int[][] heights) {
int m = heights.length;
int n = heights[0].length;
List<int[]> edges = new ArrayList<int[]>();
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
int id = i * n + j;
if (i > 0) {
edges.add(new int[]{
id - n, id, Math.abs(heights[i][j] - heights[i - 1][j])});
}
if (j > 0) {
edges.add(new int[]{
id - 1, id, Math.abs(heights[i][j] - heights[i][j - 1])});
}
}
}
Collections.sort(edges, new Comparator<int[]>() {
public int compare(int[] edge1, int[] edge2) {
return edge1[2] - edge2[2];
}
});
UnionFind uf = new UnionFind(m * n);
int ans = 0;
for (int[] edge : edges) {
int x = edge[0], y = edge[1], v = edge[2];
uf.unite(x, y);
if (uf.connected(0, m * n - 1)) {
ans = v;
break;
}
}
return ans;
}
}
// 并查集模板
class UnionFind {
int[] parent;
int[] size;
int n;
// 当前连通分量数目
int setCount;
public UnionFind(int n) {
this.n = n;
this.setCount = n;
this.parent = new int[n];
this.size = new int[n];
Arrays.fill(size, 1);
for (int i = 0; i < n; ++i) {
parent[i] = i;
}
}
public int findset(int x) {
return parent[x] == x ? x : (parent[x] = findset(parent[x]));
}
public boolean unite(int x, int y) {
x = findset(x);
y = findset(y);
if (x == y) {
return false;
}
if (size[x] < size[y]) {
int temp = x;
x = y;
y = temp;
}
parent[y] = x;
size[x] += size[y];
--setCount;
return true;
}
public boolean connected(int x, int y) {
x = findset(x);
y = findset(y);
return x == y;
}
}