【LeetCode-动态规划】打家劫舍

题目描述

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
示例：

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

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

题目链接： https://leetcode-cn.com/problems/house-robber/

思路

使用动态规划求解，关键是找到状态转移方程。使用dp[n]表示在n个房屋内能够偷窃到的最高金额，A[i]表示第i个房屋存放的金额，分析过程如下：

• 当n=1时，dp[1] = A[1]；
• 当n=2时，因为不能连续偷窃两个房屋，所以dp[2] = max(A[1], A[2]) ；
• 当n=3时，有两种选择：偷第3个房屋，此时金额为dp[1]+A[3]；不偷第3个房屋，此时金额为之前的金额dp[2]，因为要求偷窃金额最大化，所以dp[3] = max(dp[1]+A[3], dp[2])；
• 以此类推，偷窃n个房屋的最高金额dp[n] = max(dp[n-2]+A[n], f(n-1)).
  代码如下：

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.empty()) return 0;

        int dp[nums.size()];
        memset(dp, 0, sizeof(dp));
        dp[0] = nums[0];
        for(int i=1; i<nums.size(); i++){
            if(i==1){
                dp[i] = max(nums[0], nums[1]);
            }else{
                dp[i] = max(dp[i-2]+nums[i], dp[i-1]);
            }
        }
        return dp[nums.size()-1];
    }
};

换一种写法：

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.empty()) return 0;

        int* dp = new int[nums.size()+1];
        memset(dp, 0, sizeof(dp));
        dp[0] = 0;
        dp[1] = nums[0];
        for(int i=2; i<=nums.size(); i++){
            dp[i] = max(dp[i-2]+nums[i-1], dp[i-1]);
        }

        return dp[nums.size()];
    }
};

本来应该是dp[0]=nums[0]，为了计算方便，将dp[0]设为0，则dp[i]对应上面的dp[i-1]（i>0）。

• 时间复杂度：O(n)
• 空间复杂度：O(n)

优化

可以将空间复杂度优化到O(1)，代码如下：
代码如下：

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.empty()) return 0;

        int preMax = 0;
        int curMax = 0;
        for(int i=0; i<nums.size(); i++){
            int temp = curMax;
            curMax = max(preMax+nums[i], curMax);
            preMax = temp;
        }
        return curMax;
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(1)