House Robber II - Practice Coding Problems

House Robber II - Problem

You're a master thief planning the heist of a lifetime! This time, you've targeted a circular street where houses form a complete loop - meaning the first house is right next to the last house.

Each house contains a different amount of cash, represented by the array nums. However, there's a catch: the houses have a connected security system that will trigger an alarm if you rob any two adjacent houses on the same night.

Since the street is circular, you face an additional constraint: you cannot rob both the first AND last house, as they are neighbors!

Goal: Return the maximum amount of money you can steal without triggering the security system.

Example: Given houses [2,3,2] in a circle, you can rob house 2 (middle) for 3 total, but you cannot rob houses 1 and 3 together since house 1 and 3 are adjacent in the circle.

Input & Output

example_1.py — Basic Circle

$ Input: [2,3,2]

› Output: 3

💡 Note: You cannot rob house 1 (money = 2) and then rob house 3 (money = 2), because they are adjacent houses. Rob house 2 instead.

example_2.py — Larger Circle

$ Input: [1,2,3,1]

› Output: 4

💡 Note: Rob house 1 (money = 1) and then rob house 3 (money = 3). Total = 1 + 3 = 4.

example_3.py — Single House

$ Input: [5]

› Output: 5

💡 Note: Only one house to rob, so rob it for maximum money of 5.

Visualization

Tap to expand

Understanding the Visualization

Identify the Constraint

The circular arrangement means first and last houses are adjacent

Create Two Scenarios

Scenario A: Include first house (exclude last). Scenario B: Include last house (exclude first)

Solve Linear Problems

Use standard house robber DP for each linear subarray

Take Maximum

Return the maximum result from both scenarios

Key Takeaway

🎯 Key Insight: The circular constraint creates exactly two mutually exclusive scenarios, each solvable as a linear house robber problem using dynamic programming.

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate 2^n subsets and check each one

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and subset storage

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 1000
All houses are arranged in a circle

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses dynamic programming to solve two linear subproblems: one excluding the last house and another excluding the first house. This handles the circular constraint by ensuring we never rob both the first and last houses simultaneously. Time complexity: O(n), Space: O(1) with optimized DP.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(n)	Generate all possible combinations of non-adjacent houses and find maximum sum
Two-Pass Dynamic Programming	O(n)	O(n)	Solve two linear house robber problems separately and take maximum

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible subsets of house indices
For each subset, check if any two indices are adjacent
Check if both first (0) and last (n-1) indices are in subset
If valid, calculate sum and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible combinations of houses

Check Adjacent

Verify no two adjacent houses are selected

Check Circular

Ensure first and last houses aren't both selected

Calculate Sum

Sum money from valid combinations and track maximum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int max(int a, int b) {
    return a > b ? a : b;
}

bool isValidSubset(int* subset, int subsetSize, int n) {
    // Check no adjacent houses
    for (int i = 0; i < subsetSize - 1; i++) {
        if (subset[i+1] - subset[i] == 1) return false;
    }
    // Check first and last not both selected
    bool hasFirst = false, hasLast = false;
    for (int i = 0; i < subsetSize; i++) {
        if (subset[i] == 0) hasFirst = true;
        if (subset[i] == n-1) hasLast = true;
    }
    return !(hasFirst && hasLast);
}

int rob(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    if (numsSize == 1) return nums[0];
    if (numsSize == 2) return max(nums[0], nums[1]);
    
    int maxMoney = 0;
    
    // Generate all subsets
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int subset[numsSize];
        int subsetSize = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subset[subsetSize++] = i;
            }
        }
        
        if (isValidSubset(subset, subsetSize, numsSize)) {
            int money = 0;
            for (int i = 0; i < subsetSize; i++) {
                money += nums[subset[i]];
            }
            maxMoney = max(maxMoney, money);
        }
    }
    
    return maxMoney;
}

int main() {
    int nums[100];
    int n = 0;
    char c;
    scanf("%c", &c); // '['
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    printf("%d\n", rob(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate 2^n subsets and check each one

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and subset storage

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 1000
All houses are arranged in a circle

68.5K Views

High Frequency

~25 min Avg. Time

3.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler