leetcode 198.打家劫舍 & 213.打家劫舍II - 动态规划

leetcode 198.打家劫舍 & 213.打家劫舍II - 动态规划

题干

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 。

提示：
0 <= nums.length <= 100
0 <= nums[i] <= 400

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 = [0]
输出：0

知识点&算法

198.打家劫舍

很经典的动态规划问题，两题的差别在于数据量，和后者的条件从一列店铺变成了一圈店铺。
dp[i]表示到下标为i的店铺为止所能获得的最大金额，考虑初值条件，dp[0]显然只能偷第一家所以是nums[0]，dp[1]由于相邻的两家只能选一家偷，所以偷较大的一家，为max(nums[0],nums[1])。
考虑状态转移方程，由于相邻的两家不能连着偷，所以dp[i] = max(dp[i-1],dp[i-2] + nums[i])，为相邻一家偷了的情况，和相邻一家没有偷，所以偷当前家的情况。
答案即为dp[n-1]。

213.打家劫舍II

对于成环的店铺来说，思路基本是一样的，如果我们将一圈店铺以数组首元和尾元之间为中界断开展开为一列店铺，就可以按照之前的思路继续考虑。
但这里有一个问题，第一家店铺和最后一家店铺是冲突的，我们如果按照之前的策略一路遍历下来，无法判断获得最大金钱的情况是否同时选择了第一家店铺和最后一家店铺。
所以我们分开讨论，讨论选择了第一家店铺和没有选择的情况，我们用dp[i][0]遍历到下标为i的店铺时且选择了第一家店铺时能获得的最大金额，dp[i][1]表示没有选择第一家店铺的情况。
考虑初值情况，dp[0][0]由于选择了第一家店铺所以是nums[0]，dp[1][0]由于选择了第一家店铺，第二家店铺不能再选，所以也是nums[0]；dp[0][1]由于没有选择第一家店，所以是0，dp[1][1]由于没有选择第一家店，只能选第二家店，所以是nums[1]。
考虑状态转移方程，和之前一样，只是多了一维dp[i][j] = max(dp[i-1][j],dp[i-2][j] + nums[i]);
特别需要注意的是，在选择了第一家店铺的情况下最后一家店铺是无法选择的，所以dp[i][0]只需要遍历到倒数第二家店铺即可。
答案即为dp[n-1][1]和dp[n-2][0]中较大的一个。

题解

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

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