动态规划-打家劫舍

198. 打家劫舍

难度中等

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

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

示例 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[i]表示偷1~i+1家，能够获得的最大金额数，于是显然有如下状态转移方程

        读者可能会疑惑，这样设置dp[i]，后果是dp[i]并不能代表一定会偷第i+1家，既然如此，好像有时候即使是dp[i]也可以选择nums[i+1]，但是有时候也不可以，因为dp[i]也有可能是因为选择了nums[i]达到的。

        这边笔者尝试解释一下，如果说dp[i]是选择了nums[i]得到的结果，那么自然下一步就不能选择nums[i+1]，但是如果dp[i]不是选择了nums[i]的呢？那么根据我们对dp的定义-dp[i]表示偷1~i+1家，能够获得的最大金额数，就可以知道，此时dp[i]就等于dp[i-2]，而读者所顾虑的dp[i]并没有偷nums[i]情况下获得的最大金额数就是dp[i-1]，此时状态转移方程

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

就包括了读者顾虑的情况啦~

213. 打家劫舍 II

难度中等836

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

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

示例 1：

输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

示例 2：

输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 3：

输入：nums = [0]
输出：0

提示：

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

思路：本题和上一题类似 ，不过问题在于房屋的排列成了环状，因此偷了第一家就不能偷最后一家。既然一切都是因为第一家和最后一家不能共存导致的，因此我们分开考虑

A.考虑偷第一家，那么可以偷的范围为 1 ~ n - 1

B.考虑偷第n家，那么可以偷的范围为 2 ~ n

两次dp过程即可~

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size(), dp[n + 5], i, max_ans;
        if(n == 1){
            return nums[0];
        }
        if(n == 2){
            return max(nums[0], nums[1]);
        }
        // 第一种，想偷第一家，可考虑范围为0~n-2
        memset(dp, 0, sizeof(dp));
        dp[0] = nums[0];
        dp[1] = max(dp[0], nums[1]);
        for(i = 2; i <= n - 2; ++ i){
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        max_ans = dp[n - 2];
        // 第一种，不偷第一家，可考虑范围为1~n-1
        dp[1] = nums[1];
        dp[2] = max(dp[1], nums[2]);
        for(i = 3; i < n; ++ i){
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return max(max_ans, dp[n - 1]);
    }
};