LeetCode198. 打家劫舍&&213. 打家劫舍 II&&337. 打家劫舍 III

198. 打家劫舍

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

class Solution {
public:
    //DP+滚动数组优化: 时间O(n), 空间O(1)
    int rob(vector<int>& nums) {
        if(nums.size() == 0) return 0;
        if(nums.size() == 1) return nums[0];
        int first = nums[0];
        int second = max(nums[0], nums[1]);
        //dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
        for(int i = 2; i < nums.size(); i++) {
            int temp = max(second, first + nums[i]);
            first = second;
            second = temp;
        }
        return second;
    }
};

213. 打家劫舍 II

class Solution {
public:
    int rob(vector<int>& nums) {
        int len = nums.size();
        if(len == 0) return 0;
        if(len == 1) return nums[0];
        if(len == 2) return max(nums[0], nums[1]);
        // res = max(不偷第一家，不偷最后一家));
        return max(helper(nums, 0, len - 2), helper(nums, 1, len - 1));
    }
private:
    int helper(const vector<int>& nums, int start, int end) {
        int first = nums[start];
        int second = max(nums[start], nums[start + 1]);
        for(int i = start + 2; i <= end; i++) {
            int temp = max(second, first + nums[i]);
            first = second;
            second = temp;
        }
        return second;
    }
};

337. 打家劫舍 III

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    unordered_map<TreeNode*, int> memo;
    int rob(TreeNode* root) {
        if(root == nullptr) return 0;
        if(memo.count(root))
            return memo[root];
        //抢根节点，然后去孙子节点
        int do_it = root->val;
        if(root->left) {
            do_it += rob(root->left->left) + rob(root->left->right); 
        }
        if(root->right) {
            do_it += rob(root->right->left) + rob(root->right->right);
        }
        //不抢根节点，然后去儿子节点
        int not_do = rob(root->left) + rob(root->right);

        int res = max(do_it, not_do);
        memo[root] = res;
        return res;
    }
};