Leetcode 337. 打家劫舍Ⅲ的两种解法

解法一

该解法借鉴自labuladong的算法小抄 ¹ ，我采用C++进行改写，较容易理解。
思想比较简单易懂，主要是分为两种情况

1. 自己加上自己的孙子
2. 自己的两个儿子

比较这两个值的大小，取大的那个，对每个节点都这么做，递归下去。
由于这里会有很多个对儿子做过的操作再对孙子做，因此，采用备忘录将算过的最大值存起来。
代码如下所示：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    map<TreeNode*,int> memo;
    int rob(TreeNode* root) {
        if(root == nullptr)
            return 0;
        if(memo.find(root)!=memo.end())
            return memo[root];
        int do_it = root->val + 
                    (root->left == NULL? 0 : (rob(root->left->left) + rob(root->left->right))) +
                    (root->right == NULL?0:(rob(root->right->left)+rob(root->right->right))) ;
        int not_do = rob(root->left) + rob(root->right);

        int max = do_it>not_do?do_it:not_do;
        memo.insert(pair<TreeNode*,int>(root,max));
        return max;
    }
};

这里do_it 和 not_do 代表的意思分别是第一种和第二种情况。

解法二

第二种解法较难理解，这里是我自己写出来的解法，时间复杂度和空间复杂度并不低，但是在此记录下，以拓宽思维。
通过两个函数互相递归调用，实现上面的两种情况。
主函数rob是求当前结点返回能偷的最大值，辅助函数是调用了主函数。

1. 算出左边节点能偷的最大值，右边节点能偷的最大值。两个加一起就是第二种情况。
2. 把左边节点的儿子能偷的最大值，右边节点的儿子能偷的最大值，两个加一起再加上自己的值就是第一种情况。

通过这两种情况，比较出最大值。
code如下：

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

 //要么自己也算，要么自己不算
 //自己算的话，左右子树不能算，自己不算的话，左右子树可以算
class Solution {
public:
    int max = 0;
    map<TreeNode*,int> memo;
    int rob_au(TreeNode* root)
    {
        if(root == nullptr)
            return 0;
        int noself = 0;
        int ltree = rob(root->left);
        int rtree = rob(root->right);
        noself = ltree+rtree;
        return noself;
    }
    int rob(TreeNode* root) {
        if(root == nullptr)
            return 0;
        if(memo.find(root)!=memo.end())
            return memo[root];
        int noself = rob_au(root);

        int self = 0;
        int ll = rob_au(root->left);
        int rr = rob_au(root->right);
        self = ll+rr+root->val;

        max = noself>self?noself:self;
        memo.insert(pair<TreeNode*,int>(root,max));
        return max;
    }
};

---

1. labuladong的算法小抄 ↩︎