力扣337题：打家劫舍（3）

力扣337题：打家劫舍（3）

题目描述

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。

给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。

输入输出样例

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

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

解法一：使用递归

//使用递归的思想完成，代码会出现超时
//自顶向下的思想
class Solution
{
public:
    int rob(TreeNode *root )
    {
        if(!root)
        {
            return 0;
        }
        int money=root->val;

        if(root->left)
        {
            money+=(rob(root->left->left)+rob(root->left->right));
        }
        if(root->right)
        {
            money+=(rob(root->right->left)+rob(root->right->right));
        }
    //四个孙子偷的钱+爷爷偷的钱VS两个儿子偷的钱，那个偷的钱最多，当作当前结点的最大钱数
    //这一步便是在比较第二层和第三层的值的大小
        return max(money,rob(root->left)+rob(root->right));
    }
};

解法二，使用记忆化+递归

//因为爷爷在计算自己能偷多少钱的时候，同时也计算了4个孙子能偷多少钱和2个儿子能投多少钱
class Solution2
{
public:
//建立hash表将每次计算的结果都存储进来
    int rob(TreeNode *root)
    {
        unordered_map<TreeNode *,int>map;
        return robInternal(root,map);

    }

    int robInternal(TreeNode *root,unordered_map<TreeNode *,int>&map)
    {
        if(!root)
        {
            return 0;
        }
        if(map.count(root))
        {
            return map[root];
        }

        int money=root->val;
        if(root->left)
        {
            money+=(robInternal(root->left->left,map)+robInternal(root->left->right,map));
        }

        if(root->right)
        {
            money+=(robInternal(root->right->left,map)+robInternal(root->right->right,map));
        }
        int result=max(money,robInternal(root->left,map)+robInternal(root->right,map));
        map[root]=result;
        return result;
    }
};

解法三，使用动态规划

class Solution3
{
public:
    int rob(TreeNode *root )
    {
        vector<int>res=robInternal(root);
        return max(res[0],res[1]);
    }
//当前结点选择偷，则两个孩子节点不能选择偷
//      当前结点能偷到的最大钱数=左孩子选择自己不偷时能得到的钱+右孩子选择不偷时能得到的钱+当前节点的钱数
//当前结点选择不偷，则只需要两个孩子结点能拿出的最多钱即可
//      当前结点能偷到的最大钱数=左孩子能偷到的钱+右孩子能偷到的钱
    vector<int>robInternal(TreeNode*root)
    {
        if(!root)
        {
            return vector<int>(2,0);
        }

        vector<int>res(2,0);

//这样一直遍历到最底部
//从最底部中开始选
        vector<int>left=robInternal(root->left);
        vector<int>right=robInternal(root->right);

        res[0]=max(left[0],left[1])+max(right[0],right[1]);
        res[1]=left[0]+right[0]+root->val;
        return res;
    }
};