力扣解题思路：打家劫舍

思路：题目：
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
这一题与198. 打家劫舍 唯一的区别是此时nums可以视为一个环形数组，回忆一下198题，由于不可以在相邻的房屋闯入，所以在当前位置 n 房屋可盗窃的最大值，要么就是 n-1 房屋可盗窃的最大值，要么就是 n-2 房屋可盗窃的最大值加上当前房屋的值，二者之间取最大值 因此可以使用动态规划算法：
动态规划方程：dp[n] = Math.max( dp[n-1], dp[n-2] + num )，198题的完整代码如下：

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

但是打家劫舍 II显然没有这么简单，因为该数组可以看作一个环形，如果偷了第一家，那么最后一家就不能偷，如果开始偷的是第二家，那么才可以偷最后一家，那么我们完全可以将其分成两种情况分别处理：

public int rob(int[] nums) {
 if(nums==null||nums.length==0)
  return 0;
 if(nums.length==1)
  return nums[0];
 int[] dp1 = new int[nums.length+1];
 int[] dp2 = new int[nums.length+1];
 dp1[1] = nums[0]; //从第1个房屋开始偷
 dp2[1] = 0; //从第2个房屋开始偷
 for(int i=2;i<nums.length;i++) {
  dp1[i] = Math.max( dp1[i-2]+nums[i-1],dp1[i-1] );
 }
    for(int i=2;i<nums.length+1;i++){
        dp2[i] = Math.max( dp2[i-2]+nums[i-1], dp2[i-1]);
    }
 return Math.max( dp1[nums.length-1], dp2[nums.length] );
}

当然，把这个动态规划封装成一个函数myRob也可以，封装好了就可以直接调用了，例如：

return Math.max(myRob(Arrays.copyOfRange(nums, 0, nums.length - 1))， myRob(Arrays.copyOfRange(nums, 1, nums.length))

这一题与上面几题的区别是这一题考察到了树，那么对于任意一个节点，我们可以选择抢或者不抢该节点，然后我们对每个节点进行递归，计算抢该节点和不抢该节点所能得到的最大金额，将其保存在一个二元数组中。

但是我最开始想的是，一个节点偷与不偷是与其父节点有关的，那么我们遍历的时候是否需要记录其父节点的二元数组呢？其实是没必要的，因为我们采用递归的方式，实际上只有递归到叶子节点数组才会有值，然后再从叶子节点更新到根节点。因此，无需记录父节点数组，只需记录其子节点数组即可，将其作为返回值不就行了吗。
则有：

    result[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);    //计算不抢劫当前根节点可获得的最大金额(那么其左右子树可以随便抢)
    result[1] = left[0] + right[0] + root.val;//计算若抢劫根节点可获得的最大金额(此时,其左右子树的根节点不能被抢)

这样最终计算出的二元数组取其中一个最大值就是我们的答案了，完整代码如下：

public int rob(TreeNode root) {
    int[] result = robInternal(root);
    return Math.max(result[0], result[1]);
}
public int[] robInternal(TreeNode root) {   
    if (root == null) return new int[2];   
    int[] result = new int[2];
    int[] left = robInternal(root.left);    
    int[] right = robInternal(root.right);
    result[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);    
    result[1] = left[0] + right[0] + root.val;
    return result;
}

当然也可以不用数组来存放结果，这样就不用另写递归函数了：

public int rob(TreeNode root) {
    if (root == null) return 0;
    int val1 = root.val;
    if (root.left != null) val1 += rob(root.left.left) + rob(root.left.right);
    if (root.right != null) val1 += rob(root.right.left) + rob(root.right.right);
    int val2 = rob(root.left) + rob(root.right);
    return Math.max(val1, val2);
}

是不是更简单呢(✿◕‿◕✿)