每日一题——1631. 最小体力消耗路径

最新推荐文章于 2024-07-15 17:09:23 发布

vwmin

最新推荐文章于 2024-07-15 17:09:23 发布

阅读量173

点赞数

分类专栏： LeetCode 文章标签：图论 leetcode

本文链接：https://blog.csdn.net/weixin_42955230/article/details/113373739

版权

LeetCode 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

1631. 最小体力消耗路径

分类：并查集、二分答案、最短路

并查集思路类似于Kruskal，将所有的路径看成边，边的权值就是高度差，边按照高度差排序，挨个连接，最后一个使左上和右下连通的边的权值就是最小高度差

class UnionFind{
private:
    vector<int> u;
    vector<int> sz;
public:
    int member;
    UnionFind(int n):member(n), u(n), sz(n, 1){
        iota(u.begin(), u.end(), 0);
    }
    int root(int i){
        return u[i] == i ? i : u[i] = root(u[i]);
    }
    bool connect(int i, int j){
        int ri = root(i), rj = root(j);
        if(ri == rj){
            return false;
        }
        if(sz[ri] < sz[rj]){
            swap(ri, rj);
        }
        u[rj] = ri;
        sz[ri] += sz[rj];
        member--; 
        return true;
    }
    bool isConnected(int i, int j){
        return root(i) == root(j);
    }
};
class Solution {
public:
    struct edge{
        int p1, p2, v;
        edge(int p1, int p2, int v):p1(p1),p2(p2),v(v){}
        bool operator < (const edge& other){
            return v < other.v;
        }
    };
    int minimumEffortPath(vector<vector<int>>& heights) {
        int n = heights.size(), m = heights[0].size();
        vector<edge> edges;
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                int p1 = i*m+j;
                if(i+1 < n)
                    edges.push_back(edge(p1, p1+m, abs(heights[i][j]-heights[i+1][j])));
                if(j+1 < m)
                    edges.push_back(edge(p1, p1+1, abs(heights[i][j]-heights[i][j+1])));
            }
        }
        sort(edges.begin(), edges.end());
        UnionFind u(n*m);
        for(int i=0; i<edges.size(); i++){
            u.connect(edges[i].p1, edges[i].p2);
            if(u.isConnected(0, n*m-1))
                return edges[i].v;
        }
        return 0;
    }
};

二分答案思路；界定左右两个区间，如果左区间内能够使连通，则将左区间再次划分为两个区间，如果不能，则到右区间搜索。最后一个成功的区间即为答案。搜索可用bfs、dfs

class Solution {
public:
    int mv[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    int minimumEffortPath(vector<vector<int>>& heights) {
        int n = heights.size(), m = heights[0].size();
        int left = 0, right = 1e6, ans=0;
        while(left <= right){
            int mid = (left+right) >> 1;
            queue<pair<int, int>> q;
            q.emplace(0, 0);
            vector<bool> vis(n*m);
            vis[0] = true;
            while(!q.empty()){
                pair<int, int> cur = q.front(); q.pop();
                for(int i=0; i<4; i++){
                    int x = cur.first + mv[i][0];
                    int y = cur.second + mv[i][1];
                    if(x<n&& y<m && x>-1 && y>-1 && !vis[x*m+y] && 
                        abs(heights[cur.first][cur.second]-heights[x][y])<=mid){
                        q.emplace(x, y);
                        vis[x*m+y]=true;
                    }
                }
            }
            if(vis[n*m-1]){
                ans=mid;
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        return mid;
    }
};