Leetcdoe198. 打家劫舍

Every day a leetcode

题目来源：198. 打家劫舍

解法1：动态规划

确定dp含义

dp[i]: 表示在第 i 号房子之前可偷窃的最高金额。

初始化：

dp[0] = nums[0]
dp[1] = max(nums[0], nums[1])

转移方程

在第 i 号房子可偷窃的最高金额由两种情况确定：

1. 第 i-2 号房子可偷窃的最高金额加上第 i 号房子的存放金额；
2. 或者第 i-1 号房子可偷窃的最高金额。

我们两者取其大，得转移方程：dp[i] = max(dp[i-2] + nums[i], dp[i-1])。

最终结果

ans=max(dp[numsSize - 1], dp[numsSize - 2]);

代码：

int max(int a,int b)
{
    return a>b?a:b;
}
int rob(int* nums, int numsSize){
    if(numsSize == 1) return nums[0];
    int dp[numsSize];
    memset(dp,0,sizeof(dp));
    dp[0]=nums[0];
    dp[1]=max(nums[0],nums[1]);
    for(int i=2;i<numsSize;i++)
    {
        dp[i]=max(dp[i-2]+nums[i],dp[i-1]);
    }
    int ans=max(dp[numsSize-1],dp[numsSize-2]);
    return ans;
}

结果：

解法2：动态规划 - C++ version

代码：

// 动态规划

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

        int n = nums.size();
        if (n == 1)
            return nums[0];

        // dp[i]: 偷窃 nums[0,...,i] 能得到的最高金额
        vector<int> dp(n, 0);

        // 初始化
        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];
    }
};

结果：

复杂度分析：

时间复杂度：O(n)，其中 n 为数组 nums 的长度。

空间复杂度：O(n)，其中 n 为数组 nums 的长度。

空间优化：

// 动态规划 - 空间压缩

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

        int n = nums.size();
        if (n == 1)
            return nums[0];

        int pre2 = 0, pre1 = 0, cur;
        // 状态转移
        for (int i = 0; i < n; i++)
        {
            cur = max(pre2 + nums[i], pre1);
            pre2 = pre1;
            pre1 = cur;
        }
        return cur;
    }
};

复杂度分析：

时间复杂度：O(n)，其中 n 为数组 nums 的长度。

空间复杂度：O(1)。

解法3：递归 + 记忆化搜索

记忆化搜索 = 递归 + 保存搜索结果。

代码：

// 递归 + 记忆化搜索

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

        int n = nums.size();
        if (n == 1)
            return nums[0];

        int memo[n];
        memset(memo, -1, sizeof(memo));

        function<int(int)> dfs = [&](int i) -> int
        {
            if (i < 0)
                return 0;
            if (memo[i] != -1)
                return memo[i];

            int res = max(dfs(i - 1), dfs(i - 2) + nums[i]);
            memo[i] = res;
            return res;
        };

        return dfs(n - 1);
    }
};

结果：

复杂度分析：

时间复杂度：O(n)，其中 n 为数组 nums 的长度。

空间复杂度：O(n)，其中 n 为数组 nums 的长度。