leetcode-动态规划

   近期在刷leetcode，偶尔会遇到一些动态规划的问题。动态规划的特点就是整体问题求解能划分为若干个子问题求解，并且整体最优解依赖于若干个子问题的最优解，子问题间也许存在重叠。所以动态规划一个非常重要的点就在于如何划分出子问题。此篇博客记录了我在刷leetcode动态规划专题时easy级别和部分medium级别的题目，我也正尝试着从这些题目中归纳总结出动态规划的精髓。<文中代码都是c++版本的>

198. House Robber

问题建模：对于一个vector，统计出该vector中非相邻元素的最大元素和。

问题思考：对于一对相邻元素，选择出其中较大值参与求和运算，隔点采样，假定有三个数a,b,c，如果a+c<b，则选择b参与最终运算，因此这个问题是由若干个子问题组成的，并且实验中需要不断地更新当前最优解，是一个典型的动态规划问题。

大神代码1：

#define max(a, b) ((a)>(b)?(a):(b))
int rob(int num[], int n) {
    int a = 0;
    int b = 0;
    
    for (int i=0; i<n; i++)
    {
        if (i%2==0)
        {
            a = max(a+num[i], b);
        }
        else
        {
            b = max(a, b+num[i]);
        }
    }
    
    return max(a, b);
}

这段代码非常精辟，不过就是没那么好懂，大致思想是根据index的奇偶性将其分为两部分，通过a=max(a+num[i],b)和b=max(a,b+num[i])不断更新a和b的值，最后返回a,b中较大的那个值，你们可以拿一串数字来推导一下，真的不会取到相邻的值！！！我个人觉得这种方法很巧妙，但是不够好理解，所以我又去找到了另外一个大神的代码。

大神代码二：

int rob(vector<int>& nums) {
        
        int ifRobbedPrevious = 0; 	// max monney can get if rob current house
	int ifDidntRobPrevious = 0;    // max money can get if not rob current house
	    
	    // We go through all the values, we maintain two counts, 1) if we rob this cell, 2) if we didn't rob this cell
	    for(int i=0; i < nums.size(); i++) 
	    {
	    	// If we rob current cell, previous cell shouldn't be robbed. So, add the current value to previous one.
	        int currRobbed = ifDidntRobPrevious + nums[i];
	        
	        // If we don't rob current cell, then the count should be max of the previous cell robbed and not robbed
	        int currNotRobbed = max(ifDidntRobPrevious, ifRobbedPrevious); 
	        
	        // Update values for the next round
	        ifDidntRobPrevious  = currNotRobbed;
	        ifRobbedPrevious = currRobbed;
	    }
	    
	    return max(ifRobbedPrevious, ifDidntRobPrevious);
    }

这个代码看后面的解释都能懂啦！非常简洁，思路也非常清晰，点赞！！！

70. Climbing Stairs

这就是个典型的斐波那契数列，代码就不贴了，很简单。

746. Min Cost Climbing Stairs

这是上面爬梯子的升级版，关键在于要到cost之和最小的step上，跳过cost消耗大的step。

解决思路一——前向爬梯，不断更新当前到达当前step所需要的cost之和，代码如下：

  int minCostClimbingStairs(vector<int>& cost) {
        int n=(int)cost.size();
        vector<int> dp(n);
        dp[0]=cost[0];
        dp[1]=cost[1];
        for (int i=2; i<n; ++i)
            dp[i]=cost[i]+min(dp[i-2],dp[i-1]);
        return min(dp[n-2],dp[n-1]);
        
    }

因为题目说了可以从index为0或1开始爬，所以我们的循环体是从i=2开始，一直到n-1为止的，最后返回的是,min(dp[n-2],dp[n-1])，这个可以和他的例子结合起来看，题目中给了一个例子是：input:cost=[10,15,20];output=15;为啥不是output=30呢？我的理解是cost[n-1]不一定非要取到，当跳到cost[1]时，下一步跳2步，直接就跳出cost数组了，所以最小值是15，同样的方法理解最后return的是min(dp[n-2],dp[n-1])而不是dp[n-1]咯。

