打家劫舍三部曲

打家劫舍 I

一条街道，不能偷相邻房屋，问可以取得的最大钱数。
打家劫舍 I

分析：

1. dp[i]: 偷前 i 个房间可以获得的最大钱数；
2. 是否偷第i个房间，由dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]]);

int rob(vector<int>& nums) {
        // dp[i] : 偷前 i 个房间，可以获得的最大利润
        int n = nums.size();
        vector<int> dp(n, 0);
        if(n == 0)
            return 0;
        if(n == 1)
            return nums[0];
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for(int i = 2; i < nums.size(); ++i){
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp[n - 1];
    }

打家劫舍 II

环形街道（最后一个房屋与第一个相邻），不可偷相邻房屋，问可以取得的最大钱数。
打家劫舍 II
与版本1 的区别就是头尾相连了，只需要做两次版本1的计算，一次包括头不包括尾，一次包括尾不包括头。

int rob(vector<int>& nums) {
        int n = nums.size();
        if(n == 0)      return 0;
        if(n == 1)      return nums[0];
        if(n == 2)      return max(nums[0], nums[1]);
        int res1 = helper(nums, 0, n - 2);
        int res2 = helper(nums, 1, n - 1);
        int res = max(res1, res2);
        return res;
    }

    int helper(vector<int>& nums, int l, int r){
        vector<int> dp(nums.size(), 0);
        dp[l] = nums[l];
        dp[l + 1] = max(nums[l], nums[l + 1]);
        for(int i = l + 2; i <= r; ++i)
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
        return dp[r];
    }

打家劫舍 III

二叉树式分布的房屋，不可偷直接相连的房屋，问可以取得的最大钱数。
打家劫舍 III

此题需要后序遍历，因为我们需要子节点的返回值进行计算。
代码思想已在代码中注释：

int rob(TreeNode* root) {
        if(!root)   return 0;
        vector<int> res = helper(root);
        return max(res[0], res[1]);
    }

    // 后序遍历
    // 1. dp是一个长度为 2 的数组，下标为0表示不偷该节点，下标为1表示偷该节点。
    vector<int> helper(TreeNode* cur){
        if(!cur)
            return vector<int> {0, 0};
        vector<int> l = helper(cur -> left);
        vector<int> r = helper(cur -> right);
        int val1 = cur -> val + l[0] + r[0];    // 偷该节点
        int val2 = max(l[0], l[1]) + max(r[0], r[1]);  // 不偷该节点
        return {val2, val1};
    }