# 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: 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 2:

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

Constraints:

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

A robber has 2 options:

1. Rob the current house `i`.
2. Don’t rob current house.
1. If an option `(1)` is selected it means he can’t rob previous `i-1` house but can safely proceed to the one before previous `i-2` and gets all cumulative loot that follows.
2. If an option (2) is selected the robber gets all the possible loot from robbery of `i-1` and all the following buildings.
3. So it boils down to calculating what is more profitable:
1. Robbery of current house + loot from houses before the previous.
2. Loot from the previous house robbery and any loot captured before that.

So the `dp` relation can be expalined as:

``dp(i) = Math.max(dp(i - 2) + currentHouseValue, dp(i - 1))``

Let us implement the `dp` solution:

```class Solution {
public int rob(int[] nums) {

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

Convert the dp solution to a recursive solution:

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

This algorithm will process the same `i` multiple times and it needs improvement.

Recursive + Memoization:

```int[] memo;
public int rob(int[] nums) {
memo = new int[nums.length + 1];
Arrays.fill(memo, -1);
return rob(nums, nums.length - 1);
}

private int rob(int[] nums, int i) {
if (i < 0) {
return 0;
}
if (memo[i] >= 0) {
return memo[i];
}
int result = Math.max(rob(nums, i - 2) + nums[i], rob(nums, i - 1));
memo[i] = result;
return result;
}
```

This should run in `O(n)` time. Space complexity is `O(n)` as well, because of the recursion stack.

Categories: Dynamic Programming