打家劫舍（滚动数组）

滚动数组是DP中的一种编程思想。简单的理解就是让数组滚动起来，每次都使用固定的几个存储空间，来达到压缩，节省存储空间的作用。

比如斐波那契额数列

    d[0]=1;
    d[1]=1;
    for(i=2;i<80;i++)
    d[i]=d[i-1]+d[i-2];

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。

输入: [2,1,1,3]
输出: 5

如果只有一间房，则偷取。如果有两件房，则偷两间房中数额大的那件。设置一个dp容器，存取当前i间房时候的最优解。当有k间房，有两种方案:

• 偷取第k间房，不偷k-1间房
• 偷取第k-1间房，不偷第k间房

所以 dp[i] = max(dp[i-2]+nums[i],dp[i-1])

class Solution {
public:
    int rob(vector<int>& nums) {
        //滚动数组的思想，用dp[0]和dp[1]推出后续是dp[0]+num[i]还是dp[1]

        if(nums.empty()) return 0;
        if(nums.size() == 1) return nums[0];

        int size = nums.size();
        vector<int> dp(size,0);//初始化大小为size，值为0的容器，每次存放当前最优解。
        dp[0] = nums[0];
        dp[1] = max(nums[0],nums[1]);
        for(int i=2;i<nums.size();i++)
        {
            dp[i] = max(dp[i-2]+nums[i],dp[i-1]);  //每次只需要对比i-2加上自身和i-1的值。
        }
        return dp[size-1];
    }
};

上述使用了数组存储当期最优解，考虑到每间房屋的最高总金额只和该房屋的前两间房屋的最高总金额相关，因此可以使用滚动数组，在每个时刻只需要存储前两间房屋的最高总金额。

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