每日一题：打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

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

示例 2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

提示：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 400

---

动态规划入门问题。

最简单的思路：从遍历的角度思考。

对每一间屋子，我们有两个动作：偷和不偷。

定义dp数组保存到当前屋子获得的最大值，长度为房子数的二倍，用单数下标表示不偷当前屋子，双数下标表示偷当前屋子。

初始值：

dp[0] = nums[0]; //偷第一间屋子
dp[1] = 0;       //不偷

对第n间房子：

dp[i] = dp[i-1] + nums[i/2];       //偷当前屋子，获得的最大值就是不偷前一间屋子+当前屋子值。
dp[i+1] = max(dp[i-2],dp[i-1]);    //不偷当前屋子，那么最大值就是偷/不偷前一间屋子的较大值。

最终返回最后一间房子偷和不偷的较大值。

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

优化的思路：从宏观的角度思考。

• 偷第 n 间屋子，那么就不能偷第 n−1 间屋子，获得的最大值就是前 n−2 间屋子的获得的最大值加上第 n 间屋子值。
• 不偷第 n 间屋子，获得的最大值就是前 n−1 间屋子的获得的最大值。
• 比较这两者哪个更大。

状态转移方程：

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

初始状态：

dp[0] = nums[0];               //只有一间屋子，当然是偷。
dp[1] = max(nums[0],nums[1]);  //有两间屋子，取最大值偷。

 从第三间开始，按照上述思路进行dp。

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