leetcode198. 213 337打家劫舍

198.打家劫舍I
https://leetcode-cn.com/problems/house-robber/
动态规划。

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

f[i]表示前i家可得最大钱数。对于第 i 家来说，有两种选择：
（1）打劫第 i 家，那么第 i-1家就不能打劫，那么总钱数为 f[i-2]+nums[i]
（2）不打劫第i家，那么总钱数为f[i-1]
则到第 i 家最大钱数为 max(f[i-1],f[i-2]+nums[i])
还可以优化，用两个变量代替一维数组
https://leetcode.com/problems/house-robber/discuss/55695/JAVA-DP-Solution-O(n)-runtime-and-O(1)-space-with-inline-comment

213.打家劫舍II
https://leetcode-cn.com/problems/house-robber-ii/
参考：https://leetcode.com/problems/house-robber-ii/discuss/59921/9-lines-0ms-O(1)-Space-C%2B%2B-solution
和198一样，只不过因为最后一个和第一个是相连的，因此最后一个和第一个不能同时抢。则分别求0—n-2（不抢最后一家）和1—n-1（不抢第一家），然后取两者较大值即可。

337.打家劫舍III
https://leetcode-cn.com/problems/house-robber-iii/
代码参考：
https://leetcode.com/problems/house-robber-iii/discuss/79330/Step-by-step-tackling-of-the-problem
解释参考：
https://blog.csdn.net/qq_36309480/article/details/87976654

1. rob表示以root为根节点的树所能得到的最大钱数，有两种情况：
   （1）抢劫root节点，那么他的两个孩子就不能抢，它的孩子的孩子需要抢，此时的总钱数的四个孩子为根节点的钱的和在加上自己的值
   （2）不抢劫root节点，那么应该抢劫它的两个孩子，此时的总钱数是两个孩子为根节点的和
   最后两者取较大值
   用到了DFS

public int rob(TreeNode root) {
    if (root == null) return 0;
        
    int val = 0;    
    if (root.left != null) {
        val += rob(root.left.left) + rob(root.left.right); //左边两个孙子的总钱数
    }    
    
    if (root.right != null) {
        val += rob(root.right.left) + rob(root.right.right); //右边两个孙子的总钱数
    }    
    
    return Math.max(val + root.val, rob(root.left) + rob(root.right));//第一个值对应抢root节点，第二个对应不抢root节点
}

这种从上至下的递归会有很多重复子问题

改进：
robSub表示root为根的树最多可以得到多少钱，他会返回一个包含两个元素的数组，第一个元素res[0]表示不抢root节点可以得到的钱，第二个元素表示抢root元素可以得到的钱

res[0]不打劫root节点。按理说如果不打劫root,那么应该打劫root->left和root->right，即应该取left[1]+right[1],但是这里取了个max，不太明白

public int rob(TreeNode root) {
    int[] res = robSub(root);
    return Math.max(res[0], res[1]);
}

private int[] robSub(TreeNode root) {
    if (root == null) return new int[2];
    
    int[] left = robSub(root.left);
    int[] right = robSub(root.right);
    int[] res = new int[2];

    res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]); //res[0]不打劫root节点。按理说如果不打劫root,那么应该打劫root->left和root->right，即应该取left[1]+right[1],但是这里取了个max，不太明白
    res[1] = root.val + left[0] + right[0]; //res[1]表示打劫root节点。left[0]表示不抢root->left可以得到的钱（对应第一段代码中root->left->left+root->left->right 所得钱总和），right[0]表示不抢root->right可以得到的钱    
    return res;
}