算法训练营day48 第九章 动态规划part9

第一题：198.打家劫舍

        这道题可以用动态规划来解决，比较容易想到。直接就可以写出代码：

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        //dp[i]表示从前i个房屋中偷盗的最大金额
        vector<int> dp(n + 1);
        dp[1] = nums[0];
        for(int i = 2; i <= n; i++) {
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i - 1]);
        }
        return dp[n];
    }
};

还可以对上述代码进行优化，使用滚动数组，使得空间复杂度为常数级别。优化后的代码为：

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

第二题：213.打家劫舍Ⅱ

        这道题和上一题相比，多了一个限制条件，即：开头和结尾元素也是相邻的，不能同时选取。这道题就变成了需要考虑环形结构，为了简化，还是要将环形结构转化为线性结构再来思考。那么就有以下这三种情况需要考虑：

（1）、不考虑首部和尾部的元素，只从中间选取

（2）、从除了第一个元素外的其他元素中选取

（3）、从除了最后一个元素外的其他元素中选取

仔细分析一下就会发现，其实情况（2）和情况（3）是包含了情况（1）的，那么我们就只用分析后两种情形了。对后两种情况，分别用第一题的思路来解决就ok了。

代码如下：

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

第三题：337.打家劫舍Ⅲ

        这道题是一道树形dp问题，需要结合动态规划以及递归的方法来解题。按照递归三部曲来写一下递归函数。

（1）确定函数的参数和返回值：该递归函数参数为二叉树的节点，返回值为一个大小为2的vector<int>数组，数组的首个元素表示不偷这个节点时获取到的最大价值，尾部元素表示偷这个节点时获取到的最大价值；

（2）确定终止条件：当该节点为nullptr时，此时就是终止的条件，应该返回{0， 0}；

（3）确定单层递归的逻辑：单层递归的逻辑在于，要获取偷这个节点时的最大价值，以及不偷这个节点时的最大价值。能够发现，每个节点的值是依赖于它的两个子节点，所以应该采取后序遍历的方法，从下往上遍历，这样才能满足我们的需求。

代码如下：

class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> dp = postOrder(root);
        return max(dp[0], dp[1]);
    }
private:
    //返回一个大小为2的数组dp[2]
    //dp[0]表示不偷该节点的情况下获取的最高金额
    //dp[1]表示偷该节点的情况下获取的最高金额
    vector<int> postOrder(TreeNode* root) {
        if(!root) return {0, 0};
        vector<int> leftVal = postOrder(root->left);
        vector<int> rightVal = postOrder(root->right);
        int stealThisNode = root->val + leftVal[0] + rightVal[0];
        int nostealThisNode = max(leftVal[0], leftVal[1]) + max(rightVal[0], rightVal[1]);
        return {nostealThisNode, stealThisNode};
    }
};

        Day48打卡！！！