近期在刷leetcode,偶尔会遇到一些动态规划的问题。动态规划的特点就是整体问题求解能划分为若干个子问题求解,并且整体最优解依赖于若干个子问题的最优解,子问题间也许存在重叠。所以动态规划一个非常重要的点就在于如何划分出子问题。此篇博客记录了我在刷leetcode动态规划专题时easy级别和部分medium级别的题目,我也正尝试着从这些题目中归纳总结出动态规划的精髓。<文中代码都是c++版本的>
问题建模:对于一个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);
}
这个代码看后面的解释都能懂啦!非常简洁,思路也非常清晰,点赞!!!
这就是个典型的斐波那契数列,代码就不贴了,很简单。
这是上面爬梯子的升级版,关键在于要到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);
}
这段代码简直可以说是非常类似斐波那契数列的一个镜像了,从后往前爬梯,但是要真的理解它并不是那么容易的,画个图说下思路吧:
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);
}
如果懂了上面的两道题那么这个代码就会看起来非常的简单啦~
这简直就和剑指offerP96面试题14:剪绳子一毛一样呀!主要有两种解法:动态规划、贪婪算法(尽可能多分裂成3)
找出倒卖股票的最大利润,问题的关键在于找到一个波谷值买入,然后在这个波谷值后面的最高的波峰值卖出,两个元素相减既得最大利润。代码比较简单,就是保存了波谷的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]