打家劫舍

问题描述：

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

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

示例 1:

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

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

解法一：递归

对于某间房屋只有两个分支，要么偷，要么不偷。定义process(i)返回 从i位置开始偷到结尾位置的最大收益，我们可以发现如果他偷的情况下依赖于process(i + 2), 不偷情况下依赖于process(i + 1)。实现代码如下：

    public int rob(int[] nums) {
        return process(nums, 0);
    }
    public int process(int[] nums, int i){ // 返回从i开始的最大收益
        if(i >= nums.length){
            return 0;
        }
        return Math.max(process(nums, i + 2) + nums[i] , process(nums, i + 1));
    }

该算法提交时，超出时间限制了，只能改动态规划了。

解法二：动态规划

从解法一中我们可知转移方程为dp[i] = Math.max(dp[i + 2] + nums[i], dp[i + 1]),初值 dp[n] = dp[n + 1] = 0.

实现代码如下：

    public int rob(int[] nums) {
        int[] dp = new int[nums.length + 2]; // dp[i] 表示 从i到结尾 在i位置的最大收益
        for(int i = nums.length - 1; i >= 0; i--){
            dp[i] = Math.max(nums[i] + dp[i + 2], dp[i + 1]);
        }
        return dp[0];
    }

时间复杂度O（N），额外空间复杂度O（N）

解法三:动态规划的空间进一步压缩

解法二中我们发现dp[i]的取值仅与dp[i + 1] 和 dp[i + 2]有关，因此我们可以使用两个临时变量next，nextNext存储当前位置的下一个和下下一个。

cur = Math.max（nextNext + nums[i], next）

实现代码如下：

    public int rob(int[] nums) {
        int next = 0, nextNext = 0; 
        int cur = 0;
        for(int i = nums.length - 1; i >= 0; i--){
            cur = Math.max(nums[i] + nextNext, next);
            nextNext = next;
            next = cur;
        }
        return cur;
    }

时间复杂度O（N），额外空间复杂度O（1）。

问题二：打家劫舍II（leetcode213）

就是说这个小偷来到了一个环形分布的房屋群中，即第一个房屋和最后一个房屋连着，偷第一个的话就不能偷最后一个了，否则就会报警。

该问题可以分以下两种情况:

在第一个房间偷

在第一个房间不偷

如此该问题就可以转化为两个直线型dp,最终选择上述两种情况中收益最大的。

实现代码如下：

    public int rob(int[] nums) {
        if(nums.length == 0){
            return 0;
        }
        if(nums.length == 1){
            return nums[0];
        }
        // 变为 偷第一个房间和不偷第一个房间两种情况
        int[] dp0 = new int[nums.length + 1]; //不偷第一个房间
        int[] dp1 = new int[nums.length + 1]; // 若第一个偷了，则第二个和最后一个都不能偷了
        dp0[nums.length - 1] = nums[nums.length - 1];
        for(int i = nums.length - 2; i >= 1; i--){
            dp0[i] = Math.max(dp0[i + 1], nums[i] + dp0[i + 2]);
        }
        dp1[nums.length - 2] = nums[nums.length - 2];
        for(int i = nums.length - 3; i >= 2; i--){
             dp1[i] = Math.max(dp1[i + 1], nums[i] + dp1[i + 2]);
        }
        return Math.max(dp1[2] + nums[0], dp0[1]);
    }

问题三：打家劫舍III（leetcode337）

问题描述：

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

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

解决方案：

这是一个树型dp问题，也称为信息搜集题。父节点通过孩子收集的信息来完善自己的信息。

每个节点需要返回在其上偷或者不偷的最大收益，info[0] 为不偷的最大收益，info[1]为偷的最大收益

当前结点偷的最大收益为当前结点的金额加上其两孩子不偷的收益；

        info[1] = root.val + leftInfo[0] + rightInfo[0];

        info[0] = Math.max(leftInfo[0], leftInfo[1]) + Math.max(rightInfo[0], rightInfo[1]);

当前结点偷的最大收益为当前结点的金额加上其两孩子不偷的收益；

当前结点不偷的收益为max(左孩子偷， 左孩子不偷) + max(右孩子偷， 右孩子不偷）

实现代码如下：

class Solution {
    public int rob(TreeNode root) {
        int[] info = process(root);
        return Math.max(info[0], info[1]);
    }
    /**
    * @Return info[0] : 当前位置不偷的最大收益 info[1] : 当前位置偷的最大收益
    */
    public int[] process(TreeNode root){
        if(root == null){
            return new int[2];
        }
        int[] info = new int[2];
        int[] leftInfo = process(root.left);
        int[] rightInfo = process(root.right);
        info[1] = root.val + leftInfo[0] + rightInfo[0];
        info[0] = Math.max(leftInfo[0], leftInfo[1]) + Math.max(rightInfo[0], rightInfo[1]);
        return info;
    }
}