代码随想录算法训练营第47天| 198.打家劫舍 213.打家劫舍II 337.打家劫舍III

• 今日学习的文章链接，或者视频链接

第九章 动态规划part09

• 自己看到题目的第一想法

• 看完代码随想录之后的想法

198

自顶向下：

class Solution {
public:
    vector<int> memo;
    int dp(vector<int>& nums,int start){
        if(start >= nums.size()) return 0;
        if(memo[start]!=-1) return memo[start];
        memo[start] = max(dp(nums,start+1),dp(nums,start+2)+nums[start]);
        return memo[start];
    }
    int rob(vector<int>& nums) {
        // 初始化备忘录
        memo = vector<int>(nums.size(), -1);
        // 强盗从第 0 间房子开始抢劫
        return dp(nums, 0);
    }
};

自底向上：

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

213

自顶向下：

class Solution {
public:
    vector<int> memo1;
    vector<int> memo2;
    int dp(vector<int>& nums,int start,int end,vector<int>& memo){
        if(start > end) return 0;
        if(memo[start]!=-1) return memo[start];
        memo[start] = max(dp(nums,start+1,end,memo),dp(nums,start+2,end,memo)+nums[start]);
        return memo[start];
    }
    int rob(vector<int>& nums) {
        int n = nums.size();
        if(n==1) return nums[0];
        vector<int> memo1(n, -1);
        vector<int> memo2(n, -1);
        return max(
                dp(nums, 0, n - 2, memo1),
                dp(nums, 1, n - 1, memo2)
        );
    }
};

自底向上：

class Solution {
public:
    int robRange(vector<int>& nums, int start, int end) {
        if(start == end){
            return nums[start];
        }
        vector<int> dp(nums.size(),0);
        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];
    }

    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);
    }
};

337

class Solution {
public:
    unordered_map<TreeNode*,int> memo;
    int rob(TreeNode* root) {
        if(root == nullptr) return 0;
        if(memo.count(root)) return memo[root];
        // 抢，然后去下下家
        int do_it = root->val
                    +(root->left==nullptr?0:rob(root->left->left)+rob(root->left->right))
                    +(root->right==nullptr?0:rob(root->right->left)+rob(root->right->right));
        // 不抢，然后去下家
        int not_do = rob(root->left)+rob(root->right);
        memo[root] = max(do_it, not_do);
        return memo[root];
    }
};

卡哥的思路：

class Solution {
public:
    //dp[0] 不偷最大值， dp[1] 偷的最大值
    vector<int> robtree(TreeNode* cur){
        if(cur == nullptr) return vector<int>{0,0};
        vector<int> leftdp = robtree(cur->left);
        vector<int> rightdp = robtree(cur->right);
        //不偷当前，那么可偷可不偷孩子节点
        int not_do = max(leftdp[0],leftdp[1])+max(rightdp[0],rightdp[1]);
        //偷当前，那么不能偷左右孩子
        int do_it = cur->val+leftdp[0]+rightdp[0];
        return {not_do,do_it};
    }
    int rob(TreeNode* root) {
        vector<int> result = robtree(root);
        return max(result[0],result[1]);
    }
};

• 自己实现过程中遇到哪些困难

• 今日收获，记录一下自己的学习时长