打家劫舍系列总结

打家劫舍基础版

##解法一：
###思路：
此问题对于动态规划的新手可能没有概念， 那么这个问题就要建立这个概念。对于每个房间，有两种情况：偷与不偷
为此可以建立一个二维数组，dp[n+1][2]，其中n为房间的个数
依次遍历每个房间，我们可以选择偷与不偷，但是相邻的一定不可以一起偷。
dp[i][0] = Math.max(dp[i - 1][0],dp[i - 1][1]);
dp[i][1] = nums[i-1] + dp[i -1][0];

dp[i][1]代表我们偷了第i个房间
dp[i][0]代表我们没有偷第i个房间

dp[i][0]的值是已经走到第i-1个房间的最大收益值(在第i-1个房间偷与未偷中选大的)
dp[i][1] 的值为拿走该房间的财产后+没有偷i-1个房间的财产值

最后返回最后一个房间偷或者不偷的最大收益

###Code:

public class Solution {
    public int rob(int[] nums) {
       int[][] dp = new int[nums.length + 1][2];
       
       for(int i = 1; i <= nums.length; i++ ){
           dp[i][0] = Math.max(dp[i - 1][0],dp[i - 1][1]);
           dp[i][1] = nums[i-1] + dp[i -1][0];
       }
       return Math.max(dp[nums.length][0],dp[nums.length][1]);
    }
}

##解法二：
###思路：

由于动态规划的数组中, 每次的状态只与前一次的状态有关，所以可以只用一维数组保存状态。
其中include代表每次偷的结果, exclude代表每次不偷的结果，初始化都为0。
在迭代的过程中，有两个局部变量rob和norob用来暂存信息。
最后求得的结果是全局变量include和exclude的最大值。

###Code:

    public int rob(int[] nums) {
        //二维解法, 直接上dp[i][2], 表示偷与不偷的两种状态
        //一维解法, 因为每次的状态只与上次有关, 所以在空间维度上可以优化
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int include = 0;
        int exclude = 0;
        for (int i = 0; i < nums.length; i++) {
            int rob = include;
            int norob = exclude;
            include = norob + nums[i];
            exclude = Math.max(norob, rob);
        }
        return Math.max(include, exclude);
    }

打家劫舍(带环)

213. 打家劫舍 II

##解法一：
###思路：
乍看这个问题无解，因为解决此前的House Robber问题是从a[0]作为入口，一直遍历到a[n-1]，最后返回最大值。
如果换一个角度思考，把有环问题转换成无环问题。那么把问题分解下，第一种情况偷0–n-2的房间(无环问题）；第二种情况偷1–n-1的房间(无环问题），最后得到两者中的最大值就行。
但是注意一点，需要将原先解决的House Robber问题（无环)泛化。
这样就又将新问题规约为原问题。。
##Code:

public class Solution {
    public int rob(int[] nums) {
        if(nums.length == 1) return nums[0];
        return Math.max(rob(nums,0,nums.length - 2),rob(nums,1,nums.length-1));
    }
    private int rob(int[] nums, int lo, int hi){
        int include = 0, exclude = 0;
        for(int j = lo; j <= hi; j++){
            int i = include , e = exclude;
            include = e + nums[j];
            exclude = Math.max(e,i);
        }
        return Math.max(include,exclude);
    }
}

打家劫舍(树型)

337. 打家劫舍 III

一句话描述题目:
二叉树的相邻层的元素不能同时取…
解决思路:
递归求解, 1. 选取根结点 + 左子树的左右子树 + 右子树的左右子树
2. 左子树 + 右子树
选取1和2中的较大值

这种解法会超时

解法一

class Solution {
    public int rob(TreeNode root) {

        //递归求解
        //max(root.val + 左子树的左右子树 + 右子树的左右子树, 左子树 + 右子树)
        if (root == null) {
            return 0;
        }
        int val = root.val;
        if (root.left != null) {
            val += rob(root.left.left) + rob(root.left.right);
        }
        if (root.right != null) {
            val += rob(root.right.left) + rob(root.right.right);
        }
        return Math.max(val, rob(root.left) + rob(root.right));
        
    }
}

解法二

class Solution {
    public int rob(TreeNode root) {
        //用HashMap解决求解重复子问题
        Map<TreeNode, Integer> map = new HashMap<>();
        if (root == null) {
            return 0;
        }
        return helper(root, map);
    }
    private int helper(TreeNode root, Map<TreeNode, Integer> map) {
        if (root == null) {
            return 0;
        }
        if (map.containsKey(root)) {
            return map.get(root);
        }
        int val = root.val;
        if (root.left != null) {
            val += helper(root.left.left, map) + helper(root.left.right, map);
        }
        if (root.right != null) {
            val += helper(root.right.left, map) + helper(root.right.right, map);
        }
        int res = Math.max(val, helper(root.left, map) + helper(root.right, map));
        map.put(root, res);
        return res;
    }
}

解法三

对于每个结点其实可以抽象出两个状态，偷与不偷。可以用二维数组表示…由于是二叉树，具有天然的递归特性。
此种解法不用递归到孙子级别，减少了很多重复计算工作。。

class Solution {
    public int rob(TreeNode root) {
        //对于每个节点, 只有两个选择, 偷与不偷
        if (root == null) {
            return 0;
        }
        int[] res = helper(root);
        return Math.max(res[0], res[1]);
    }
    private int[] helper(TreeNode root) {
        if (root == null) {
            return new int[2];
        }
        int[] res = new int[2];
        int[] left = helper(root.left);
        int[] right = helper(root.right);
        res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        res[1] = left[0] + right[0] + root.val;
        return res;
    }
}