leetcode-动态规划-打家劫舍问题

198. 打家劫舍

class Solution {
public:
    int rob(vector<int>& nums) {
        int size = nums.size();
        if(size == 0){
            return 0;
        }
        int dp[size+2];
        memset(dp, 0 ,sizeof(dp));
        // base case: dp[n] = 0
        // dp数组：dp[i] 表示从第i间房子开始抢劫
        for(int i = size - 1; i >= 0;i--){
            dp[i] = max(dp[i+1], dp[i+2]+nums[i]);
        }
        return dp[0];
    }
};

213. 打家劫舍 II

环形

class Solution {
public:
    int rob(vector<int>& nums) {
        // 头尾只会被抢一所
        int size = nums.size();
        if(size == 0){
            return 0;
        }
        if(size == 1){
            return nums[size-1];
        }
        return max(robRange(nums, 0, size-2), robRange(nums, 1, size-1)); // 可以抢这些下标范围的房子
    }

    int robRange(vector<int>& nums, int begin, int end){
        int size = nums.size();
        int dp[size+2];
        memset(dp, 0, sizeof(dp));

        for(int i = end; i >= begin; i--){
            dp[i] = max(dp[i+1], dp[i+2]+nums[i]);
        }
        return dp[begin];
    }
};

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 == NULL){
            return 0;
        }
        // 备忘录中找到了结果
        if(memo.find(root) != memo.end()){
            return memo[root];
        }
        // 备忘录中没有，要开始抢了
        // 抢这个节点，跳过相连的，去抢其他的
        int doIt = root->val + (root->left == NULL ? 0 : rob(root->left->left) + rob(root->left->right)) + (root->right == NULL ? 0 : rob(root->right->left) + rob(root->right->right));
        // 这个节点不抢，去抢其他的
        int notDo = rob(root->left)+ rob(root->right);
		// 两者取大的
        int res = max(doIt, notDo);
        // 备忘录记录
        memo[root] = res;
        return res;
    }
};