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);
} 这段代码简直可以说是非常类似斐波那契数列的一个镜像了，从后往前爬梯，但是要真的理解它并不是那么容易的，画个图说下思路吧：
213.House Robber II
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]