leetcode Triangle

最新推荐文章于 2020-05-23 10:06:18 发布

原创最新推荐文章于 2020-05-23 10:06:18 发布 · 266 阅读

0 ·

CC 4.0 BY-SA版权

leetcode Fighting 专栏收录该内容

133 篇文章

订阅专栏

本文探讨了寻找三角形路径中最小和的问题，通过递归方法引入并解决了其存在的重复计算问题，最终采用动态规划实现了高效解决方案。

刚开始的想法是从第一层开始，每次累加下一层中与上一层选定数相邻两个数中的较小者，此方法有问题，例如

因此，利用递归算法，从下往上，计算从第 i 层第 j 个元素起始地最小和，可以通过求第 i+1 层第 j 个与第 j+1 个为起始点的最小和，两者取较小者小并与第 i 层第 j 个元素相加。

代码-- 超时

class Solution
{

	int minimumTotal(vector<vector<int> > &triangle)
	{

		return minimumTotalHelper(triangle, 0, 0);

	}

	int minimumTotalHelper(vector<vector<int> > &triangle, int i, int j)
	{
		if(i==triangle.size()-1)
			return triangle[i][j];

		int left = minimumTotalHelper(triangle, i+1, j);
		int right = minimumTotalHelper(triangle, i+1, j+1);

		return min(left, right)+triangle[i][j];	
	
	
	}
};

大数据时提示超时。

因为每次递归中重复计算了很多数值，此时很自然想到动态规划，开辟空间记录中间结果。

方法：从下往上，开辟数组与计算最小值同时进行

代码--Accepted

class Solution
{
public:
	int minimumTotal(vector<vector<int> > &triangle)
	{
		int **dp;
		int row = triangle.size();
		int col = triangle[row-1].size();
		dp = new int *[row];
		for(int i = row-1; i >= 0; --i)
		{
			dp[i] = new int[col];
			for(int j = 0; j < col; ++j)
			{
				if(i==row-1)
					dp[i][j] = triangle[i][j];
				else
					dp[i][j] = min(dp[i+1][j], dp[i+1][j+1])+triangle[i][j];

			}
		}

		return dp[0][0];		
	
	}	

};

此时，空间复杂度为O(n^2). 分析可知，程序从下往上从左往右执行，每次计算当前层的值只用下方一行的数值，且当前层按照从左往右顺序，因此开辟一维数组即可。

代码--Accepted

class Solution
{
public:
	int minimumTotal(vector<vector<int> > &triangle)
	{
		int *dp;
		int row = triangle.size();
		int col = triangle[row-1].size();
		dp = new int[col];
		for(int i = row-1; i >= 0; --i)
		{
			for(int j = 0; j < col; ++j)
			{
				if(i==row-1)
					dp[j] = triangle[i][j];
				else
					dp[j] = min(dp[j], dp[j+1])+triangle[i][j];

			}
		}

		return dp[0];		
	
	}	

};