Baozi Training Leetcode solution 213. House Robber II

Problem Statement 

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.

 Problem link

Video Tutorial

You can find the detailed video tutorial here

• Youtube
• B站

Thought Process

This is very similar to House Robber I problem where the only difference is the houses now form a circle (French fancy way calls it cul-de-sac). It's same DP algorithm except now we need to consider two cases: whether we rob the first house or not. If we rob the first house, we should not rob the last house. If we do not rob the first house, we can rob the last house. We can even reuse the rob() function in House Robber I problem

 

 

 

 

Solutions

Use DP

 

public int rob(int[] nums) {
    if (nums == null || nums.length == 0) {
        return 0;
    }
    if (nums.length == 1) {
        return nums[0];
    }

    // rob first house, so need to remove the last house
    int[] rob_first_nums = new int[nums.length - 1];
    for (int i = 0; i < rob_first_nums.length; i++) {
        rob_first_nums[i] = nums[i];
    }

    // do not rob first house, start from the 2nd and rob to the end of the house
    int[] rob_no_first_nums = new int[nums.length - 1];
    for (int i = 1; i < nums.length; i++) {
        rob_no_first_nums[i - 1] = nums[i];
    }

    int rob_first_max = this.robFlatRow(rob_first_nums);
    int rob_no_first_max = this.robFlatRow(rob_no_first_nums);

    return Math.max(rob_first_max, rob_no_first_max);
}

public int robFlatRow(int[] num) {
    if (num == null || num.length == 0) {
        return 0;
    }

    int n = num.length;
    int[] lookup = new int[n + 1]; // DP array size normally larger than 1
    lookup[0] = 0;
    lookup[1] = num[0];

    for (int i = 2; i <= n; i++) {
        lookup[i] = Math.max(lookup[i - 1], lookup[i - 2] + num[i - 1]);
    }

    return lookup[n];
}

 

Time Complexity: O(N), N is the array size
Space Complexity: O(N) since we use extra arrays

References

• House Robber I problem solution
  
• Leetcode discussion solution