[Leetcode] 139. 单词拆分、198.打家劫舍、213.打家劫舍II、337.打家劫舍III

139. 单词拆分

排列问题

容量：拼接单词长度

物品：单词

dp：背包容量为 i，是否装满为true

class Solution {
public:
    bool wordBreak(string s, vector& wordDict) {
        unordered_set wordSet(wordDict.begin(), wordDict.end());
        vector dp(s.size()+1, false);
        dp[0] = true;
        for(int i=1; i<=s.size(); ++i) {
            for(int j=0; j

198. 打家劫舍

dp：第i间房间以内，所能获取到的最大金额

递推：偷第i间，就不能偷第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& nums) {
        if(nums.size()==0) return 0;
        if(nums.size()==1) return nums[0];
        vector dp(nums.size(), 0);
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for(int i=2; i

213. 打家劫舍 II

这题的区别是需要分开考虑，一种考虑首元素；一种不考虑首元素

class Solution {
public:
    int calMoney(vector& nums, int begin, int end) {
        if(end==begin) return nums[begin];
        vector dp(nums.size());
        dp[begin] = nums[begin];
        dp[begin+1] = max(nums[begin], nums[begin+1]); 
        for(int i=begin+2; i<=end; ++i) {
            dp[i] = max(dp[i-2]+nums[i], dp[i-1]);
        }
        return dp[end];
    }

    int rob(vector& nums) {
        if(nums.size()==0) return 0;
        if(nums.size()==1) return nums[0];
        int result0 = calMoney(nums, 1, nums.size()-1);
        int result1 = calMoney(nums, 0, nums.size()-2);
        return max(result0, result1);
    }
};

337. 打家劫舍 III

dp数组（dp table）以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱

dp：0为不偷该节点的最大金额；1为偷该节点的最大金额

递归：

如果此节点偷了，子节点不能偷 cur->val + left[0] + left[1]

如果此节点没偷，子节点可偷可不偷 max(left[0], left[1]) + max(right[0], right[1])

每层返回值{没偷，偷}

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int rob(TreeNode* root) {
        vector result = robTree(root);
        return max(result[0], result[1]);

    }

    vector robTree(TreeNode* cur) {
        if(cur==nullptr) return {0, 0};
        vector left = robTree(cur->left);
        vector right = robTree(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};

    }

};