Maximize the loot from non-adjacent houses along a street.

Interview question: 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 is that adjacent houses have security systems connected, and it will automatically contact the police if two adjacent houses are broken into on the same night.

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

## Example
```
Input: nums = [1, 2, 3, 1]
Output: 4
Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3). Total = 1 + 3 = 4.
```

- At each house, you either rob it or skip it.
- If you rob the current house, you cannot rob the immediately previous one.
- The goal is the best total after considering all houses.

Understand the Choice at Each House

- Let `dp[i]` mean the maximum money obtainable from houses up to index `i`.
- For each house, choose between skipping it (`dp[i - 1]`) or robbing it (`dp[i - 2] + nums[i]`).
- The recurrence is `dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])`.

Define the Dynamic Programming State

- The recurrence only needs the previous two results.
- Store `prev_two` for `dp[i - 2]` and `prev_one` for `dp[i - 1]`.
- Update them as you move through the array.

Optimize the Space

- For each amount, compute the best total if this house is included or skipped.
- `current = max(prev_one, prev_two + amount)`.
- Then shift the rolling values forward.

Update Rolling Values

- This dynamic programming solution considers every house once.
- Time complexity is O(n).
- Space complexity is O(1) because only two previous totals are stored.