代码随想录第48天

198. 打家劫舍

题解

class Solution {
public:
    int rob(vector<int>& nums) {
        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];

    }
};

思路

①dp[i]:考虑下标为[0,i]的房间，可以偷的最大金额
②递推公式:
第i间房子偷，则dp[i] = dp[i - 2] + nums[i]
第i间房子不偷，则dp[i] = dp[i - 1]

注意

①dp[i] = dp[i - 1]时，不一定偷第i - 1间房，有可能dp[i - 1] = dp[i - 3] + nums[i - 1]或者是dp[i - 1] = dp[i - 2]，即在第i - 1间房时，可能偷第i - 1间房的金币，也可能偷的是i - 2间房子的金币
②若要连续偷两个房间的金币，则dp[i] = dp[i - 3] + nums[i - 1] + dp[i - 2] + nums[i]，但是由于递推公式可知，出现的情况是dp[i] = dp[i - 2] + nums[i] 或 dp[i] = dp[i - 1] = dp[i - 3] + nums[i - 1]，因此不会出现连续偷两个房间的情况

213. 打家劫舍 II

题解

class Solution {
public:
    int rob(vector<int>& nums) {
        int len = nums.size();
        if(nums.size() == 1)    return nums[0];
        vector<int> nums1(nums.begin(), nums.end() - 1);
        vector<int> nums2(nums.begin() + 1, nums.end());
        int result1 = subRub(nums1);
        int result2 = subRub(nums2);
        return max(result1,result2);
    }
    int subRub(vector<int>& subNums)
    {
        if(subNums.size() == 1)
            return subNums[0];
        vector<int> dp(subNums.size(),0);
        dp[0] = subNums[0];
        dp[1] = max(subNums[0],subNums[1]);
        for(int i = 2;i < subNums.size();i++)
        {
            dp[i] = max(dp[i - 1],dp[i - 2] + subNums[i]);
        }
        return dp[subNums.size() - 1];
    }
};

或

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

思路

①由于本题中房间成环了，因此房间有以下三种情况：



其中每种情况不一定要选择其中的尾部或者首部元素，因此情况2和3包含了情况1，即本题只需考虑情况2和3.
②对于以上两种情况，每种情况都是一次198. 打家劫舍，因此只需最后选择两种情况中的最大值即可

337. 打家劫舍 III

题解

/**
 * 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:
    vector<int> robTree(TreeNode* cur)
    {
        // 返回值：
        // dp[0]:当前节点偷的情况下获取的最大值
        // dp[1]:当前节点不偷的情况下获取的最大值
        // 终止条件
        if(cur == NULL) return {0,0};

        // 后序遍历
        // 左
        vector<int> leftdp = robTree(cur->left);
        // 右
        vector<int> rightdp = robTree(cur->right);
        // 中
        // 偷
        int result1 = cur->val + leftdp[1] + rightdp[1];
        // 不偷
        int result2 = max(leftdp[0],leftdp[1]) + max(rightdp[0],rightdp[1]);// 因为当前节点不偷，所以考虑与之相连的两个子节点是否要偷，两个子节点是否要偷取决于两个子节点在偷和不偷两种情况下的最大值

        return{result1,result2};

    }
    int rob(TreeNode* root) {
        vector<int> dp = robTree(root);
        return max(dp[0],dp[1]);
    }
};

思路

① 具体看题解中的注释
② 遍历顺序：由于需要先判断子节点的情况，因此二叉树选择后序遍历