房屋抢劫问题

198. House Robber

题目链接
You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.

Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.

Example 1:

Input: [1,2,3,1]
Output: 4
Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
             Total amount you can rob = 1 + 3 = 4.

Example 2:

Input: [2,7,9,3,1]
Output: 12
Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
             Total amount you can rob = 2 + 9 + 1 = 12.

题目大意
有一个强盗打算抢劫一条街的房子， 但是他不能连续抢劫相连的两栋房屋，否则会触发警报。现在用一个整数数组表示每栋房屋中的现金，找出这个强盗在不触发警报的情况下能抢到最多的钱。

解题思路
状态

• 抢劫当前房屋:rob or dp[i][1]
• 不抢劫当前房屋: notRob or dp[i][0]

选择

• 选择两个状态中的最大值

转移方程

• 不抢劫：dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1]);
  抢劫： dp[i][1] = num[i - 1] + dp[i - 1][0];

  不抢劫: notRob = Math.max(notRob, rob);
  抢劫: rob = Math.max(rob, pre + nums[i]);
  复杂度
  SC: O(1)
  TC: O(n)

public int rob(int[] nums) {
   int rob = 0;
    int notRob = 0;
    
    for (int i = 0; i < nums.length; i++){
        int pre = notRob;
        notRob = Math.max(notRob, rob);
        rob = Math.max(rob, pre + nums[i]);
    }
    
    return Math.max(rob, notRob);
}

---

213. House Robber II

题目链接
You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place are arranged in a circle. That means the first house is the neighbor of the last one. Meanwhile, adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.

Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.

Example 1:

Input: [2,3,2]
Output: 3
Explanation: You cannot rob house 1 (money = 2) and then rob house 3 (money = 2),
             because they are adjacent houses.

Example 2:

Input: [1,2,3,1]
Output: 4
Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
             Total amount you can rob = 1 + 3 = 4.

题目大意
与第一个题区别在于，这条街是一个环，也就是第一栋房屋和最后一栋也是邻居。

解题思路
可以把这个环转换成两条街，一条包括0到n - 2栋房屋，另一条包括1到n - 1栋房屋，取最大值就行。

复杂度
SC: O(n)
TC: O(n)

 public int rob(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    if (nums.length == 1) return nums[0];
    
    int n = nums.length;
    return Math.max(helper(nums,0, n - 1), helper(nums, 1, n));
}

public int helper(int[] nums, int start, int end) {
    int rob = 0;
    int notRob = 0;
    
    for (int i = start; i < end; i++){
        int pre = notRob;
        notRob = Math.max(notRob, rob);
        rob = Math.max(rob, pre + nums[i]);
    }
    
    return Math.max(rob, notRob);
}

---

337. House Robber III

题目链接
The thief has found himself a new place for his thievery again. There is only one entrance to this area, called the “root.” Besides the root, each house has one and only one parent house. After a tour, the smart thief realized that “all houses in this place forms a binary tree”. It will automatically contact the police if two directly-linked houses were broken into on the same night.

Determine the maximum amount of money the thief can rob tonight without alerting the police.

Example 1:

Input: [3,2,3,null,3,null,1]

     3
    / \
   2   3
    \   \ 
     3   1

Output: 7 
Explanation: Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.

Example 2:

Input: [3,4,5,1,3,null,1]

     3
    / \
   4   5
  / \   \ 
 1   3   1

Output: 9
Explanation: Maximum amount of money the thief can rob = 4 + 5 = 9.

---

题目大意
现在房屋是按照二叉树方式排列，任何两个相连的房屋被抢就会触发警报，求最多能抢多少。

解题思路

状态

• 抢劫父节点的房屋 dp[0]
• 不抢劫父节点的房屋 dp[1]

选择
在以上两者间选最大值

转移方程
res[0] = root.val + left[1] + right[1];
res[1] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);

复杂度
SC:O(1)
TC:O(n)
因为要遍历整个树

 public int rob(TreeNode root) {
   int[] res = helper(root);
    return Math.max(res[0], res[1]);
}

private int[] helper(TreeNode root){
    if (root == null){
        return new int[]{0, 0};
    }
    int[] res = new int[2];
    
    int[] left = helper(root.left);
    int[] right = helper(root.right);
    
    //pick root
    res[0] = root.val + left[1] + right[1];
    res[1] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
    
    return res;
}