leetcode198/213/337：打家劫舍系列解题

// LeetCode198.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>

/***************************************************************************************************************
//打家劫舍I
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，
如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。
示例 2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

     [2,1,1,2] 就偷：2+2


提示：
0 <= nums.length <= 100
0 <= nums[i] <= 400
******************************************************************************************************************/

#include <vector>
#include <algorithm>
using namespace std;

class Solution1 {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 0)            return 0;
        if (nums.size() == 1)            return nums[0];
        if (nums.size() == 2)            return nums[0] > nums[1] ? nums[0] : nums[1];

        vector<int> dp(nums.size(), 0);
        dp[0] = nums[0];
        dp[1] = nums[0] > nums[1] ? nums[0] : nums[1];
        for (size_t i = 2; i < nums.size(); i++)
        {
            dp[i] = std::max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp[nums.size() - 1];
    };
};


/***************************************************************************************************************
//213、打家劫舍II
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。
同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
示例 1:
输入: [2,3,2]
输出: 3
解释: 你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
示例 2:
输入: [1,2,3,1]
输出: 4
解释: 你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
     偷窃到的最高金额 = 1 + 3 = 4 。
****************************************************************************************************************/

class Solution2 {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 0)            return 0;
        if (nums.size() == 1)            return nums[0];
        if (nums.size() == 2)            return nums[0] > nums[1] ? nums[0] : nums[1];

        vector<int> dp1(nums.size(), 0);
        dp1[0] = 0;
        dp1[1] = nums[1];
        dp1[2] = nums[1] > nums[2] ? nums[1] : nums[2];
        for (size_t i = 3; i < nums.size(); i++)
        {
            dp1[i] = std::max(dp1[i - 1], dp1[i - 2] + nums[i]);
        }

        vector<int> dp2(nums.size(), 0);
        dp2[0] = nums[0];
        dp2[1] = nums[0] > nums[1] ? nums[0] : nums[1];
        for (size_t i = 2; i < nums.size()-1; i++)
        {
            dp2[i] = std::max(dp2[i - 1], dp2[i - 2] + nums[i]);
        }
        dp2[nums.size() - 1] = dp2[nums.size() - 2];
        return dp2[nums.size() - 1] > dp1[nums.size() - 1] ? dp2[nums.size() - 1] : dp1[nums.size() - 1];
    }
};

/****************************************************************************************************************
337. 打家劫舍 III
在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 
除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。
如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例 1:
输入: [3,2,3,null,3,null,1]

     3
    / \
   2   3
    \   \
     3   1

输出: 7
解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.
示例 2:
输入: [3,4,5,1,3,null,1]

     3
    / \
   4   5
  / \   \
 1   3   1

输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.
****************************************************************************************************************/


// Definition for a binary tree node.
struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
public:
    int rob(TreeNode* root) {
        if (!root)
        {
            return 0;
        }
        if (root && !root->left && !root->right)
        {
            return root->val;
        }
        if (root && root->left && !root->right)
        {
            return std::max(root->val + rob(root->left->left) + rob(root->left->right), rob(root->left));
        }
        if (root && !root->left && root->right)
        {
            return std::max(root->val + rob(root->right->left) + rob(root->right->right), rob(root->right));
        }
        //带上根节点就是比较：root + root->left的子节点 + root->right的子节点
        int left = rob(root->left);
        int right = rob(root->right);
        int withroot = root->val + rob(root->right->left) + rob(root->right->right) + rob(root->left->left) + rob(root->left->right);
        int withoutroot = left + right;
        return std::max(withroot, withoutroot);
    }
};


int main()
{
    //TreeNode a(7), b(5), c(6), d(1), e(2), f(3),g(4);
    //TreeNode* root = &a;
    //a.left = &b;
    //a.right = &c;
    //b.left = &d;
    //b.right = &e;
    //c.right = &g;
    //c.left = &f;


    //TreeNode a(1), b(2);
    //TreeNode* root = &a;
    //a.left = &b;


    //TreeNode a(2), b(1), c(3), g(4);
    //TreeNode* root = &a;
    //a.left = &b;
    //a.right = &c;
    //b.right = &g;

    TreeNode a(1), b(4), c(3), d(2);
    TreeNode* root = &a;
    a.right = &b;
    b.right = &c;
    c.right = &d;

    Solution s;
    cout << s.rob(root) << endl;
}