leetcode 120 三角形最小路径

给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。

相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。

例如，给定三角形：

[
[2],
[3,4],
[6,5,7],
[4,1,8,3]
]
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

注意：既然是一条通路，那么就应该想到是既可以自底向上，也可以自顶向下。
自顶向下，从右往左，使用O(N)的空间

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int[] dp=new int[triangle.get(triangle.size()-1).size()];
        dp[0]=triangle.get(0).get(0);
        for(int i=1;i<triangle.size();i++){
            List<Integer> now=triangle.get(i);
            for(int j=now.size()-1;j>=0;j--){
                    if(j==0) dp[j]+=now.get(0);
                    else{
                        List<Integer> pre=triangle.get(i-1);
                        if(j==pre.size())
                            dp[j]=now.get(j)+dp[j-1];
                        else
                            dp[j]=now.get(j)+Math.min(dp[j],dp[j-1]);
                    } 
            }
        }
        int ans=0x7fffffff;
        for(int i=0;i<dp.length;i++)
            ans=ans>dp[i]?dp[i]:ans;
        return ans;
    }
}

自底向下，思路清晰，但是空间使用了O(n*n)

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int n=triangle.get(triangle.size()-1).size();
        int[][] dp=new int[n+1][n+1];
        for(int i=n-1;i>=0;i--){
            List<Integer> temp=triangle.get(i);
            for(int j=0;j<temp.size();j++){
                dp[i][j]=Math.min(dp[i+1][j],dp[i+1][j+1])+temp.get(j);
            }
        }
        return dp[0][0];
    }
}

使用O(n)空间，

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        //自底向上递推
        int n=triangle.get(triangle.size()-1).size();
        int[] dp=new int[n];

        for(int i=0;i<n;i++) dp[i]=triangle.get(triangle.size()-1).get(i);

        for(int i=triangle.size()-2;i>=0;i--){
            List<Integer> temp=triangle.get(i);
            for(int j=0;j<temp.size();j++){
                dp[j]=Math.min(dp[j],dp[j+1])+temp.get(j);
            }
        }
        return dp[0];
    }
}

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        //自底向上递推，从左往右，
        //只使用 O(n) 的额外空间
        int n=triangle.get(triangle.size()-1).size();
        int[] dp=new int[n+1];

        //for(int i=0;i<n;i++) dp[i]=triangle.get(triangle.size()-1).get(i);

        for(int i=triangle.size()-1;i>=0;i--){
            List<Integer> temp=triangle.get(i);
            for(int j=0;j<temp.size();j++){
                dp[j]=Math.min(dp[j],dp[j+1])+temp.get(j);
            }
        }
        return dp[0];
    }
}