动态规划-简单多状态dp问题 -- 打家劫舍(二)

动态规划-简单多状态dp问题 – 打家劫舍(二)

题目重现

题目链接：打家劫舍 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

读懂题目

对于此题需要注意：

• 所有房屋是围成一圈，即首尾相接
• 不能选择位置连续的房屋（即选中 i 位置，那么 i - 1 和 i + 1 位置都不能再偷了）

所以在本题中描述的环形情景下，假定有 n 个房屋，当下标 0 位置被选中后，相应的下标为 n - 1 的房屋就不能被选中了。这个要点是与 “打家劫舍(一)” 的差异所在。

对于该题的环形问题可以针对 i = 0 位置是否被选中转化为两种单排情况：

• **偷 i = 0 位置：**不能偷最后一个房子(下标对应 i = n - 1)，因此偷房子的区间为 [0, n - 2]
• **不偷 i = 0 位置：**可以偷最后一个房子(下标对应 i = n - 1)，因此偷房子的区间为 [1, n - 1]

因此问题由环形问题转化为求上面两种单排情况的最大值。

算法流程

1.状态表示

由题目要求和经验，我们将 dp[i] 设定为偷窃到 i 位置后，所能偷窃到的最大金额。

但是我们考虑题中有着 不能连续偷窃 的硬性条件，所以当访问到每个 i 位置时，都会对应 偷窃 和 不偷窃 两种情况，所以上面的 dp[i] 状态表示还能进行细分。将其拆分为两部分，不妨设为 f[i] 和 g[i] 分别表示 i 位置决定偷窃和不偷窃情况下的最大金额，因为 dp[i] 只能对应这两种情况中的一种，同时其代表最大金额，所以 dp[i] = max(f[i], g[i])

2.状态转移方程

对 f[i]：

因为 f[i] 代表 i 位置偷窃后得到的最大金额，所以 i - 1 位置一定是不能被偷窃过的。从而就有

f[i] = g[i - 1] + nums[i]

对 g[i]:

在状态表示中，我们设定 g[i] 是代表 i 位置偷窃未得到的最大金额，所以该金额的值仅取决于 i - 1 位置，nums[i] 的金额无需叠加。所以有

g[i] = max (f[i - 1], g[i - 1])

3.初始化

假定可盗窃下标区间为 [left, right]，结合状态转移方程和题意可得

• f[left] = nums[left]
• g[left] = 0

4.填表顺序

从左往右，f、g两表同填

5.返回值

由于上面题目解析中已经提到将环形问题转化为两个单排问题，所以返回值为两种单排情况的最大值。

每种单排情况的返回值为：max (f[right], g[right])

示例代码

class Solution {
public:
    int _rob(vector<int>& nums, int left, int right)
    {
        if(left > right) { return 0; }

        int n = nums.size();
        vector<int> f(n);
        auto g = f;

        f[left] = nums[left];
        g[left] = 0;

        while(left <= right)
        {
            f[left] = g[left - 1] + nums[left];
            g[left] = max(f[left - 1], g[left - 1]);
            ++left;
        }
        return max(f[left - 1], g[left - 1]);   // 上面for循环多执行了一次 ++left
    }

    int rob(vector<int>& nums) {
        // 环形转数组 对于nums[0]有两种情况
        // 1.nums[0]选择后，nums[1]和nums[n - 1]都不能选，即_rob(nums, 2, n - 2) + nums[0]
        // 2.nums[0]未被选，nums[1]和nums[n - 1]都可被选，即_rob(nums, 1, n - 1)

        int n = nums.size();
        if(n == 1) { return nums[0]; }
        
        return max(
            _rob(nums, 2, n - 2) + nums[0],     // nums[0]被选中
            _rob(nums, 1, n - 1));    // nums[0]未被选中
    }
};

提交结果：