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](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](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];
}
};