Number of Good Leaf Nodes Pairs - Practice Coding Problems

Number of Good Leaf Nodes Pairs - Problem

Given the root of a binary tree and an integer distance, you need to find all "good" leaf node pairs.

A pair of two different leaf nodes is considered good if the shortest path between them has length less than or equal to distance. The shortest path between two nodes is measured by counting the number of edges in the path.

Goal: Return the total number of good leaf node pairs in the tree.

Example: If we have leaf nodes A and B, and the path from A to their lowest common ancestor to B has 3 edges total, then this pair is good if distance >= 3.

Input & Output

example_1.py — Basic Tree

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

› Output: 1

💡 Note: The only leaf nodes are 4 and 3. The distance between them is 3 (4→2→1→3), which equals our distance limit, so this pair counts.

example_2.py — Multiple Leaves

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

› Output: 2

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

example_3.py — Single Node

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

› Output: 0

💡 Note: Only one node exists, so there are no pairs of different leaf nodes possible.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

🍃 Identify Leaves

Find all leaf nodes - these are the children who can form friendships

📏 Measure Distances

For each pair of leaves, calculate the path distance through their lowest common ancestor

✅ Count Valid Pairs

Count pairs where the total path distance is ≤ the given distance limit

⚡ Optimize with DFS

Use postorder traversal to count pairs efficiently in one pass

Key Takeaway

🎯 Key Insight: Instead of checking every leaf pair individually, we use postorder DFS to count valid pairs at their lowest common ancestor, achieving optimal efficiency with a single tree traversal.

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses a postorder DFS traversal where each node returns distance information about leaves in its subtree. At each internal node, we count valid pairs between leaves from different subtrees and propagate updated distances upward. This achieves O(n × d²) time complexity with a single tree traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal: Postorder DFS with Distance Arrays	O(n × d²)	O(n × d)	Use postorder traversal to collect distances and count pairs at LCA
Brute Force DFS for Each Leaf Pair	O(n² * h)	O(n + h)	Find all leaves, then calculate distance between every pair using DFS

Optimal: Postorder DFS with Distance Arrays — Algorithm Steps

Use postorder DFS traversal (visit children before parent)
Each leaf node returns array [0] (distance 0 to itself)
Each internal node gets distance arrays from left and right subtrees
Count pairs where left_dist + right_dist + 2 ≤ distance
Increment all distances by 1 and merge arrays for parent
Prune distances > distance limit for efficiency

Visualization

Tap to expand

Step-by-Step Walkthrough

Postorder Traversal

Visit children before processing current node

Collect Distances

Each node returns distances to all leaves in its subtree

Count at LCA

Count pairs between left and right subtrees

Propagate Up

Increment distances by 1 for parent level

Code -

solution.c — C

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

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

struct Result {
    int* distances;
    int distCount;
    int pairs;
};

struct Result dfs(struct TreeNode* node, int distance) {
    struct Result result = {NULL, 0, 0};
    
    if (!node) {
        return result;
    }
    
    if (!node->left && !node->right) {
        result.distances = malloc(sizeof(int));
        result.distances[0] = 0;
        result.distCount = 1;
        result.pairs = 0;
        return result;
    }
    
    struct Result leftResult = dfs(node->left, distance);
    struct Result rightResult = dfs(node->right, distance);
    
    result.pairs = leftResult.pairs + rightResult.pairs;
    
    // Count cross-subtree pairs
    for (int i = 0; i < leftResult.distCount; i++) {
        for (int j = 0; j < rightResult.distCount; j++) {
            if (leftResult.distances[i] + rightResult.distances[j] + 2 <= distance) {
                result.pairs++;
            }
        }
    }
    
    // Prepare distances for parent
    int capacity = leftResult.distCount + rightResult.distCount;
    result.distances = malloc(capacity * sizeof(int));
    result.distCount = 0;
    
    for (int i = 0; i < leftResult.distCount; i++) {
        if (leftResult.distances[i] + 1 < distance) {
            result.distances[result.distCount++] = leftResult.distances[i] + 1;
        }
    }
    for (int i = 0; i < rightResult.distCount; i++) {
        if (rightResult.distances[i] + 1 < distance) {
            result.distances[result.distCount++] = rightResult.distances[i] + 1;
        }
    }
    
    if (leftResult.distances) free(leftResult.distances);
    if (rightResult.distances) free(rightResult.distances);
    
    return result;
}

int countPairs(struct TreeNode* root, int distance) {
    struct Result result = dfs(root, distance);
    int pairs = result.pairs;
    if (result.distances) free(result.distances);
    return pairs;
}

int main() {
    int distance;
    scanf("%d", &distance);
    printf("%d\n", countPairs(NULL, distance));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × d²)

O(n) nodes, each potentially processing O(d²) pairs where d is the distance limit

✓ Linear Growth

Space Complexity

O(n × d)

O(n) recursion stack and up to O(d) distances stored per node

⚡ Linearithmic Space

42.5K Views

Medium Frequency

~15 min Avg. Time

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

Optimal: Postorder DFS with Distance Arrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler