Binary Tree Cameras

Binary Tree Cameras - Problem

You are given the root of a binary tree. We install cameras on the tree nodes where each camera at a node can monitor its parent, itself, and its immediate children.

Return the minimum number of cameras needed to monitor all nodes of the tree.

Input & Output

Example 1 — Simple Tree

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

› Output: 1

💡 Note: Place one camera at root node 0. It monitors itself and both children at level 1. The grandchildren at level 2 are monitored by their parents.

Example 2 — Single Path

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

› Output: 2

💡 Note: Two cameras needed - one can be placed optimally to cover 3 nodes each, requiring 2 cameras total for this linear path.

Example 3 — Single Node

$ Input: root = [0]

› Output: 1

💡 Note: Single node tree requires exactly one camera to monitor itself.

Constraints

The number of nodes in the tree is in the range [1, 1000].
Node.val == 0

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use greedy post-order DFS with state tracking. Each node has three states: NEED_CAMERA, HAS_CAMERA, or MONITORED. Place cameras only when necessary (when a child needs monitoring). Best approach is Greedy DFS with Time: O(n), Space: O(h).

Common Approaches

✓ Brute Force - Try All Combinations

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

For each node, decide whether to place a camera or not. Try all 2^n combinations and find the minimum that covers all nodes.

Greedy DFS with State Tracking

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

Use DFS to traverse the tree bottom-up. For each node, track three states: needs camera, has camera, or is monitored. Place cameras greedily only when necessary.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible camera placements
For each placement, check if all nodes are monitored
Return the minimum valid placement size

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Combinations

Try placing cameras at every possible subset of nodes

Check Coverage

For each combination, verify all nodes are monitored

Find Minimum

Return the smallest valid combination

Code -

solution.c — C

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

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

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

void collectNodes(struct TreeNode* node, struct TreeNode** nodes, int* count) {
    if (node) {
        nodes[*count] = node;
        (*count)++;
        collectNodes(node->left, nodes, count);
        collectNodes(node->right, nodes, count);
    }
}

bool isCovered(struct TreeNode** nodes, int nodeCount, int cameraMask) {
    bool* covered = (bool*)calloc(nodeCount, sizeof(bool));
    
    for (int i = 0; i < nodeCount; i++) {
        if (cameraMask & (1 << i)) {
            struct TreeNode* node = nodes[i];
            covered[i] = true;
            for (int j = 0; j < nodeCount; j++) {
                struct TreeNode* other = nodes[j];
                if (other == node->left || other == node->right ||
                    (other->left == node || other->right == node)) {
                    covered[j] = true;
                }
            }
        }
    }
    
    for (int i = 0; i < nodeCount; i++) {
        if (!covered[i]) {
            free(covered);
            return false;
        }
    }
    
    free(covered);
    return true;
}

int popcount(int x) {
    int count = 0;
    while (x) {
        count++;
        x &= x - 1;
    }
    return count;
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    
    struct TreeNode* nodes[1000];
    int nodeCount = 0;
    collectNodes(root, nodes, &nodeCount);
    
    int minCameras = 1000000;
    
    for (int mask = 0; mask < (1 << nodeCount); mask++) {
        if (isCovered(nodes, nodeCount, mask)) {
            int cameras = popcount(mask);
            if (cameras < minCameras) {
                minCameras = cameras;
            }
        }
    }
    
    return minCameras == 1000000 ? 0 : minCameras;
}

struct TreeNode* buildTree(int* arr, int size) {
    if (size == 0 || arr[0] == -1001) return NULL;
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        if (i < size && arr[i] != -1001) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        if (i < size && arr[i] != -1001) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int size = 0;
    char* token = strtok(line, "[,] \n");
    while (token != NULL) {
        if (strcmp(token, "null") == 0) {
            arr[size] = -1001;
        } else {
            arr[size] = atoi(token);
        }
        size++;
        token = strtok(NULL, "[,] \n");
    }
    
    struct TreeNode* root = buildTree(arr, size);
    printf("%d\n", solution(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Try all 2^n possible camera placements where n is number of nodes

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to tree height

✓ Linear Space

89.5K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler