# 0213. House Robber II

<https://leetcode.com/problems/house-robber-ii>

## Description

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`

## ac1

two pass without a function to wrap it up, a little bit ugly.

```java
// so DP doesn't care about those passed state, can't go back to change it.

class Solution {
    public int rob(int[] nums) {
        // edge case, length <= 3, rob 1
        if (nums.length < 4) {
            int res = 0;
            for (int n : nums) {
                res = Math.max(res, n);
            }
            return res;
        }

        // rob first, walk 0 - [nums.length - 2]
        int prev = 0;
        int max = nums[0];
        for (int i = 1; i < nums.length - 1; i++) {
            int tmp = max;
            max = Math.max(max, nums[i] + prev);
            prev = tmp;
        }

        // don't rob first, walk 1 -> [nums.length - 1]
        int max2 = nums[1];
        prev = 0;
        for (int i = 2; i < nums.length; i++) {
            int tmp = max2;
            max2 = Math.max(max2, nums[i] + prev);
            prev = tmp;
        }

        // answer
        return Math.max(max, max2);
    }
}
```