代码随想录算法训练营第三十九天|打家劫舍

打家劫舍 leetcode 198

dp[i]含义：房间i之前以及i可以偷到的最高金额为dp[i]。

递推公式：首先考虑偷i房间的话，偷到的最大金额为：nums[i]+dp[i-2]，不偷i房间的话，偷到的最大金额为：dp[i-1]，则递推公式：dp[i]=max(dp[i-1],nums[i]+dp[i-2]);

初始化：dp[0]=nums[0]，只有一个房间只能选择偷，dp[1]=max(nums[0],nums[1])，有两个房间选钱多的偷。非0和非1dp数组初始化为0防止max将正确的值覆盖。

遍历顺序：从小到大。

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

因为数组是从下标0开始，那么我们要求得就是dp[nums.size()-1]。

打家劫舍Ⅱ leetcode 213

思路：与上一题不同得是，房间连成一个环，相邻的不能都偷。那么一共有三种情况：

情况一：首元素和尾元素不选，只考虑中间元素最优解。

情况二：不选尾元素，只考虑首元素和中间元素的最优解。

情况三：不选首元素，只考虑中间元素和尾元素的最优解。

我们仔细分析上述三种情况，发现情况二和情况三是包含情况一的，例如情况二只考虑首元素和中间元素的最优解，里面肯定会包含不选首元素的情况就和情况一相同了，因为dp[i]的含义是房间i之前以及i可以偷到的最高金额为dp[i]。我们可以取首元素也可以不取。情况三同理也包含情况一。

此时我们只要求情况二的最优解以及情况三的最优解然后取一个最大值就可以了。

遇到环形问题不好处理时，可以将其展开，分别考虑几种情况！

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-1],dp[i-2]+nums[i]);
        }
        return dp[end];
    }
    int rob(vector<int>& nums) {
        if(nums.size()==0) return 0;
        if(nums.size()==1) return nums[0];
        int res1=robRange(nums,0,nums.size()-2);
        int res2=robRange(nums,1,nums.size()-1);
        return max(res1,res2);
    }
};

我们直接copy打家劫舍Ⅰ的代码，传入情况二和情况三的参数范围最后取最大值。

打家劫舍Ⅲ leetcode 337

思路：遍历的每个节点有两个状态偷或者不偷。只需要一个长度为2的一维dp数组即可，使用递归函数层层覆盖后序遍历最后回到根节点，选择偷或者不偷的最大值。

dp含义：dp[0]表示不偷当前节点能够获得的最大金额，dp[1]表示偷当前节点能够获得的最大金额。

class Solution {
public:
    vector<int> traversal(TreeNode* cur){
        if(cur==nullptr) return vector<int>{0,0};
        vector<int> leftdp=traversal(cur->left);
        vector<int> rightdp=traversal(cur->right);
        int val1=cur->val+leftdp[0]+rightdp[0];
        int val2=max(leftdp[0],leftdp[1])+max(rightdp[0],rightdp[1]);
        return {val2,val1};
    }
    int rob(TreeNode* root) {
        vector<int> res=traversal(root);
        return max(res[0],res[1]);
    }
};

递归函数：首先确定返回值，根据思路中返回值应该是一个大小为2的vector<int>类型容器数组。

后序遍历左右中，中间要执行的单层逻辑就是：

选择偷当前节点能够获取的最大金额为val1，也就是当前节点的值加上其左子树以及右子树能够获得的最大金额。

选择不偷当前节点，就是偷左孩子节点能够获得的最大价值加上偷右孩子节点能够获得的最大金额。