House Robber

House Robber - Problem

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 from robbing each of them is that adjacent houses have security systems 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.

Input & Output

Example 1 — Basic Case

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

› Output: 12

💡 Note: Rob houses 0, 2, and 4: 2 + 9 + 1 = 12. Cannot rob adjacent houses 1 and 3.

Example 2 — Choose Larger Adjacent

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

› Output: 4

💡 Note: Rob houses 0 and 2: 1 + 3 = 4, or rob houses 1 and 3: 2 + 1 = 3. The optimal choice is 4.

Example 3 — Single House

$ Input: nums = [5]

› Output: 5

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

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 400

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 M Microsoft 32 f Facebook 28

The key insight is that for each house, we choose the maximum between robbing it (current money + best from i-2) or skipping it (best from i-1). Best approach is space-optimized DP using two variables. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force Recursion

⏱️ Time: O(2ⁿ) Space: O(n)

For each house, recursively calculate the maximum money by either robbing it (and skipping the next) or skipping it. This explores all possible valid combinations but recalculates the same subproblems multiple times.

Dynamic Programming (Bottom-Up)

⏱️ Time: O(n) Space: O(n)

Use a DP array where dp[i] represents the maximum money that can be robbed from houses 0 to i. For each house, we decide whether to rob it (current money + dp[i-2]) or skip it (dp[i-1]), taking the maximum.

Recursion with Memoization

⏱️ Time: O(n) Space: O(n)

Same recursive logic as brute force, but we store (memoize) the results of subproblems to avoid recalculating them. This transforms the exponential solution into a linear one by ensuring each subproblem is solved only once.

Space-Optimized DP

⏱️ Time: O(n) Space: O(1)

Since we only need the previous two values (dp[i-1] and dp[i-2]) to calculate the current maximum, we can use two variables instead of an entire DP array. This reduces space complexity to O(1) while maintaining the same time complexity.

Brute Force Recursion — Algorithm Steps

For each house, decide rob or skip
If rob: add money + solve from house i+2
If skip: solve from house i+1
Return maximum of both choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

At each house, make rob/skip decision

Branch

Create two branches for each choice

Result

Return maximum from all valid paths

Code -

solution.c — C

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

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

int solution(int* nums, int numsSize) {
    return robFrom(nums, numsSize, 0);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    // Parse JSON array manually
    int nums[100];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    printf("%d\n", solution(nums, numsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Each house has 2 choices (rob/skip), creating 2^n possible combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion call stack can go up to n levels deep

✓ Linear Space

67.9K Views

High Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler