LeetCode 1631. 最小体力消耗路径

最新推荐文章于 2024-07-23 21:16:02 发布

可达鸭丶

最新推荐文章于 2024-07-23 21:16:02 发布

阅读量392

点赞数

CC 4.0 BY-SA版权

文章标签： dfs java leetcode

本文链接：https://blog.csdn.net/qq_20067165/article/details/113371487

这篇博客介绍了两种方法来解决寻找二维数组中从左上角到右下角的最小体力消耗路径问题。第一种方法是通过并查集，将所有边按代价排序，依次尝试连接，直到找到联通(0,0)和(m-1,n-1)的最小代价边。第二种方法是采用二分查找，通过深度优先搜索判断在一定体力消耗下能否从起点到达终点，逐步调整体力值找到最小值。这两种方法都巧妙地利用了数据结构和算法来优化问题的求解过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java两种方法击败50% -> 100%！

并查集

将所有边从小到大排序，每次拿一条边连接两点，然后判断一下 $(0, 0)$ 和 $(m - 1, n - 1)$ 是否联通，若联通这次加入的边就是最小体力消耗。

class Solution {
    int[] p;
    int[][] edges;
    int m, n, N, len;
    int find(int u){
        if(p[u] != u) p[u] = find(p[u]);
        return p[u];
    }
    public int minimumEffortPath(int[][] heights) {
        int m = heights.length, n = heights[0].length;
        N = m * n;
        p = new int[N];
        for(int i = 0; i < N; i++) p[i] = i;
        len = 2 * N - (m + n);
        edges = new int[len][3];
        int k = 0;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(i > 0){
                    edges[k][0] = (i - 1) * n + j;
                    edges[k][1] = i * n + j;
                    edges[k++][2] = Math.abs(heights[i][j] - heights[i - 1][j]);
                }
                if(j > 0){
                    edges[k][0] = i * n + j - 1;
                    edges[k][1] = i * n + j;
                    edges[k++][2] = Math.abs(heights[i][j] - heights[i][j - 1]);
                }
            }
        }
        Arrays.sort(edges, (x, y) -> x[2] - y[2]);
        for(int i = 0; i < len; i++){
            int rootA = find(edges[i][0]), rootB = find(edges[i][1]);
            if(rootA != rootB){
                p[rootA] = rootB;
            }
            if(find(0) == find(N - 1)) return edges[i][2];
        }
        return 0;
    }
}

二分法

非常秀的方法，写了一个深搜版本的，高度值从 $1 - 10^6$ ，体力消耗也是在这个范围内，每次取中间值判断一下不超过这个体力消耗能不能从左上到右下，如果能，就缩小体力，如果不能就增大体力，直到找到一个最小值。

class Solution {
    int m, n;
    int[][] heights;
    int[] dx = {0, 1, 0, -1}, dy = {1, 0, -1, 0};
    boolean[][] visit;
    boolean dfs(int x, int y, int len){
        visit[x][y] = true;
        if(x == m - 1 && y == n - 1) return true;
        int flag = 0;
        for(int i = 0; i < 4; i++){
            int xx = x + dx[i], yy = y + dy[i];
            if(xx >= 0 && xx < m && yy >= 0 && yy < n && !visit[xx][yy] && Math.abs(heights[xx][yy] - heights[x][y]) <= len && dfs(xx, yy, len))
                return true;
            else flag++;
        }
        if(flag == 4) return false;
        else return true;
    }
    public int minimumEffortPath(int[][] heights) {
        m = heights.length; n = heights[0].length;
        this.heights = heights;
        visit = new boolean[m][n];
        int l = 0, r = 1000010;
        while(l < r){
            int mid = l + r >> 1;
            for(boolean[] v : visit) Arrays.fill(v, false);
            if(dfs(0, 0, mid)) r = mid;
            else l = mid + 1;
        }
        return l;
    }
}