Delete Tree Nodes

Delete Tree Nodes - Problem

A tree rooted at node 0 is given as follows:

The number of nodes is nodes
The value of the ith node is value[i]
The parent of the ith node is parent[i]

Remove every subtree whose sum of values of nodes is zero.

Return the number of the remaining nodes in the tree.

Input & Output

Example 1 — Basic Tree Pruning

$ Input: parent = [-1,0,0,1,1,1,1], value = [1,-3,4,0,-2,-1,-2]

› Output: 2

💡 Note: Node 3 and its descendants form subtree with sum 0 + (-2) + (-1) + (-2) = -5. Wait, let me recalculate: Node 1 has value -3, children 3,4,5,6. Subtree sum = -3 + 0 + (-2) + (-1) + (-2) = -8. Only nodes 0 and 2 remain with values 1 and 4.

Example 2 — Single Node Tree

$ Input: parent = [-1], value = [0]

› Output: 0

💡 Note: Root node has value 0, so entire tree is removed. No nodes remain.

Example 3 — No Removal Needed

$ Input: parent = [-1,0,1], value = [1,2,3]

› Output: 3

💡 Note: No subtree has sum 0. All nodes remain: root(1) -> child(2) -> grandchild(3)

Constraints

1 ≤ nodes ≤ 10⁴
parent.length == nodes
0 ≤ parent[i] ≤ nodes - 1
parent[0] == -1 which indicates that 0 is the root
value.length == nodes
-10⁵ ≤ value[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is to use post-order DFS traversal to calculate subtree sums from leaves to root, marking zero-sum subtrees for removal in a single pass. Best approach is DFS post-order with Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Multiple Tree Traversals

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

Build the tree from parent array, then repeatedly scan for zero-sum subtrees and remove them until no more can be found. This requires multiple full tree traversals.

DFS Post-Order Traversal

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

Build tree structure, then perform post-order DFS traversal. Calculate subtree sums from leaves to root, marking zero-sum subtrees for removal during the traversal.

Brute Force - Multiple Tree Traversals — Algorithm Steps

Build tree from parent array
Traverse tree to find zero-sum subtrees
Remove found subtrees
Repeat until no more zero-sum subtrees exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Tree

Construct tree from parent array

Find Zero Sums

Traverse tree to find zero-sum subtrees

Remove & Repeat

Remove found subtrees and scan again

Code -

solution.c — C

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

#define MAX_N 1000

static int children[MAX_N][MAX_N];
static int childCount[MAX_N];
static int value[MAX_N];
static bool removed[MAX_N];
static int n;

int dfs(int node) {
    int subtreeSum = value[node];
    
    // First, process all children
    for (int i = 0; i < childCount[node]; i++) {
        int child = children[node][i];
        subtreeSum += dfs(child);
    }
    
    // If subtree sum is 0, mark this entire subtree as removed
    if (subtreeSum == 0) {
        removed[node] = true;
    }
    
    // If this node is removed, return 0 to parent (don't contribute to parent's sum)
    return removed[node] ? 0 : subtreeSum;
}

int solution(int parent[], int val[], int size) {
    n = size;
    if (n == 0) return 0;
    
    memset(childCount, 0, sizeof(childCount));
    memset(removed, false, sizeof(removed));
    memcpy(value, val, sizeof(int) * n);
    
    // Build adjacency list
    int root = -1;
    for (int i = 0; i < n; i++) {
        if (parent[i] == -1) {
            root = i;
        } else {
            int p = parent[i];
            children[p][childCount[p]++] = i;
        }
    }
    
    // Start DFS from root
    if (root != -1) {
        dfs(root);
    }
    
    // Count remaining nodes
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (!removed[i]) count++;
    }
    return count;
}

int parseArray(char* line, int arr[]) {
    int len = strlen(line);
    int count = 0;
    int i = 0;
    
    // Skip initial '['
    while (i < len && line[i] != '[') i++;
    i++; // skip '['
    
    while (i < len && line[i] != ']') {
        // Skip whitespace and commas
        while (i < len && (line[i] == ' ' || line[i] == ',')) i++;
        
        if (i >= len || line[i] == ']') break;
        
        // Parse number (handle negative)
        int num = 0;
        int sign = 1;
        if (line[i] == '-') {
            sign = -1;
            i++;
        }
        
        while (i < len && line[i] >= '0' && line[i] <= '9') {
            num = num * 10 + (line[i] - '0');
            i++;
        }
        
        arr[count++] = sign * num;
    }
    
    return count;
}

int main() {
    char line1[10000], line2[10000];
    int parent[MAX_N], val[MAX_N];
    
    // Read parent array
    if (fgets(line1, sizeof(line1), stdin) == NULL) return 1;
    int size1 = parseArray(line1, parent);
    
    // Read value array  
    if (fgets(line2, sizeof(line2), stdin) == NULL) return 1;
    int size2 = parseArray(line2, val);
    
    // Both arrays should have same size
    int size = (size1 < size2) ? size1 : size2;
    
    printf("%d\n", solution(parent, val, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

May need O(n) iterations, each requiring O(n) traversal

⚠ Quadratic Growth

Space Complexity

O(n)

Tree structure and visited arrays

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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 - Multiple Tree Traversals — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler