Count Nodes Equal to Sum of Descendants - Problem

Given the root of a binary tree, return the number of nodes where the value of the node is equal to the sum of the values of its descendants.

A descendant of a node x is any node that is on the path from node x to some leaf node. The sum is considered to be 0 if the node has no descendants.

Input & Output

Example 1 — Basic Tree

$ Input: root = [10,3,4,2,1]

› Output: 2

💡 Note: Node 10: descendants are [3,4,2,1], sum = 10 (matches). Node 3: descendants are [2,1], sum = 3 (matches). Node 4 has no descendants, sum = 0 ≠ 4.

Example 2 — Single Node

$ Input: root = [2]

› Output: 0

💡 Note: Single node with value 2 and no descendants. Sum of descendants = 0, but node value = 2, so 2 ≠ 0 and it doesn't match.

Example 3 — No Matches

$ Input: root = [0]

› Output: 1

💡 Note: Single node with value 0. It has no descendants, so sum of descendants = 0. Since 0 = 0, this node matches.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 A Amazon 12

The key insight is to use post-order DFS traversal to calculate subtree sums efficiently. Best approach uses single-pass DFS where we calculate descendant sums bottom-up and count matches during traversal. Time: O(n), Space: O(h)

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Dp 1d

⏱️ Time: N/A Space: N/A

Brute Force - Calculate Sum for Each Node

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

Visit each node in the tree, and for each node, make a separate recursive call to calculate the sum of all its descendants. Then check if the node's value equals this sum.

Optimized DFS - Single Pass

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

Perform a post-order depth-first search where we calculate the sum of each subtree during the traversal. This allows us to get subtree sums and count matching nodes in a single pass through the tree.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

int count_nodes = 0;

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

int* parseArray(const char* s, int* size) {
    *size = 0;
    if (strcmp(s, "[]") == 0) {
        return NULL;
    }
    
    int len = strlen(s);
    char* temp = (char*)malloc(len + 1);
    strcpy(temp, s);
    
    // Remove brackets
    memmove(temp, temp + 1, len - 1);
    temp[len - 2] = '\0';
    
    if (strlen(temp) == 0) {
        free(temp);
        return NULL;
    }
    
    // Count elements
    int count = 1;
    for (int i = 0; temp[i]; i++) {
        if (temp[i] == ',') count++;
    }
    
    int* result = (int*)malloc(count * sizeof(int));
    *size = count;
    
    // Parse elements using strtol instead of strtok
    char* p = temp;
    int i = 0;
    
    while (*p && i < count) {
        // Skip whitespace
        while (*p == ' ') p++;
        
        if (strncmp(p, "null", 4) == 0) {
            result[i] = -100001; // Use as null marker
            p += 4;
        } else {
            result[i] = (int)strtol(p, &p, 10);
        }
        
        // Skip whitespace and comma
        while (*p == ' ' || *p == ',') p++;
        i++;
    }
    
    free(temp);
    return result;
}

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

int dfs(TreeNode* node) {
    if (!node) {
        return 0;
    }
    
    int leftSum = dfs(node->left);
    int rightSum = dfs(node->right);
    int descendantsSum = leftSum + rightSum;
    
    if (node->val == descendantsSum) {
        count_nodes++;
    }
    
    return node->val + descendantsSum;
}

int solution(TreeNode* root) {
    count_nodes = 0;
    dfs(root);
    return count_nodes;
}

int main() {
    char rootStr[100001];
    fgets(rootStr, sizeof(rootStr), stdin);
    rootStr[strcspn(rootStr, "\n")] = 0;
    
    int size;
    int* rootArray = parseArray(rootStr, &size);
    TreeNode* root = buildTree(rootArray, size);
    
    int result = solution(root);
    printf("%d\n", result);
    
    if (rootArray) free(rootArray);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.2K Views

Medium Frequency

~15 min Avg. Time

890 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