解决思路二——后向爬梯，逆向的斐波那契数列，非常巧妙的一种解法，大神代码如下：

   int minCostClimbingStairs(vector<int>& cost) {
    int length = cost.size();
	int f1 = 0;
	int f2 = 0;
	for (int i = length - 1; i >= 0; i--)
	{
		int f0 = cost[i] + min(f1, f2);
		f2 = f1;
		f1 = f0;
	}
        return min(f1,f2);
        
    }

这段代码简直可以说是非常类似斐波那契数列的一个镜像了，从后往前爬梯，但是要真的理解它并不是那么容易的，画个图说下思路吧：

213.House Robber II

这是house robber的升级版，house robber是不能取到相邻的两个元素，而这个题将收尾元素相连，形成一个环，也不能取到相邻元素，index=0与index=n-1是一组相邻元素，所以我做的时候就分两种情况讨论，一种是取index=0参与运算，另外一种是取index=n-1参与运算，最后比较这两种情况对应总和的最大值。代码是House Robber第二种解法和Min Cost Climbing Stairs 第二种解法的综合体，如下：

 int rob(vector<int>& nums) {
        int length = nums.size();
	if (length == 0) return 0;
	if (length == 1) return nums[0];
	if (length == 2) return max(nums[0], nums[1]);
	
		int ifRobbedPrevious = 0;
		int ifDidntRobPrevious = 0;
		int currRobbed;
		int currNotRobbed;
		for (int i = 0; i < length - 1; i++)

		{
			currRobbed = ifDidntRobPrevious + nums[i];
			currNotRobbed = max(ifDidntRobPrevious, ifRobbedPrevious);
			ifDidntRobPrevious = currNotRobbed;
			ifRobbedPrevious = currRobbed;

		}
		int temp1= max(ifRobbedPrevious, ifDidntRobPrevious);

		 ifRobbedPrevious = 0;
		 ifDidntRobPrevious = 0;
		for (int i = length - 1; i > 0; i--)

		{
			currRobbed = ifDidntRobPrevious + nums[i];
			currNotRobbed = max(ifDidntRobPrevious, ifRobbedPrevious);
			ifDidntRobPrevious = currNotRobbed;
			ifRobbedPrevious = currRobbed;

		}
		int temp2=max(ifRobbedPrevious, ifDidntRobPrevious);
          return max(temp1,temp2);
            
        }

如果懂了上面的两道题那么这个代码就会看起来非常的简单啦~

343 Integer Break

这简直就和剑指offerP96面试题14：剪绳子一毛一样呀！主要有两种解法：动态规划、贪婪算法（尽可能多分裂成3）

121.Best Time to Buy and Sell Stock

找出倒卖股票的最大利润，问题的关键在于找到一个波谷值买入，然后在这个波谷值后面的最高的波峰值卖出，两个元素相减既得最大利润。代码比较简单，就是保存了波谷的index值，然后往后寻找波峰的index，如下所示：

 int maxProfit(vector<int>& prices) {
        if(prices.size()==0) return 0;
        int base, index;
	int profit=0;	
	for (size_t i = 0; i < prices.size()-1; i++)
	{
		if (prices[i + 1] >= prices[i])
		{
			base = prices[i]; 
			index = i;
			break;
		}
		else if ((prices[i + 1] < prices[i]) && i != prices.size() - 2)
		{
			continue;
		}
		else
		{
			return 0;
		}
		
	}
	for (index;index  < prices.size()-1;index++)
	{
	
		if (prices[index+1]<base)
		{
			base = prices[index + 1];
		}
		else
		{
			profit = max(prices[index + 1] - base,profit);
		}
	}
        return profit;
        
    }

小结：我个人觉得动态规划最难的就是巧妙地去选择base并去更新这些base值，很多时候都会有斐波那契数列的影子，for、while循环自然是少不了的，多写才能慢慢的摸到一些门道。关于leetcode上动态规划的题还有许多，比如寻找unique number，寻找maximum Subarray等等，官网给的solution大多也非常巧妙，discuss区更是牛人如云，每次膜拜完大神的代码总是像打了鸡血一样的热爱代码热爱算法呀！