leetcode120. 三角形最小路径和

120. 三角形最小路径和

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

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

例如，给定三角形：

[
     [2],
    [3,4],
   [6,5,7],
  [4,1,8,3]
]

自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

说明：

如果你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题，那么你的算法会很加分。

解题思路

• 注意：题目“出错”了：
  题中相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。
  实际上是相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 - 1 的两个结点。
  我理解的“上层”是横坐标小的那一个

  题给案例可行进路线如下图所示：
  

从上至下-动态规划

• 状态转移方程dp[i,j] = min(dp[i-1,j-1],dp[i-1,j]) + triangle[i][j]表示(i,j)位置的最小路径和

//求三角形最小路径和
//动态规划
class Solution {
public:
    //状态转移方程dp[i,j] = min(dp[i-1,j-1],dp[i-1,j]) + triangle[i][j]
    int minimumTotal(vector<vector<int>>& triangle) {
        if(triangle.size()==0)
            return 0;
        if(triangle.size()==1)
            return triangle[0][0];
            
        int n = triangle.size();
        int m = triangle[n-1].size();
        
        vector<vector<int> > dp(n,vector<int>(m,0));
        //初始化dp[0][0]
        dp[0][0] = triangle[0][0];
        int minPath = 0x7f7f7f;
        //dp从第1行开始
        for(int i=1; i<n; ++i){
            for(int j=0; j<triangle[i].size(); ++j){
                if(j==0)
                    dp[i][j] = dp[i-1][j] + triangle[i][j];
                else if(j==triangle[i].size()-1)
                    dp[i][j] = dp[i-1][j-1] + triangle[i][j];
                else 
                    dp[i][j] = min(dp[i-1][j-1], dp[i-1][j]) + triangle[i][j];
                if(i==n-1 && dp[i][j]<minPath)
                    minPath = dp[i][j];
            }
        }
        
        return minPath;
    }
};

执行用时：8 ms, 在所有 C++ 提交中击败了93.12% 的用户
内存消耗：8.6 MB, 在所有 C++ 提交中击败了28.07% 的用户

从上至下-就地规划

不额外创建dp数组

//求三角形最小路径和
//动态规划
class Solution {
public:
    //状态转移方程dp[i,j] = min(dp[i-1,j-1],dp[i-1,j]) + triangle[i][j]
    int minimumTotal(vector<vector<int>>& triangle) {
        if(triangle.size()==0)
            return 0;
        if(triangle.size()==1)
            return triangle[0][0];
    
        int minPath = 0x7f7f7f;
        //dp从第1行开始
        for(int i=1; i<triangle.size(); ++i){
            for(int j=0; j<triangle[i].size(); ++j){
                if(j==0)
                    triangle[i][j] += triangle[i-1][j];
                else if(j==triangle[i].size()-1)
                    triangle[i][j] += triangle[i-1][j-1];
                else 
                    triangle[i][j] += min(triangle[i-1][j-1], triangle[i-1][j]);
                if(i==triangle.size()-1 && triangle[i][j]<minPath)
                    minPath = triangle[i][j];
            }
        }
        
        return minPath;
    }
};

执行用时：8 ms, 在所有 C++ 提交中击败了93.12% 的用户
内存消耗：8.2 MB, 在所有 C++ 提交中击败了88.26% 的用户

从下至上-就地规划

class Solution {
public:
    //状态转移方程dp[i,j] = min(dp[i-1,j],dp[i-1,j-1])
    int minimumTotal(vector<vector<int>>& triangle) {
        if(triangle.size()==0)
            return 0;

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

执行用时：8 ms, 在所有 C++ 提交中击败了93.12% 的用户
内存消耗：8.3 MB, 在所有 C++ 提交中击败了67.16% 的用户