Binary Tree Cameras - Practice Coding Problems

Binary Tree Cameras - Problem

Binary Tree Cameras is a fascinating optimization problem that challenges you to find the minimum number of security cameras needed to monitor an entire binary tree.

Imagine you're designing a security system for a hierarchical network where each node represents a location. You need to strategically place cameras at certain nodes to monitor the entire network. Each camera has a monitoring range that covers:

• The node where it's installed
• Its parent node
• All its immediate children

Your goal is to determine the minimum number of cameras required to ensure every single node in the binary tree is monitored by at least one camera. This is a classic example of a greedy algorithm combined with dynamic programming on trees.

Input: The root of a binary tree
Output: Minimum number of cameras needed to monitor all nodes

Input & Output

example_1.py — Simple Tree

$ Input: root = [0,0,null,0,0]

› Output: 1

💡 Note: One camera at the root's left child can monitor the root, its left child, and the left child's children. This covers all 4 nodes with just 1 camera.

example_2.py — Linear Tree

$ Input: root = [0,0,null,0,null,0,null,null,0]

› Output: 2

💡 Note: This is essentially a linear chain. We need cameras at alternating positions to cover the entire chain efficiently. Placing cameras at positions that can cover 3 nodes each gives us the minimum.

example_3.py — Single Node

$ Input: root = [0]

› Output: 1

💡 Note: A single node tree requires exactly one camera to monitor itself, as there are no parent or children to help with coverage.

Visualization

Tap to expand

Understanding the Visualization

Bottom-Up Analysis

Start from the leaf offices (bottom of hierarchy) and work upward

Greedy Placement

Place cameras only when absolutely necessary - when subordinates need monitoring

State Propagation

Each camera placement affects the monitoring status of neighboring offices

Optimal Coverage

Achieve complete network security with minimum hardware investment

Key Takeaway

🎯 Key Insight: The greedy bottom-up approach ensures optimal camera placement by prioritizing parent nodes over leaf nodes, maximizing the coverage area of each camera while minimizing the total number needed.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal visits each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced trees

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 1000]
Node values are always 0 (values don't affect the camera placement)
Each camera monitors exactly its parent, itself, and immediate children

Asked in

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

The optimal solution uses a single DFS traversal with state tracking. Each node can be in one of three states: UNCOVERED (needs monitoring), COVERED (monitored but no camera), or CAMERA (has a camera). The algorithm makes greedy decisions bottom-up: place cameras only when children are uncovered, ensuring minimal camera usage while maintaining complete coverage.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with State Tracking (Optimal)	O(n)	O(h)	Use DFS with three states per node to find optimal camera placement
Brute Force (Try All Combinations)	O(2^n * n)	O(n)	Try all possible camera placements and find the minimum

DFS with State Tracking (Optimal) — Algorithm Steps

Define three states: UNCOVERED (0), COVERED (1), CAMERA (2)
Perform post-order DFS traversal (children first, then parent)
For each node, determine optimal state based on children's states
If any child is UNCOVERED, current node must have CAMERA
If any child has CAMERA, current node is COVERED
Otherwise, leave current node UNCOVERED (parent will handle)

Visualization

Tap to expand

Step-by-Step Walkthrough

Post-order Traversal

Visit children before processing current node

State Decision

Decide state based on children's states

Camera Placement

Place camera when children are uncovered

Coverage Propagation

Update coverage based on camera placement

Code -

solution.c — C

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

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

#define UNCOVERED 0
#define COVERED 1
#define CAMERA 2

int cameras = 0;

int dfs(struct TreeNode* node) {
    if (!node) return COVERED;
    
    int leftState = dfs(node->left);
    int rightState = dfs(node->right);
    
    if (leftState == UNCOVERED || rightState == UNCOVERED) {
        cameras++;
        return CAMERA;
    }
    
    if (leftState == CAMERA || rightState == CAMERA) {
        return COVERED;
    }
    
    return UNCOVERED;
}

int minCameraCover(struct TreeNode* root) {
    cameras = 0;
    if (dfs(root) == UNCOVERED) {
        cameras++;
    }
    return cameras;
}

int main() {
    // Tree construction would go here
    printf("%d\n", minCameraCover(NULL));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal visits each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced trees

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 1000]
Node values are always 0 (values don't affect the camera placement)
Each camera monitors exactly its parent, itself, and immediate children

43.5K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

DFS with State Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler