day52 动态规划part9

198. 打家劫舍

中等
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

思路

class Solution {
    public int rob(int[] nums) {
        // 如果只有一间房或0间房：
        if (nums.length == 0) return 0;  // 如果没有房屋，返回0
        if (nums.length == 1) return nums[0]; // 如果只有一个房屋，返回其金额

        int[] dp = new int [nums.length]; // dp[i] 表示前i个屋子能偷到的最大金额, 即偷 [0..k) 房间中的最大金额，注意是从0算起，所以不包含k

        dp[0] = nums[0];  // 将dp的第一个元素设置为第一个房屋的金额
        dp[1] = Math.max(nums[0], nums[1]);  // 将dp的第二个元素设置为第一二个房屋中的金额较大者

        for (int i = 2; i < nums.length; i++) { // i=2代表从第3间屋子开始算起
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        
        return dp[nums.length - 1];
    }
}

213. 打家劫舍 II

中等
提示
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

难点：要把环展开成线，无法判断从哪里选起就从头开始了，不能说因为是一个环就无法碰它了，总得有个破局点。偷东西是一家一家偷的，总得找第个一家先试试。归根到底，就是比打家劫舍多了一个限制条件：首尾不能同时偷。

思路：

class Solution {
    public int rob(int[] nums) {
        if (nums.length == 0) return 0; // 如果没有房屋，返回0
        if (nums.length == 1) return nums[0]; // 如果只有一个房屋，返回其金额

        int result1 = myRob(nums, 0, nums.length - 1); // 选首部屋子
        int result2 = myRob(nums, 1, nums.length);  // 选尾部屋子

        return Math.max(result1, result2);
    }

    public int myRob(int[] nums, int start, int end) {
        int pre = 0; // 前一位
        int prepre = 0; // 前前一位
        int temp = 0; // 用作交换

        for (int i = start; i < end; i++) {
            temp = pre;
            // 和二维相比，这里也做了dp[0] 和dp[1] 的初始化，当然，要把dp[0] 看作之前还有一位 0
            // 注意此时的pre已经是dp[i]了，
            // 可以看看原来的公式就明白了：dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
            pre = Math.max(pre, prepre + nums[i]); 
            prepre = temp;
        }
        return pre;
    }
}

337. 打家劫舍 III

中等
相关标签
相关企业
小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

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

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

思路：

使用爷爷、两个孩子、4 个孙子来说明问题
首先来定义这个问题的状态
爷爷节点获取到最大的偷取的钱数呢

首先要明确相邻的节点不能偷，也就是爷爷选择偷，儿子就不能偷了，但是孙子可以偷
二叉树只有左右两个孩子，一个爷爷最多 2 个儿子，4 个孙子

作者：房建斌学算法
链接：https://leetcode.cn/problems/house-robber-iii/solutions/47828/san-chong-fang-fa-jie-jue-shu-xing-dong-tai-gui-hu/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
每个节点可选择偷或者不偷两种状态，根据题目意思，相连节点不能一起偷

当前节点选择偷时，那么两个孩子节点就不能选择偷了
当前节点选择不偷时，两个孩子节点只需要拿最多的钱出来就行(两个孩子节点偷不偷没关系)
我们使用一个大小为 2 的数组来表示 int[] res = new int[2] 0 代表不偷，1 代表偷
任何一个节点能偷到的最大钱的状态可以定义为

当前节点选择不偷：当前节点能偷到的最大钱数 = 左孩子能偷到的钱 + 右孩子能偷到的钱
当前节点选择偷：当前节点能偷到的最大钱数 = 左孩子选择自己不偷时能得到的钱 + 右孩子选择不偷时能得到的钱 + 当前节点的钱数
表示为公式如下

root[0] = Math.max(rob(root.left)[0], rob(root.left)[1]) + Math.max(rob(root.right)[0], rob(root.right)[1])
root[1] = rob(root.left)[0] + rob(root.right)[0] + root.val;

将公式做个变换就是代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int rob(TreeNode root) {
        int[] result = robAction(root);

        return Math.max(result[0], result[1]);
    }

    public int[] robAction(TreeNode root) {
        if (root == null) return new int[2]; // 如果该节点为空，那么偷或不偷它都返回0，所以它的result为[0, 0]

        int[] result = new int[2];

        // 后续遍历，因为要从底下找到上面
        int[] left = robAction(root.left); 
        int[] right = robAction(root.right);

        // 当前节点选择不偷：当前节点能偷到的最大钱数 = 左孩子能偷到的钱 + 右孩子能偷到的钱, 但是不是说左右孩子必须偷，所以是选它们偷或者不偷的最大值
        result[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        // 当前节点选择偷：当前节点能偷到的最大钱数 = 左孩子选择自己不偷时能得到的钱 + 右孩子选择不偷时能得到的钱 + 当前节点的钱数
        result[1] = root.val + left[0] + right[0];

        return result;
    }
}