Leetcode 120. Triangle

最新推荐文章于 2021-07-15 12:02:02 发布

GoodJobJasper

最新推荐文章于 2021-07-15 12:02:02 发布

阅读量118

点赞数

分类专栏： Leetcode 文章标签： dfs backtracking dp

本文链接：https://blog.csdn.net/GoodJobJasper/article/details/113362682

版权

Leetcode 专栏收录该内容

278 篇文章 0 订阅

订阅专栏

这篇博客介绍了三种不同的算法来解决寻找三角形中从顶点到底部的最小路径和问题。方法1使用深度优先搜索（DFS），但没有使用记忆化，可能导致超时；方法2通过记忆化改进DFS，降低时间复杂度到线性；方法3采用动态规划（DP）进一步优化，空间复杂度减至常数。每种方法的时间和空间复杂度都进行了详细分析。

摘要由CSDN通过智能技术生成

在这里插入图片描述

方法1: dfs，can’t memo，cause tle。时间复杂2n，n为node数。空间复杂1.

class Solution {
    List<List<Integer>> triangle;
    int min = Integer.MAX_VALUE;
    public int minimumTotal(List<List<Integer>> triangles) {
        this.triangle = triangles;
        int pathLen = 0;
        dfs(0, 0, pathLen);
        return min;
    }
    
    public void dfs(int i, int j, int pathLen){
        if(i == triangle.size()){
            min = Math.min(min, pathLen);
            return;
        }
        if(i > triangle.size() || j >= triangle.get(i).size()) return;
        pathLen += triangle.get(i).get(j);
        dfs(i + 1, j, pathLen);
        dfs(i + 1, j + 1, pathLen);
    }
}

方法2: ：改变方法1中的dfs返回值，使其返回当前最短路径值，这样我们就可以用memoization技术了。时间复杂n，空间复杂n。

class Solution {
    List<List<Integer>> triangle;
    Map<Pair<Integer, Integer>, Integer> map = new HashMap<>();
    public int minimumTotal(List<List<Integer>> triangles) {
        this.triangle = triangles;
        return dfs(0, 0);
    }
    
    public int dfs(int i, int j){
        if(map.containsKey(new Pair<>(i, j))) 
            return map.get(new Pair<>(i, j));
        if(i >= triangle.size() || j >= triangle.get(i).size()) 
            return 0;
        int res = 0;
        res = triangle.get(i).get(j) + Math.min(dfs(i+1, j), dfs(i+1, j+1));
        map.put(new Pair<>(i, j), res);
        return res;
    }
}

方法3: dp。时间复杂n，空间复杂1。

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        for(int i = 1; i < triangle.size(); i++){
            for(int j = 0; j < triangle.get(i).size(); j++){
                int curr = triangle.get(i).get(j);
                if(j - 1  >= 0 && j < triangle.get(i - 1).size()){
                    triangle.get(i).set(j, Math.min(curr + triangle.get(i - 1).get(j - 1), curr + triangle.get(i - 1).get(j)));
                }else if(j - 1  >= 0) {
                    triangle.get(i).set(j, curr + triangle.get(i - 1).get(j - 1));
                }else if(j < triangle.get(i - 1).size()){
                    triangle.get(i).set(j, curr + triangle.get(i - 1).get(j));
                }
            }
        }
        int res = Integer.MAX_VALUE;
        for(int i = 0; i < triangle.get(triangle.size() - 1).size(); i++){
            res = Math.min(res, triangle.get(triangle.size()-1).get(i));
        }
        return res;
    }
}