【动态规划：简单多状态dp问题】打家劫舍Ⅰ && 打家劫舍Ⅱ

打家劫舍Ⅰ（medium）

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

解题思路

​ 这道题的大体思路和上面的按摩师题目是类似的，分为两种状态去解析，如下图所示：

​ 还有剩下的初始化问题、填表顺序和返回值问题，都用图片形式展现：

class Solution {
public:
    int rob(vector<int>& nums) {
        // 创建dp表
        int n = nums.size();
        vector<int> steal(n, 0);
        vector<int> nosteal(n, 0);

        // 初始化
        steal[0] = nums[0];

        // 填表
        for(int i = 1; i < n; ++i)
        {
            steal[i] = nosteal[i - 1] + nums[i];
            nosteal[i] = max(steal[i - 1], nosteal[i - 1]);
        }

        // 返回两种可能状态的最大值
        return max(steal[n-1], nosteal[n-1]);
    }
};

打家劫舍Ⅱ（medium）

213. 打家劫舍 II

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

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

示例 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 = [1,2,3]
输出：3

提示：

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

解题思路

​ 这道题和上面的 打家劫舍Ⅰ 的唯一区别，就是它的首尾是相连的，相当于一个环形队列！也就是说，如果我们在第一个位置选择偷，那么最后一个位置是不能偷的；如果第一个位置不偷的话，那么最后一个位置是可偷可不偷的！

​ 仅仅是这个区别而已，所以我们只需要分析一下这种情况，然后复用我们上面写的 打家劫舍Ⅰ 的代码稍微修改一下就行了！

下面我们来分析一下首尾的情况：

• 首先我们要明白，我们不需要都得首尾进行判断，只需要对首部进行情况分析即可，因为我们最后要到达的是尾部位置，而此时首部是已经走过的了，所以其实影响尾部的就是首部，所以我们分析首部的时候，已经就相当于分析了尾部的情况，这点要清楚！

  • 如果首部选择偷：

    • 此时尾部就不能偷了，也就是说，我们能偷的 下标范围 就局限于 [2, n-2] 了。
    • 为什么是从 2 开始呢，因为首部偷了，那么不仅尾部不能偷，首部的下一个元素也就是下标为 1 的元素也不能偷了，所以从 2 开始！
    • 为什么是到 n-2 结束呢，因为要注意这是下标范围，最后一个元素是 n-1，因为它不能偷，所以能偷的范围就是到它的前一个下标 n-2 的元素！
      

  • 如果选择选择不偷：

    • 此时尾部是可以偷或者不偷的，而且首部的下一个下标 1 处的元素也是可以偷或者不偷的，所以能偷的 下标范围 就局限于 [1, n-1] 了！
      

​ 考虑完这两种情况，我们就可以开始写代码了，因为在能偷的下标范围内，其实代码实现就和 打家劫舍Ⅰ 是一样的，所以这里就不再详细讲解，具体的可以参考上面的笔记！

​ 只不过我们需要将 打家劫舍Ⅰ 的代码稍微修改一下，具体的参考代码：

class Solution {
public:
    // 主函数
    int rob(vector<int>& nums) {
        int n = nums.size();
        // 返回首部偷和不偷情况中最后金额大的那个
        // 注意偷的话还要加上首部的金额，而不偷就不用，相当于加0
        return max(nums[0] + rob1(nums, 2, n-2), rob1(nums, 1, n-1));
    }

    // 打家劫舍Ⅰ代码的修改
    int rob1(vector<int>& nums, int left, int right)
    {
        // 判断是否范围有效
        if(left > right)
            return 0;
        
        // 剩下的代码都是类似的，只不过下标变成了left和right范围！
        int n = nums.size();
        vector<int> steal(n, 0);
        vector<int> nosteal(n, 0);
        steal[left] = nums[left];
        for(int i = left; i <= right; ++i)
        {
            steal[i] = nosteal[i-1] + nums[i];
            nosteal[i] = max(steal[i-1], nosteal[i-1]);
        }
        return max(steal[right], nosteal[right]);
    }
};