# House Robber II LeetCode Solution | Easy Approach Share:

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 a security system connected, and it will automatically contact the police if two adjacent houses were broken into on the same night.

Given an integer array `nums` representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.

Example 1:

```Input: nums = [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: nums = [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 3:

```Input: nums = [1,2,3]
Output: 3
```

Constraints:

• `1 <= nums.length <= 100`
• `0 <= nums[i] <= 1000`

Time: O(n)
Space: O(n)→O(1)

### C++

``````class Solution {
public:
int rob(vector<int>& nums) {
if (nums.empty())
return 0;
if (nums.size() == 1)
return nums;

auto rob = [&](int l, int r) {
int prev1 = 0;  // dp[i - 1]
int prev2 = 0;  // dp[i - 2]

for (int i = l; i <= r; ++i) {
const int dp = max(prev1, prev2 + nums[i]);
prev2 = prev1;
prev1 = dp;
}

return prev1;
};

return max(rob(0, nums.size() - 2), rob(1, nums.size() - 1));
}
};
``````

### Java

`````` class Solution {
public int rob(int[] nums) {
if (nums.length == 0)
return 0;
if (nums.length == 1)
return nums;

return Math.max(rob(nums, 0, nums.length - 2), rob(nums, 1, nums.length - 1));
}

private int rob(int[] nums, int l, int r) {
int prev1 = 0; // dp[i - 1]
int prev2 = 0; // dp[i - 2]

for (int i = l; i <= r; ++i) {
final int dp = Math.max(prev1, prev2 + nums[i]);
prev2 = prev1;
prev1 = dp;
}

return prev1;
}
}
``````

### Python

``````
class Solution:
def rob(self, nums: List[int]) -> int:
def rob(l: int, r: int) -> int:
dp1 = 0
dp2 = 0

for i in range(l, r + 1):
temp = dp1
dp1 = max(dp1, dp2 + nums[i])
dp2 = temp

return dp1

if not nums:
return 0
if len(nums) < 2:
return nums

return max(rob(0, len(nums) - 2), rob(1, len(nums) - 1))
``````

#### Watch Tutorial

Checkout more Solutions here