动态规划Day29：打家劫舍

198. 打家劫舍

dp $i$ 代表从0到i所获取的最大金额

初始化dp $0$ ,dp $1$ 。

状态转移：当前房屋偷不偷：偷->取i-2房屋的dp + 当前房屋的金额，不偷->取i-1的dp

cpp 复制代码

    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(dp[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];
    }

213. 打家劫舍 II

与1类似，只是需要将环解开，一共n个，可以分为0~n-2和1~n-1。寻求这两个区间段的最大值，取更大的那个

cpp 复制代码

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

337. 打家劫舍 III

后序遍历暴力法超时,因为包含了两边递归

cpp 复制代码

    int rob(TreeNode* root) {
        if(root == nullptr){
            return 0;
        }
        if (root->left == NULL && root->right == NULL) return root->val;
        //不取父节点
        int r = 0, l = 0;
        if(root->left){
            l = rob(root->left);
        }
        if(root->right){
            r = rob(root->right);
        }
        int val1 = r + l;
        //取父节点
        int val2 = 0;
        val2+=root->val;
        if(root->left) {
            val2 += rob(root->left->right) + rob(root->left->left);
        }
        if(root->right){
            val2 += rob(root->right->left) + rob(root->right->right);
        }
        return max(val1, val2);
    }

动态规划

树形动态规划，每个结点保存两个内容，偷当前的价值，与不偷的价值，这样就可以省去重复递归计算的时间

cpp 复制代码

    vector<int> robTree(TreeNode* cur){
        if(cur == nullptr){
            return vector<int>{0, 0};
        }
        vector<int> left = robTree(cur->left);
        vector<int> right = robTree(cur->right);
        //偷cur
        int val1 = cur->val + left[1] + right[1];
        //不偷cur
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);
        return {val1, val2};
    }
    int rob(TreeNode* root) {
        vector<int> res = robTree(root);
        return max(res[0], res[1]);
    }