Sum of Nodes with Even-Valued Grandparent - Problem

Given the root of a binary tree, return the sum of values of nodes with an even-valued grandparent.

A grandparent of a node is the parent of its parent if it exists.

If there are no nodes with an even-valued grandparent, return 0.

Input & Output

Example 1 — Basic Tree

$ Input: root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]

› Output: 18

💡 Note: Nodes with even-valued grandparent 6: nodes 7,1,4 (sum=12). Nodes with even-valued grandparent 8: node 5 (sum=5). But wait, let me recalculate: grandchildren of 6 are 2,7,1,3 and grandchildren of 8 are null,5. So sum = 2+7+1+3+5 = 18.

Example 2 — Simple Tree

$ Input: root = [6,7,8,2,4,1,3]

› Output: 10

💡 Note: Node 6 is even. Its grandchildren are 2,4,1,3. Sum = 2+4+1+3 = 10

Example 3 — No Even Grandparents

$ Input: root = [1]

› Output: 0

💡 Note: Only one node exists, no grandchildren possible

Constraints

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

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12

The key insight is to track grandparent information during DFS traversal. As we visit each node, we pass down the grandparent and parent from the previous levels. Best approach is DFS with parameter passing giving us optimal Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Brute Force - Check Every Node

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

Visit every node in the tree. For each node, traverse upward to find its grandparent (if exists), check if the grandparent value is even, and add current node's value to sum if so.

DFS with Grandparent Tracking

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

Use depth-first search to traverse the tree while keeping track of grandparent and parent nodes. When visiting a node, check if grandparent is even and add to sum if so.

Brute Force - Check Every Node — Algorithm Steps

Traverse all nodes
For each node, find its grandparent
If grandparent exists and is even, add to sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit Node

Start at a node and search for its parent

Find Grandparent

From parent, search for grandparent

Check & Sum

If grandparent is even, add node value to sum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.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 getAllNodes(struct TreeNode* node, struct TreeNode** nodes, int* count) {
    if (!node) return;
    nodes[(*count)++] = node;
    getAllNodes(node->left, nodes, count);
    getAllNodes(node->right, nodes, count);
}

struct TreeNode* findParent(struct TreeNode* node, struct TreeNode* target, struct TreeNode* parent) {
    if (!node) return NULL;
    if (node == target) return parent;
    struct TreeNode* leftResult = findParent(node->left, target, node);
    if (leftResult) return leftResult;
    return findParent(node->right, target, node);
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    
    struct TreeNode* allNodes[1000];
    int nodeCount = 0;
    getAllNodes(root, allNodes, &nodeCount);
    
    int total = 0;
    for (int i = 0; i < nodeCount; i++) {
        struct TreeNode* parent = findParent(root, allNodes[i], NULL);
        if (parent) {
            struct TreeNode* grandparent = findParent(root, parent, NULL);
            if (grandparent && grandparent->val % 2 == 0) {
                total += allNodes[i]->val;
            }
        }
    }
    
    return total;
}

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);
        }
        token = strtok(NULL, "[],\n ");
    }
    
    struct TreeNode* root = buildTree(arr, size);
    printf("%d\n", solution(root));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we might traverse up to root to find grandparent

✓ Linear Growth

Space Complexity

O(h)

Recursion depth equals tree height h

✓ Linear Space

18.5K Views

Medium Frequency

~15 min Avg. Time

891 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

Sum of Nodes with Even-Valued Grandparent - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check Every Node — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler