算法Day48 | 198.打家劫舍,213.打家劫舍II,337.打家劫舍III

Day48

    • 198.打家劫舍
    • 213.打家劫舍II
    • 337.打家劫舍III

198.打家劫舍

题目链接: 198.打家劫舍
dp数组i个房间,可以偷到金钱最大为dp[i]需要强调的是dp[i]并不等价于一定要偷i房间,只是表示包含了i个房间,是否偷了房间,是通过nums[i]来表示的

递推公式

  • i房间:dp[i - 2] + nums[i]
  • 不偷i房间:dp[i - 1]
    最终公式为dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])

初始化dp[0] = nums[0],dp[1] = max(nums[0], nums[1])

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 1) return nums[0];
        vector<int> dp{nums[0], max(nums[0], nums[1])};
        dp.resize(nums.size());//不是nums.size() + 1,是因为dp是按照nums对应求得的
        for (int i = 2; i < nums.size(); ++i) {
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp.back();
    }
};

213.打家劫舍II

题目链接:213.打家劫舍II
本题为环形循环,表示首、尾不能同时选择,讨论选择首、尾的最大值即可。

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

337.打家劫舍III

题目链接:337.打家劫舍III
树形dp,本题和968.监控二叉树 类似

dp数组
每个节点只有两个状态:偷、不偷,用dp[0]表示不偷当前节点获得最大金钱,dp[1]表示偷当前节点获得最大金钱。这就是整个二叉树的dp数组:因为当前节点可以通过该节点的父节点得到,因此只需知道其父节点的状态,就可以得到当前节点状态。
dp数组为dp{不偷, 偷}

初始化
对于叶子节点来说,由于没有子节点,因此初始化为{0, 0}

遍历顺序:由于是二叉树,最后递归到根节点,因此采用后序遍历

class Solution {
    vector<int> postOrder(TreeNode* cur) {
        if (!cur) return {0, 0};//初始化
        auto left = postOrder(cur->left);
        auto right = postOrder(cur->right);
        //偷当前节点
        int val1 = cur->val + left[0]/*不偷左子节点*/ + right[0]/*不偷右子节点*/;
        //不偷当前节点
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);
        return {val2, val1};
    }
public:
    int rob(TreeNode* root) {
        return max(postOrder(root)[0]/*不偷根节点*/, postOrder(root)[1]/*偷根节点*/);
    }
};

你可能感兴趣的:(刷题日志,算法,leetcode,数据结构,c++,动态规划)