【无标题】

198.打家劫舍

class Solution {
public:
    int rob(vector<int>& nums) {
        vector<int> dp(nums.size(),0);
        if (nums.size() == 0) return 0;
        if (nums.size() == 1) return nums[0];//必须有，不然当Nums[0]=0时，dp[1]计算不出来。
        dp[0]=nums[0];
        dp[1]=max(nums[0],nums[1]);
        for(int i=2;i<nums.size();i++){
            dp[i]=max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[nums.size()-1];

    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

213.打家劫舍II

用上面基础情况的逻辑写成子函数，数组成环，情况一：包含首不包含尾，包含尾不包含首。

class Solution {
public:
    int robRange(vector<int>& nums,int startIndex,int endInedx){
        if(startIndex==endInedx) return nums[startIndex];
        //if((startIndex+1)==endInedx) return max(nums[startIndex],nums[startIndex+1]);
        vector<int> dp(nums.size(),0);
        dp[startIndex]=nums[startIndex];
        dp[startIndex+1]=max(nums[startIndex],nums[startIndex+1]);
        for(int i=startIndex+2;i<=endInedx;i++){
            dp[i]=max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[endInedx];

    }
    int rob(vector<int>& nums) {
        if(nums.size()==0) return 0;
        if(nums.size()==1) return nums[0];        
        int result1 = robRange(nums, 0, nums.size() - 2); // 情况二
        int result2 = robRange(nums, 1, nums.size() - 1); // 情况三
        return max(result1, result2);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

337.打家劫舍III

后序遍历
暴力法：如果偷父节点，那么下一次递归考虑的就是孙子节点。如果不偷父节点，那么下一次递归考虑的是孩子节点。

class Solution {
public:
    int rob(TreeNode* root) {
        if (root == NULL) return 0;
        if (root->left == NULL && root->right == NULL) return root->val;
        // 偷父节点
        int val1 = root->val;
        if (root->left) val1 += rob(root->left->left) + rob(root->left->right); // 跳过root->left，相当于不考虑左孩子了
        if (root->right) val1 += rob(root->right->left) + rob(root->right->right); // 跳过root->right，相当于不考虑右孩子了
        // 不偷父节点
        int val2 = rob(root->left) + rob(root->right); // 考虑root的左右孩子
        return max(val1, val2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

树形dp的入门题目：在树上进行状态转移，
递归三部曲为框架，其中融合动规五部曲的内容：

1. 确定递归函数的参数和返回值这里我们要求一个节点 偷与不偷的两个状态所得到的金钱，那么返回值就是一个长度为2的数组。其实这里的返回数组就是dp数组。所以dp数组（dp table）以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。
2. 确定终止条件：在遍历的过程中，如果遇到空节点的话，很明显，无论偷还是不偷都是0。这也相当于dp数组的初始化
3. 确定递归顺序：首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算。通过递归左节点，得到左节点偷与不偷的金钱。通过递归右节点，得到右节点偷与不偷的金钱
4. 确定单层递归逻辑：

class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> result = robTree(root);
        return max(result[0], result[1]);
    }
    // 长度为2的数组，0：不偷，1：偷
    vector<int> robTree(TreeNode* cur) {
        if (cur == NULL) return vector<int>{0, 0};
        vector<int> left = robTree(cur->left);
        vector<int> right = robTree(cur->right);
        // 偷cur，那么就不能偷左右节点。
        int val1 = cur->val + left[0] + right[0];
        // 不偷cur，那么可以偷也可以不偷左右节点，则取较大的情况
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);
        return {val2, val1};
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19