LeetCode //C - 213. House Robber II

213. 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

From: LeetCode
Link: 213. House Robber II

Solution:

Ideas:

1. rob_linear function:
   This function handles the simpler linear version of the house robber problem.
   prev1 and prev2 are used to store the maximum amounts robbed up to the previous house and the house before the previous one, respectively.
   Iterate from start to end, updating the maximum amount that can be robbed up to the current house (curr) by either taking the current house’s money plus the maximum amount robbed from houses before the previous one (nums[i] + prev2) or not taking the current house’s money and keeping the previous maximum amount (prev1).
   Update prev2 and prev1 accordingly.

2. rob function:
   This is the main function that handles the circular arrangement of houses.
   If there’s only one house, return its money.

Code:

int rob_linear(int* nums, int start, int end) {
    int prev1 = 0, prev2 = 0, curr;
    for (int i = start; i <= end; i++) {
        curr = (nums[i] + prev2 > prev1) ? nums[i] + prev2 : prev1;
        prev2 = prev1;
        prev1 = curr;
    }
    return curr;
}

int rob(int* nums, int numsSize) {
    if (numsSize == 1) {
        return nums[0];
    }
    int case1 = rob_linear(nums, 0, numsSize - 2);
    int case2 = rob_linear(nums, 1, numsSize - 1);
    return (case1 > case2) ? case1 : case2;
}