House Robber - Practice Coding Problems

House Robber - Problem

The House Robber Challenge

You're a professional robber planning the perfect heist along a residential street. Each house contains a different amount of money, but there's a catch: adjacent houses have connected security systems that will automatically alert the police if both are robbed on the same night.

Your Goal: Maximize your earnings without triggering any alarms.

Input: An integer array nums where nums[i] represents the money in house i
Output: The maximum amount you can rob without robbing adjacent houses

Example: For houses [2, 7, 9, 3, 1], you can rob houses 0, 2, and 4 (values 2, 9, 1) for a total of 12, which is optimal.

Input & Output

example_1.py — Basic Case

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

› Output: 12

💡 Note: Rob houses 0, 2, and 4 with values 2, 9, and 1. Total = 2 + 9 + 1 = 12. This is optimal since we can't rob adjacent houses.

example_2.py — Two Houses

$ Input: [2,1]

› Output: 2

💡 Note: Rob house 0 with value 2. Can't rob both adjacent houses, so choose the larger value.

example_3.py — Single House

$ Input: [5]

› Output: 5

💡 Note: Only one house available, so rob it for maximum value of 5.

Visualization

Tap to expand

Understanding the Visualization

Assess Each House

Look at each house and the maximum money you could have earned up to the previous houses

Make Strategic Choice

Decide: Rob this house + best from 2 houses ago, or skip and keep the best from the previous house

Build Optimal Path

Each decision builds upon previous optimal decisions, ensuring the best overall strategy

Maximum Heist Complete

The final house gives you the maximum money possible without triggering any alarms

Key Takeaway

🎯 Key Insight: At each house, we only need to remember the maximum money from the previous house and two houses back. This transforms an exponential problem into a linear one by avoiding redundant calculations and building the optimal solution incrementally.

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each house has 2 choices, creating a binary tree of depth n

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 400
Adjacent houses cannot be robbed on the same night

Asked in

a Amazon 85 G Google 72 ⊞ Microsoft 68 f Meta 45

The optimal solution uses dynamic programming to build the maximum robbery amount incrementally. For each house, we choose the maximum between robbing it (current value + max from 2 houses back) or skipping it (max from previous house). This runs in O(n) time and can be optimized to O(1) space by only tracking the last two values instead of a full DP array.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Brute Force	O(2^n)	O(n)	Try every possible combination of non-adjacent houses recursively
Dynamic Programming (Optimal)	O(n)	O(n)	Build solution incrementally using previously computed optimal values

Recursive Brute Force — Algorithm Steps

Start from the first house with two choices: rob or skip
If we rob current house, recursively solve for houses starting from index+2
If we skip current house, recursively solve for houses starting from index+1
Return the maximum of both choices
Base case: if index >= array length, return 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at House 0

Two choices: rob (take 2 + solve from index 2) or skip (solve from index 1)

Branch Exploration

Each choice creates two more branches, forming a binary tree

Overlapping Subproblems

Same subproblems are solved multiple times (highlighted in red)

Return Maximum

Combine results from both branches and return the maximum

Code -

solution.c — C

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

int robRecursive(int* nums, int numsSize, int i) {
    if (i >= numsSize) {
        return 0;
    }
    // Choice 1: rob current house + rob from i+2
    int robCurrent = nums[i] + robRecursive(nums, numsSize, i + 2);
    // Choice 2: skip current house, rob from i+1
    int skipCurrent = robRecursive(nums, numsSize, i + 1);
    return robCurrent > skipCurrent ? robCurrent : skipCurrent;
}

int rob(int* nums, int numsSize) {
    return robRecursive(nums, numsSize, 0);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[100];
    int numsSize = 0;
    
    char* token = strtok(input, "[],\n ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", rob(nums, numsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each house has 2 choices, creating a binary tree of depth n

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 400
Adjacent houses cannot be robbed on the same night

68.3K Views

High Frequency

~15 min Avg. Time

2.8K 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

Recursive Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler