初级算法之动态规划

总结：动态规划着重解决最优化问题，例如下列题目中给出的最大金额，最大子序和等等。动态规划关键在于将一个问题分解为子问题，通过递推方程自底向上进而得到整个问题的最优解。例如题目1和题目4中将问题分解为了到达i元素时可以获得的最大值，然后一步一步根据递推式求得到达n元素时可以获得的最大值；又例如题目2和题目3将问题分解为了以i元素结尾时可以获得的最大值，然后通过比较这些值的大小来得到最终结果。所以总结一下可知动态规划的步骤：1.准确找到子问题2.确定递推方程3.确定方程最初的初始值。当确定不了递推方程的时候，可以举一些特殊的例子，根据特定例子去找递推式。

题目1：爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 阶 + 1 阶 + 1 阶
2.  1 阶 + 2 阶
3.  2 阶 + 1 阶

思路：使用动态规划的方法去思考这个问题，用count[i]来表示爬i阶的方法总数。因为每次都只能爬1阶或2阶，那么如果要爬到i阶就只能从i-1阶向上爬1阶或者是从i-2阶向上爬2阶，所以爬到i阶的方法总数其实就是爬到i-1阶的方法总数与爬到i-2阶的方法总数之和。 由此可以得到一个递推方程：count[i] = count[i-1]+count[i-2]，并且我们可以知道爬到1阶有1种方法，爬到2阶有2种方法，由这两个初始值count[1]和count[2]得到爬到n阶的方法总数。

int climbStairs(int n) 
{
	if(n==1)
	    return 1;
	if(n==2)
	    return 2;
	int count[n+1]; 
	count[1] = 1;   
	count[2] = 2;
	for(int i=3;i<n+1;i++)
	    count[i] = count[i-1]+count[i-2]; 
	return count[n];    
}

题目2：买卖股票的最佳时机

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

注意你不能在买入股票前卖出股票。

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。

示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

思路：用count[i]来表示以i天价格出售股票所能获得的最大利润数目。当遍历到第i天时，以当天价格减去前一天价格(prices[i]-prices[i-1])得到两天价格的差价，再用以i-1天价格出售能得到的最大利润(count[i-1])与之相加，所得到的就是以i天价格出售股票所能获得的最大利润，最后选出最大的count[i]，就是最大差价。但是要注意如果这个和小于0，则说明了在前i-1天，没有小于prices[i]的价格，所以无法用prices[i]出售，所以要给count[i]赋值0。

int maxProfit(vector<int>& prices) 
{
	int len = prices.size(); 
	if(len<=1)
	    return 0;
	int count[len];
	count[0] = 0;
	int maxProfit = count[0];
	for(int i=1;i<len;i++)
	{
	    count[i] = max(0,prices[i]-prices[i-1]+count[i-1]);
	    if(count[i]>maxProfit)
	        maxProfit = count[i];
	}	 
	return maxProfit;
}

题目3：最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

思路：用sum[i]表示以nums[i]结尾的子序所能得到的最大子序和，得到以nums[i]结尾的最大子序有两种可能：一种是将nums[i]加到nums[i-1]结尾的最大子序上形成一个新子序；一种是nums[i]本身自成一个子序。所以当遍历到第i个元素时，将把nums[i]加到以nums[i-1]结尾的最大子序上所形成新的以nums[i]为结尾子序的子序和同nums[i]本身作比较，将二者中的较大值赋给sum[i]，由此可以得到递推公式sum[i] = max(sum[i-1]+nums[i],nums[i])。并且可以知道以第一个数字为结尾的子序就是其本身，所以sum[0]就是nums[0]，由此可以推导得到所有sum[i]，选出其中最大值即为最大子序和。
举个例子，有一个数组nums为[-2,1,-3,4]:
1.当i=0时，能够形成的以nums[0]结尾的子序就是nums[0]本身，故sum[0]=nums[0]=-2,以nums[0]结尾的最大子序为[-2]；
2.当i=1时，将nums[1]添加到以nums[0]结尾的最大子序上形成的新子序为[-2,1]，此时的子序和为-1，如果nums[1]自身为一个子序[1]，那么子序和为1，所以以
nums[1]结尾的最大子序为[1]；
3.当i=2时，将nums[2]添加到以nums[1]结尾的最大子序上形成的新子序为[1,-3]，此时的子序和为-2，如果nums[2]自身为一个子序[-3]，那么子序和为-3，所以
以nums[2]结尾的最大子序为[1,-3]；
4.当i=3时，将nums[3]添加到以nums[2]结尾的最大子序上形成的新子序为[1,-3,4]，此时的子序和为2，如果nums[3]自身为一个子序[4]，那么子序和为4，所以
以nums[2]结尾的最大子序为[4]；
综合上述所得sum[i]，可以得到最大子序为[4]，最大子序和为4。

int maxSubArray(vector<int>& nums) 
{
	int len = nums.size();
	if(len==0)
	    return 0;
	int sum[len];
	sum[0] = nums[0];
	int maxSum = sum[0];
	for(int i=1;i<len;i++)
	{
	    sum[i] = max(sum[i-1]+nums[i],nums[i]);
	    if(sum[i]>maxSum)
	        maxSum = sum[i];
	}
	return maxSum;			 
}

题目4：打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

示例 1:

输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。偷窃到的最高金额 = 1 + 3 = 4 。

示例 2:

输入: [2,7,9,3,1]
输出: 12
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。偷窃到的最高金额 = 2 + 9 + 1 = 12 。

思路：使用动态规划解决问题，用count[i]表示到达第i间房时能够拿到的最大金额。在到达第i间房时能够拿到的最大金额取决于count[i-1]和count[i-2];如果count[i-1]和count[i-2]相等说明前i-1间房和前i-2间房取得的最大金额相等，也说明第i-1间房的钱没有被取走，那么第i间房的钱则可以被取走，则前i间房的最大金额是count[i-1]+nums[i]或者count[i-2]+nums[i]；如果count[i-1]大于count[i-2]说明第i-1间房的钱被取走，那么此时要做一个判断，比较取i-1房的钱，不取i房钱得到的总金额(count[i-1])和 取i房的钱，不取i-1房钱得到的总金额(count[i-2]+nums[i])的大小，选较大值赋给count[i]。由此可以上两种情况以的得到递推方程：count[i] = max(count[i-1],count[i-2]+nums[i])，并且可知到达第1间房时能够拿到的最大金额为第一间房的金额，到达第2间房时能够拿到的最大金额为前两间房金额中的较大值，由count[0]和count[1]便可以推得到达第i间房时能够拿到的最大金额。

int rob(vector<int>& nums) 
{
        int len = nums.size();
	if(len==0) 
	    return 0;
	if(len==1) 
	    return nums[0];
	int count[len];
	count[0] = nums[0]; 	   
	count[1] = max(nums[0],nums[1]);
	for(int i=2;i<len;i++)
	    count[i] = max(count[i-1],count[i-2]+nums[i]);   
	return count[len-1];	    
}