Number of Good Leaf Nodes Pairs - Problem

You are given the root of a binary tree and an integer distance. A pair of two different leaf nodes of a binary tree is said to be good if the length of the shortest path between them is less than or equal to distance.

Return the number of good leaf node pairs in the tree.

Input & Output

Example 1 — Basic Tree

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

› Output: 1

💡 Note: The only leaf nodes are 3 and 4. The path between them is 3→1→2→4 with length 3, which equals the distance limit of 3.

Example 2 — Multiple Leaves

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

› Output: 2

💡 Note: The leaf nodes are 4,5,6,7. Good pairs are (4,5) with distance 2, and (6,7) with distance 2. Other pairs exceed distance 3.

Example 3 — Single Leaf

$ Input: root = [1], distance = 1

› Output: 0

💡 Note: Only one leaf node exists, so no pairs can be formed.

Constraints

The number of nodes in the tree is in the range [1, 2¹⁰].
1 ≤ Node.val ≤ 100
1 ≤ distance ≤ 10

Visualization

Tap to expand

Asked in

A Amazon 15 G Google 12 M Microsoft 8 F Facebook 6

The key insight is to use DFS to collect distances from each node to leaves in its subtree. The optimal approach uses a single DFS pass with distance propagation: at each node, count valid pairs crossing that node and return incremented distances to parent. Time: O(n × distance²), Space: O(h × distance).

Common Approaches

✓ DFS with Distance Propagation

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

Use DFS to traverse the tree bottom-up. At each node, collect distances to all leaves in left and right subtrees, count valid pairs crossing this node, then propagate distances upward.

Find All Leaves + Path Calculation

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

First collect all leaf nodes with their paths from root. Then for each pair of leaves, find their lowest common ancestor and calculate the total path distance through it.

DFS with Distance Propagation — Algorithm Steps

Step 1: DFS post-order traversal to process children first
Step 2: At each node, get distance arrays from left and right subtrees
Step 3: Count pairs where left_dist + right_dist + 2 ≤ distance
Step 4: Return distances to parent (increment each by 1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Post-order DFS

Process children before parent to collect distances

Count Pairs

At each node, count valid pairs crossing this node

Propagate Up

Return incremented distances to parent node

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;
};

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 parseArray(const char* str, int* arr, int* size, int** null_flags) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    *null_flags = (int*)malloc(1000 * sizeof(int));
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (strncmp(p, "null", 4) == 0) {
            (*null_flags)[*size] = 1;
            arr[(*size)++] = 0;
            p += 4;
        } else {
            (*null_flags)[*size] = 0;
            arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
        }
    }
}

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

int result_count = 0;

int* dfs(struct TreeNode* node, int distance, int* returnSize) {
    if (!node) {
        *returnSize = 0;
        return NULL;
    }
    
    if (!node->left && !node->right) {
        int* result = (int*)malloc(sizeof(int));
        result[0] = 0;
        *returnSize = 1;
        return result;
    }
    
    int left_size, right_size;
    int* left_distances = dfs(node->left, distance, &left_size);
    int* right_distances = dfs(node->right, distance, &right_size);
    
    for (int i = 0; i < left_size; i++) {
        for (int j = 0; j < right_size; j++) {
            if (left_distances[i] + right_distances[j] + 2 <= distance) {
                result_count++;
            }
        }
    }
    
    int* all_distances = (int*)malloc((left_size + right_size) * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < left_size; i++) {
        if (left_distances[i] + 1 < distance) {
            all_distances[count++] = left_distances[i] + 1;
        }
    }
    for (int i = 0; i < right_size; i++) {
        if (right_distances[i] + 1 < distance) {
            all_distances[count++] = right_distances[i] + 1;
        }
    }
    
    *returnSize = count;
    
    if (left_distances) free(left_distances);
    if (right_distances) free(right_distances);
    
    return all_distances;
}

int solution(struct TreeNode* root, int distance) {
    result_count = 0;
    int size;
    int* result = dfs(root, distance, &size);
    if (result) free(result);
    return result_count;
}

int main() {
    char line1[10000], line2[100];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int nodes[1000];
    int* null_flags;
    int size;
    parseArray(line1, nodes, &size, &null_flags);
    
    int distance = atoi(line2);
    
    struct TreeNode* root = build_tree(nodes, null_flags, size);
    int result = solution(root, distance);
    
    printf("%d\n", result);
    
    free(null_flags);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × distance²)

Visit each node once, at each node process at most distance² pairs

✓ Linear Growth

Space Complexity

O(h × distance)

Recursion stack depth h, each level stores at most distance values

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

Number of Good Leaf Nodes Pairs - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

DFS with Distance Propagation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler