团灭leetcode打家劫舍问题

参考：https://labuladong.gitbook.io/algo/dong-tai-gui-hua-xi-lie/qiang-fang-zi

///打家劫舍1 leetcode 198
//状态：当前房子index. 选择：抢或者不抢
// dp数组定义：dp[i] 表示从第i间开始抢, 能抢到的最多的钱.
// dp[i] = max(抢i, 不抢i) = max(nums[i] + dp[i+2], dp[i+1])
int rob(vector<int>& nums) {
//    int n = nums.size();
//    vector<int> dp(n + 2, 0);
//    //反向遍历
//    for(int i = n-1; i >= 0; i--) {
//        dp[i] = max(nums[i] + dp[i+2], dp[i+1]);
//    }
//    return dp[0];

    //solution2 优化空间复杂度
    int dp_i = 0, dp_i_1 = 0, dp_i_2 = 0;
    for(int i = nums.size() - 1; i >= 0; i--) {
        dp_i = max(nums[i] + dp_i_2 , dp_i_1 );
        dp_i_2 = dp_i_1;
        dp_i_1 = dp_i;
    }
    return dp_i;
}

///打家劫舍2 leetcode 213
/*第一个和最后一个房子不能同时抢, 那么最优结果= max(不抢第一个, 不抢最后一个).
 * 两个都不抢的结果明显<=上述两种情况, 因为nums是非负数组.
 * res = max( rob(nums[0..n-2]), rob(nums[1..n-1]) )*/
//计算nums在[start, end]闭区间内的最优结果
int compute(vector<int>& nums, int start, int end) {
    int dp_i = 0, dp_i_1 = 0, dp_i_2 = 0;
    for(int i = end; i >= start; i--) {
        dp_i = max(nums[i] + dp_i_2 , dp_i_1 );
        dp_i_2 = dp_i_1;
        dp_i_1 = dp_i;
    }
    return dp_i;
}
int rob2(vector<int>& nums) {
    int n = nums.size();
    if(n == 1) return nums[0];
    return max(compute(nums, 0, n-2), compute(nums, 1, n-1));
}

///打家劫舍3 leetcode 337
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
map<TreeNode*, int> dict;
//rob3(root) : 以root为起点，能获得的最大收益。
//当前节点抢不抢，取决于哪种方式收益更大。
int rob3(TreeNode* root) {
    if(root == NULL) return 0;
    if(dict.find(root) != dict.end())
        return dict[root];
    //抢当前节点, 那么其左右子节点不能抢
    int do_it = root->val + (root->left == NULL ? 0 : rob3(root->left->left) + rob3(root->left->right))
            + (root->right == NULL ? 0 : rob3(root->right->left) + rob3(root->right->right));
    //不抢当前节点
    int not_do = rob3(root->left) + rob3(root->right);
    dict[root] = max(do_it, not_do);
    return max(do_it, not_do);
}