House Robber III - Practice Coding Problems

House Robber III - Problem

You are a professional thief who has discovered a unique neighborhood where all the houses are arranged in a binary tree structure. Each house contains a certain amount of money, but there's a catch: the houses have a sophisticated security system that will automatically alert the police if two directly connected houses (parent-child relationship) are robbed on the same night.

Given the root of a binary tree where each node represents a house with a certain amount of money, determine the maximum amount of money you can rob without triggering the alarm system.

Goal: Find the maximum sum of money you can steal without robbing any two directly connected houses in the tree.

Input & Output

example_1.py — Basic Binary Tree

$ Input: root = [3,2,3,null,3,null,1]

› Output: 7

💡 Note: Maximum money robbed = 3 + 3 + 1 = 7. We rob houses with values 3 (root), 3 (left-right), and 1 (right-right), avoiding adjacent nodes.

example_2.py — Deeper Tree

$ Input: root = [3,4,5,1,3,null,1]

› Output: 9

💡 Note: Maximum money robbed = 4 + 5 = 9. We rob houses 4 (left child) and 5 (right child), which gives us the maximum without robbing adjacent nodes.

example_3.py — Single Node

$ Input: root = [5]

› Output: 5

💡 Note: With only one house, we rob it and get 5. No adjacent constraint applies.

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
0 ≤ Node.val ≤ 10⁴
Tree structure: Each node has at most two children
No negative values in the tree

Visualization

Tap to expand

Understanding the Visualization

Identify the choice

At each house, decide: rob this house or skip it

Calculate scenarios

Rob current + best from grandchildren vs Skip current + best from children

Use memoization

Cache results to avoid recalculating the same subtrees

Propagate upward

Combine optimal choices from bottom to top

Key Takeaway

🎯 Key Insight: At each node, we have exactly two choices. The optimal solution combines the best choice at each level using dynamic programming to avoid redundant calculations.

Asked in

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

The optimal solution uses dynamic programming with memoization to solve the tree robbing problem in O(n) time. At each node, we calculate two scenarios: robbing the current house (and skipping children) versus skipping the current house (and considering children). Memoization eliminates redundant calculations by caching results for each subtree, transforming the exponential brute force approach into a linear time solution.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(n)	O(n)	Use memoization to cache results and avoid redundant calculations
Brute Force (Recursive with Overlapping Calls)	O(2^n)	O(h)	Recursively explore all possibilities with redundant calculations

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Create a memoization map to store results for each node
For each node, check if result is already computed
If not computed, calculate both rob and skip scenarios
Store the result in memo map before returning
Reuse cached results for repeated subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

First calculation

Compute and cache result for each node

Cache hit

Reuse cached results for repeated subproblems

Linear time

Each node visited exactly once

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct MemoNode {
    struct TreeNode* key;
    int value;
    struct MemoNode* next;
};

struct MemoNode* memo = NULL;

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

int getMemo(struct TreeNode* node) {
    struct MemoNode* current = memo;
    while (current) {
        if (current->key == node) return current->value;
        current = current->next;
    }
    return -1; // Not found
}

void setMemo(struct TreeNode* node, int value) {
    struct MemoNode* newNode = (struct MemoNode*)malloc(sizeof(struct MemoNode));
    newNode->key = node;
    newNode->value = value;
    newNode->next = memo;
    memo = newNode;
}

int rob(struct TreeNode* root) {
    if (!root) return 0;
    
    int cached = getMemo(root);
    if (cached != -1) return cached;
    
    // Option 1: Rob current node
    int robCurrent = root->val;
    if (root->left) {
        robCurrent += rob(root->left->left) + rob(root->left->right);
    }
    if (root->right) {
        robCurrent += rob(root->right->left) + rob(root->right->right);
    }
    
    // Option 2: Skip current node
    int skipCurrent = rob(root->left) + rob(root->right);
    
    int result = max(robCurrent, skipCurrent);
    setMemo(root, result);
    return result;
}

int main() {
    printf("%d\n", rob(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited exactly once and its result is cached

✓ Linear Growth

Space Complexity

O(n)

Memoization map stores result for each node, plus O(h) for recursion stack

⚡ Linearithmic Space

68.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler