动态规划-斐波那契题

最近在刷letcode,动态规划从头开始刷题。

所谓的动态规划，就是当前的状态和之前的状态相关，只要记住这个点，很多问题都可以迎面而解。

动态规划的一个重要应用就是斐波那契数列。

斐波那契数列是这样的：1，1，2，3，5，8，13，21...

当前数由前两个数相加而得到。也就是：

当前状态和前两个状态相关。

今天的第一道题目是这样的：

最小花费爬楼梯，每次可以爬一个或者两格，每爬一次就要支付当前楼梯的价格，一开始可以选择从第一格或者第二格爬，求爬到顶层的最小花费。

示例一：

输入：cost=[10,15,20]

输出：15

解释：从第二格开始爬，支付15就可以再爬两个到达顶层了。

示例二：

输入：cost=[1,100,1,1,1,100,1,1,100,1]

输出：6

解释：第一层，第三层，第五层，第七层，第八层，第十层

解题思路：我们要时刻记住动态规划的思想，即当前状态和之前的状态是相关的。这道题某种程度上用了dijkstra的思想，从第一格楼梯开始标记第一步，更新至第一格的最小代价，然后标记下一格，更新下一格的最小代价，直至楼梯的顶层，只不过这道题没有dijkstra那么复杂罢了，楼梯只有两个邻居，即上一格和下一格，标记更新是有唯一方向的，而且这道题不用返回爬楼梯所爬格子的标签，即不需要回溯。

下面是解题c++代码，

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

后来我们又发现，dp[i]只和dp[i-1]和dp[i-2]有关，那我们就不需要定义dp数组，而是用prev和curr两个整形将其代替。

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n = cost.size();
        int prev = 0, curr = 0;
        for (int i = 2; i <= n; i++) {
            int next = min(curr + cost[i - 1], prev + cost[i - 2]);
            prev = curr;
            curr = next;
        }
        return curr;
    }
};

今天的第二道题是这样的：小偷在村子里沿着马路的房子偷东西，但不能偷相邻的房子的东西，否则会触响警报，求小偷偷到财产的最大值。

示例一：

输入：[1,2,3,1]

输出：4

解释：小偷先偷第一家，再偷第三家。

示例二：

输入：[2，7，9，3，1]

输出：12

解释：第一家，第三家，第五家。

解题思路：咋一看这道题好像很难，但仔细想这道题和上面一道题其实有异曲同工之妙。我们还是要牢记动态规划的思想，当前状态和之前状态相关。那么这道题其实就是上面一道题的翻版，换汤不换药，只不过最小值变成了最大值，步长从1变成了2而已。

class Solution {
public:
    int rob(vector<int>& nums) {
        int n=nums.size();
        int list[n];
        list[0]=nums[0];
        if(n>1)
        {
            list[1]=max(nums[0],nums[1]);      
            for(int i=2;i<=n-1;i++)
            {
                list[i]=max(list[i-2]+nums[i],list[i-1]);
            } 
        }
        return list[n-1];        
    }
};

然后我们发现，list[i]只和list[i-1]和list[i-2]相关，那么就可以用cur,pre两个整形来代替list数组。

class Solution {
public:
    int rob(vector<int>& nums) {
        int n=nums.size();
        int pre;
        int tem;
        int cur=nums[0];
        if(n>1)
        {
            pre=cur;
            cur=max(nums[0],nums[1]);      
            for(int i=2;i<=n-1;i++)
            {   
                tem=cur;
                cur=max(pre+nums[i],cur);
                pre=tem;
            } 
        }
        return cur;        
    }
};