day51|● 198.打家劫舍 ● 213.打家劫舍II ● 337.打家劫舍III

最新推荐文章于 2024-11-01 18:22:04 发布

星轨道交

最新推荐文章于 2024-11-01 18:22:04 发布

阅读量326

点赞数

分类专栏：代码随想录一刷文章标签： leetcode 算法数据结构动态规划蓝桥杯

本文链接：https://blog.csdn.net/qerwtrt4t/article/details/128810552

版权

代码随想录一刷专栏收录该内容

54 篇文章 5 订阅

订阅专栏

198. 打家劫舍

1.代码

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

2.动规五部曲

1.确定dp数组和其下标的含义

一夜之内能够偷窃到的最高金额可知，dp[i]为盗窃到第i个房屋的最高金额，dp[nums.size() - 1]为盗窃完所有房屋的最高金额

2.确定dp数组的递推公式，一般有事从后面看，再从中间全局看，因为这不像完全背包，需要多个物品，所以再后面几个看，我们可以确定到达第i个房屋时的金额，有两种情况：

一.偷当前房屋的物品：则金额就是为dp[i - 2]所偷的金额加上现在房屋要偷的金额

二.不偷当前房屋：则金额就是dp[i - 1]的金额

所以最大金额为：dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);

3.初始化dp数组

由递推公式可知，前面两个元素必须知道，可以初始化dp[0]和dp[1]

4.确定遍历顺序

这里按照直线遍历房屋直到最后一个房屋，所以顺序遍历

5.举例说明dp数组

213. 打家劫舍 II

1.代码

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 1) return nums[0];
        if (nums.size() == 2) return max(nums[0], nums[1]);
        vector<int> a1(nums.begin(), nums.end() - 1);
        vector<int> a2(nums.begin() + 1, nums.end());
        int dpstart = robRangeMax(a1);
        int dpend = robRangeMax(a2);
        int result = max(dpstart, dpend);
        return result; 
    }
    int robRangeMax(vector<int>& nums) {
        vector<int>f(nums.size(), 0);
        if (nums.size() == 1) return nums[0];
        if (nums.size() == 2) return max(nums[0], nums[1]);
        f[0] = nums[0];
        f[1] = max(nums[0], nums[1]);
        for (int i = 2; i < nums.size(); i++) {
            f[i] = max(f[i - 2] + nums[i], f[i - 1]);
        }
        return f[nums.size() - 1];
    }
};

// 注意注释中的情况二情况三，以及把198.打家劫舍的代码抽离出来了
class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        if (nums.size() == 1) return nums[0];
        int result1 = robRange(nums, 0, nums.size() - 2); // 情况二
        int result2 = robRange(nums, 1, nums.size() - 1); // 情况三
        return max(result1, result2);
    }
    // 198.打家劫舍的逻辑
    int robRange(vector<int>& nums, int start, int end) {
        if (end == start) return nums[start];
        vector<int> dp(nums.size());
        dp[start] = nums[start];
        dp[start + 1] = max(nums[start], nums[start + 1]);
        for (int i = start + 2; i <= end; i++) {
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[end];
    }
};

2.思考

和第一题不同的是首尾不能够相连，所以我们能分成两种情况，一种是不包括首元素再进行第一题的求最后一个dp数组，另一种是不包括尾元素求最后一个dp数组，最后这两种方法的结果求最大值就是最终结果了。

3.递归五部曲

和第一题一样。就是分成了两个数组分别求dp

337. 打家劫舍 III

1.代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int rob(TreeNode* root) {
      vector<int>result = robTree(root);
      return max(result[0], result[1]);    
    }
    vector<int> robTree(TreeNode* cur) {
        if (cur == NULL) return vector<int>{0, 0};
        vector<int> left = robTree(cur->left);
        vector<int> right = robTree(cur->right);
        //偷当前结点
        int var1 = cur->val + left[0] + right[0];
        //不偷当前结点，左右结点可偷可不偷
        int var2 = max(left[0], left[1]) + max(right[0], right[1]);
        return vector<int>{var2, var1};
    }
};