leetcode-动态规划

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

198. House Robber

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

问题思考:对于一对相邻元素,选择出其中较大值参与求和运算,隔点采样,假定有三个数a,b,c,如果a+c

大神代码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

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

大神代码二:

int rob(vector& 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& cost) {
        int n=(int)cost.size();
        vector dp(n);
        dp[0]=cost[0];
        dp[1]=cost[1];
        for (int i=2; i

因为题目说了可以从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& 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);
        
    }

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

leetcode-动态规划_第1张图片

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& 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& 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值,很多时候都会有斐波那契数列的影子,for、while循环自然是少不了的,多写才能慢慢的摸到一些门道。关于leetcode上动态规划的题还有许多,比如寻找unique number,寻找maximum Subarray等等,官网给的solution大多也非常巧妙,discuss区更是牛人如云,每次膜拜完大神的代码总是像打了鸡血一样的热爱代码热爱算法呀!


你可能感兴趣的:(leetcode)