LeetCode120—Triangle

LeetCode120—Triangle

原题

https://leetcode.com/problems/triangle/

Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.

For example, given the following triangle
[
[2],
[3,4],
[6,5,7],
[4,1,8,3]
]
The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).

分析1

这里最简单的思路是二维动态规划，对于一个第i行第j列的元素来说，到该元素最短路径的上一步，可以是第i-1行第j列的元素，也可以是第i-1行第j+1列的元素（这里我们要考虑边界条件）。
如果dp[i][j]表示到第i行第j列元素的最短路径。
那么动归方程可以简单的这么写：
$dp[i][j]=min(dp[i-1][j],dp[i-1][j-1])+triangle[i][j] \tag{1}$

代码1

根据上述方程写出代码，不过要注意两点：
1. 考虑边界条件
2. 最后一行循环一次取最小值

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int len = triangle.size();
        vector<vector<int>>dp(len, vector<int>(len));
        if (0 == len)
            return 0;
        dp[0][0] = triangle[0][0];
        for (int i = 1; i < len; i++)
        {
            for (int j = 0; j < i + 1; j++)
            {
                if (j>0 && j != i)
                    dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - 1]) + triangle[i][j];
                else if (j == i)//右边界
                    dp[i][j] = dp[i - 1][j - 1] + triangle[i][j];
                else//左边界
                    dp[i][j] = dp[i - 1][j] + triangle[i][j];
            }
        }
        int minVal = dp[len - 1][0];//取最小值
        for (int i = 1; i < len; i++)
        {
            if (dp[len - 1][i] < minVal)
                minVal = dp[len - 1][i];
        }
        return minVal;
    }
};

分析2

依然是二维数组的动态规划，不过我们可以从底往上，这样，对于第i行第j列的元素来说，到该元素的最短路径的上一步可以来自第i+1行第j列或者是第i+1行第j+1列，这种情况不必考虑边界情况，因为第i+1行总是比第i行多1个元素。

如果dp[i][j]表示到第i行第j列元素的最短路径。
那么动归方程可以简单的这么写：
$dp[i][j]=min(dp[i+1][j],dp[i+1][j+1])+triangle[i][j] \tag{2}$

代码2

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int len = triangle.size();
        vector<vector<int>>dp(len, vector<int>(len));
        if (0 == len)
            return 0;
        for (int i = 0; i < len; i++)
            dp[len - 1][i] = triangle[len - 1][i];
        for (int i = len - 2; i >= 0; i--)//自底向上
        {
            for (int j = 0; j < i + 1; j++)
            {
                dp[i][j] = min(dp[i + 1][j], dp[i + 1][j + 1]) + triangle[i][j];
            }
        }
        return dp[0][0];
    }
};

分析3

这就是参考了网上大神的思路了。http://blog.csdn.net/linhuanmars/article/details/23230657
也分为自顶向下和自底向上两种情况，同样的自顶向下要考虑边界条件。
这种方法只用到$O(n)$的空间复杂度。

代码3

//自顶向下
class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int len = triangle.size();
        if (0 == len)
            return 0;
        vector<int>dp(len);
        dp[0] = triangle[0][0];
        for (int i = 1; i < len; i++)
        {
            //dp[i] = dp[i - 1] + triangle[i][i];
            for (int j = i; j >= 0; j--)//这里需要从后往前
            {
                if (0 == j)
                    dp[j] = dp[j] + triangle[i][j];
                else  if (i == j)
                    dp[j] = dp[j - 1] + triangle[i][j];
                else
                    dp[j] = min(dp[j], dp[j - 1]) + triangle[i][j];//dp[j]->上一层右侧,dp[j-1]上一层左侧
            }
        }
        int minVal = dp[0];
        for (int i = 0; i < dp.size(); i++)
        {
            if (dp[i] < minVal)
                minVal = dp[i];
        }
        return minVal;
    }
};

代码4

//自底向上
class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int len = triangle.size();
        vector<vector<int>>dp(len, vector<int>(len));
        if (0 == len)
            return 0;
        for (int i = 0; i < len; i++)
            dp[len - 1][i] = triangle[len - 1][i];
        for (int i = len - 2; i >= 0; i--)
        {
            for (int j = 0; j < i + 1; j++)
            {
                dp[i][j] = min(dp[i + 1][j], dp[i + 1][j + 1]) + triangle[i][j];
            }
        }
        return dp[0][0];
    }
};