337.打家劫舍·动态规划

题目

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/house-robber-iii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

示例

思路

简化一下这个问题：一棵二叉树，树上的每个点都有对应的权值，每个点有两种状态（选中和不选中），问在不能同时选中有父子关系的点的情况下，能选中的点的最大权值和是多少。

说明
本题目本身就是动态规划的树形版本，通过此题解，可以了解一下树形问题在动态规划问题解法
我们通过三个方法不断递进解决问题

解法一通过递归实现，虽然解决了问题，但是复杂度太高
解法二通过解决方法一中的重复子问题，实现了性能的百倍提升
解法三直接省去了重复子问题，性能又提升了一步

解法一、暴力递归 - 最优子结构
在解法一和解法二中，我们使用爷爷、两个孩子、4 个孙子来说明问题
首先来定义这个问题的状态
爷爷节点获取到最大的偷取的钱数呢

首先要明确相邻的节点不能偷，也就是爷爷选择偷，儿子就不能偷了，但是孙子可以偷
二叉树只有左右两个孩子，一个爷爷最多 2 个儿子，4 个孙子
根据以上条件，我们可以得出单个节点的钱该怎么算
4 个孙子偷的钱 + 爷爷的钱 VS 两个儿子偷的钱 哪个组合钱多，就当做当前节点能偷的最大钱数。这就是动态规划里面的最优子结构

由于是二叉树，这里可以选择计算所有子节点

4 个孙子投的钱加上爷爷的钱如下
int method1 = root.val + rob(root.left.left) + rob(root.left.right) + rob(root.right.left) + rob(root.right.right)
两个儿子偷的钱如下
int method2 = rob(root.left) + rob(root.right);
挑选一个钱数多的方案则
int result = max(method1, method2);
将上述方案写成代码如下

#define MAX(a , b) ((a) > (b) ? (a) : (b))

int rob(struct TreeNode* root){

    if(!root)

        return 0;

    int m = 0;

    m = root->val;

    if(root->left)

    {

        m += rob(root->left->left) + rob(root->left->right);

    }

    if(root->right)

    {

        m += rob(root->right->left) + rob(root->right->right);

    }

    return MAX(m , (rob(root->left) + rob(root->right)));

}

但是时间开销大，超时了。。。 

解法二、记忆化 - 解决重复子问题
针对解法一种速度太慢的问题，经过分析其实现，我们发现爷爷在计算自己能偷多少钱的时候，同时计算了 4 个孙子能偷多少钱，也计算了 2 个儿子能偷多少钱。这样在儿子当爷爷时，就会产生重复计算一遍孙子节点。

于是乎我们发现了一个动态规划的关键优化点

重复子问题

我们这一步针对重复子问题进行优化，我们在做斐波那契数列时，使用的优化方案是记忆化，但是之前的问题都是使用数组解决的，把每次计算的结果都存起来，下次如果再来计算，就从缓存中取，不再计算了，这样就保证每个数字只计算一次。

解法三、动态规划
上面两种解法用到了孙子节点，计算爷爷节点能偷的钱还要同时去计算孙子节点投的钱，虽然有了记忆化，但是还是有性能损耗。

我们换一种办法来定义此问题

每个节点可选择偷或者不偷两种状态，根据题目意思，相连节点不能一起偷

当前节点选择偷时，那么两个孩子节点就不能选择偷了
当前节点选择不偷时，两个孩子节点只需要拿最多的钱出来就行(两个孩子节点偷不偷没关系)

struct SubtreeStatus {

        int selected;//偷

        int notSelected;//不偷

};

任何一个节点能偷到的最大钱的状态可以定义为

当前节点选择不偷：当前节点能偷到的最大钱数 = 左孩子能偷到的钱 + 右孩子能偷到的钱
当前节点选择偷：当前节点能偷到的最大钱数 = 左孩子选择自己不偷时能得到的钱 + 右孩子选择不偷时能得到的钱 + 当前节点的钱数

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
 
/* 记录节点最高金额 */
struct status {
    int select;
    int notselect;
};

struct status dfs(struct TreeNode* root) {
    /* 节点为空，返回0 */
    if (root == NULL) {
        return (struct status){0, 0};
    }
    /* 依次遍历左右子树 */
    struct status l = dfs(root->left);
    struct status r = dfs(root->right);
    /* 选择当前节点所得金额 */
    int select    = root->val + l.notselect + r.notselect;
    /* 不选择当前节点所得金额 */
    int notselect = fmax(l.select, l.notselect) + fmax(r.select, r.notselect);
    /* 返回当前节点两种所得金额 */
    return (struct status){select, notselect};
}
/*
*int rob(struct TreeNode* root)
int rob：求树节点总和最大值，不能同时选择父子节点
struct TreeNode* root：树的头结点
返回值：总和最大值
*/
int rob(struct TreeNode* root){
    /* 对树从根节点进行dfs搜索 */
    struct status root_status = dfs(root);
    /* 比较根节点选或不选所得分数，取较大值 */
    return fmax(root_status.select, root_status.notselect);
}

时间空间复杂度