Insufficient Nodes in Root to Leaf Paths

Insufficient Nodes in Root to Leaf Paths - Problem

Given the root of a binary tree and an integer limit, delete all insufficient nodes in the tree simultaneously, and return the root of the resulting binary tree.

A node is insufficient if every root to leaf path intersecting this node has a sum strictly less than limit.

A leaf is a node with no children.

Input & Output

Example 1 — All paths insufficient

$ Input: root = [5,4,8,11,null,13,4,7,2,null,null,null,1], limit = 22

› Output: []

💡 Note: All root-to-leaf paths (5→4→11→7=27, 5→4→11→2=22, 5→8→13=26, 5→8→4→1=18) have at least one path ≥22, but the node structure requires careful analysis. In this case, all nodes end up being removed.

Example 2 — Some paths sufficient

$ Input: root = [1,2,3,4,-99,-99,7,8,9,-99,-99,12,13,-99,14], limit = 1

› Output: [1,2,3,4,null,null,7,8,9,null,14]

💡 Note: Paths with sum ≥ 1 are kept: 1→2→4→8=15, 1→2→4→9=16, 1→3→7→14=25. Nodes with -99 are removed as they make paths insufficient.

Example 3 — Single node tree

$ Input: root = [5], limit = 10

› Output: []

💡 Note: Single node with value 5 < 10, so it's insufficient and removed.

Constraints

The number of nodes in the tree is in the range [1, 5000]
-10⁵ ≤ Node.val ≤ 10⁵
-10⁹ ≤ limit ≤ 10⁹

Visualization

Tap to expand

Asked in

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

The optimal approach uses post-order DFS traversal to process children before parents. We recursively check each node's contribution to valid paths and remove nodes where all paths are insufficient. Key insight: process leaves first to determine which internal nodes should be kept. Time: O(n), Space: O(h).

Common Approaches

✓ Path Collection + Filtering

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

First traverse the tree to collect all root-to-leaf paths with their sums. Then rebuild the tree by only including nodes that are part of at least one path with sum >= limit.

Post-order DFS (Optimal)

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

Process children before parent using post-order DFS. For each node, check if any path through it meets the limit. Remove the node only if all paths through it are insufficient.

Path Collection + Filtering — Algorithm Steps

Step 1: Traverse tree and collect all root-to-leaf paths with sums
Step 2: Filter paths to keep only those with sum >= limit
Step 3: Rebuild tree using only nodes from valid paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect All Paths

Traverse tree to find all root-to-leaf paths with sums

Filter Valid Paths

Keep only paths with sum >= limit

Rebuild Tree

Construct new tree using only nodes from valid paths

Code -

solution.c — C

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

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

static struct TreeNode* helper(struct TreeNode* node, int currentSum, int limit) {
    if (!node) return NULL;
    
    currentSum += node->val;
    
    // Recursively process children
    node->left = helper(node->left, currentSum, limit);
    node->right = helper(node->right, currentSum, limit);
    
    // If it's a leaf node, check if path sum is sufficient
    if (!node->left && !node->right) {
        return currentSum >= limit ? node : NULL;
    }
    
    // If it's an internal node, keep it if at least one child exists
    return (node->left || node->right) ? node : NULL;
}

struct TreeNode* solution(struct TreeNode* root, int limit) {
    return helper(root, 0, limit);
}

static struct TreeNode* deserializeTree(const char* data) {
    if (strcmp(data, "[]") == 0) return NULL;
    
    static int values[5001];
    static int isNull[5001];
    int count = 0;
    
    int len = strlen(data);
    int i = 1; // Skip '['
    
    while (i < len - 1) {
        while (i < len && (data[i] == ' ' || data[i] == ',')) i++;
        if (i >= len - 1) break;
        
        if (strncmp(data + i, "null", 4) == 0) {
            isNull[count] = 1;
            i += 4;
        } else {
            isNull[count] = 0;
            int sign = 1;
            if (data[i] == '-') {
                sign = -1;
                i++;
            }
            int val = 0;
            while (i < len && isdigit(data[i])) {
                val = val * 10 + (data[i] - '0');
                i++;
            }
            values[count] = sign * val;
        }
        count++;
    }
    
    if (count == 0 || isNull[0]) return NULL;
    
    static struct TreeNode nodes[5001];
    static struct TreeNode* queue[5001];
    int queueFront = 0, queueRear = 0;
    
    nodes[0].val = values[0];
    nodes[0].left = NULL;
    nodes[0].right = NULL;
    queue[queueRear++] = &nodes[0];
    
    int nodeIndex = 1;
    int valueIndex = 1;
    
    while (queueFront < queueRear && valueIndex < count) {
        struct TreeNode* node = queue[queueFront++];
        
        if (valueIndex < count && !isNull[valueIndex]) {
            nodes[nodeIndex].val = values[valueIndex];
            nodes[nodeIndex].left = NULL;
            nodes[nodeIndex].right = NULL;
            node->left = &nodes[nodeIndex];
            queue[queueRear++] = &nodes[nodeIndex];
            nodeIndex++;
        }
        valueIndex++;
        
        if (valueIndex < count && !isNull[valueIndex]) {
            nodes[nodeIndex].val = values[valueIndex];
            nodes[nodeIndex].left = NULL;
            nodes[nodeIndex].right = NULL;
            node->right = &nodes[nodeIndex];
            queue[queueRear++] = &nodes[nodeIndex];
            nodeIndex++;
        }
        valueIndex++;
    }
    
    return &nodes[0];
}

static void serializeTree(struct TreeNode* root) {
    if (!root) {
        printf("[]\n");
        return;
    }
    
    static struct TreeNode* queue[10001];
    static int result[10001];
    static int isNullResult[10001];
    int queueFront = 0, queueRear = 0;
    int resultCount = 0;
    
    queue[queueRear++] = root;
    
    while (queueFront < queueRear) {
        struct TreeNode* node = queue[queueFront++];
        
        if (node) {
            result[resultCount] = node->val;
            isNullResult[resultCount] = 0;
            queue[queueRear++] = node->left;
            queue[queueRear++] = node->right;
        } else {
            isNullResult[resultCount] = 1;
        }
        resultCount++;
    }
    
    while (resultCount > 0 && isNullResult[resultCount - 1]) {
        resultCount--;
    }
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        if (i > 0) printf(",");
        if (isNullResult[i]) {
            printf("null");
        } else {
            printf("%d", result[i]);
        }
    }
    printf("]\n");
}

int main() {
    static char rootStr[100001];
    int limit;
    
    fgets(rootStr, sizeof(rootStr), stdin);
    scanf("%d", &limit);
    
    // Remove newline
    int len = strlen(rootStr);
    if (len > 0 && rootStr[len-1] == '\n') {
        rootStr[len-1] = '\0';
    }
    
    struct TreeNode* root = deserializeTree(rootStr);
    struct TreeNode* result = solution(root, limit);
    serializeTree(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to collect paths × O(n) average path length, plus O(n) reconstruction

⚠ Quadratic Growth

Space Complexity

O(n²)

Storing all paths can take O(n²) space in worst case (skewed tree)

⚠ Quadratic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

785 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

Path Collection + Filtering — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler