Count the Number of Good Nodes - Practice Coding Problems

Count the Number of Good Nodes - Problem

Imagine a family tree where node 0 is the patriarch/matriarch at the root. Each node represents a family member, and the connections show parent-child relationships. Given an undirected tree with n nodes labeled from 0 to n-1, you need to determine how many nodes are "good".

A node is considered good if all of its children's subtree sizes are identical. In other words, if you look at any node and count how many descendants each of its children has (including the child itself), those counts must all be equal for the node to be "good".

Input: A 2D array edges where edges[i] = [a_i, b_i] represents an edge between nodes a_i and b_i.

Output: Return the total count of good nodes in the tree.

Note: Leaf nodes (nodes with no children) are always considered good since there are no subtrees to compare!

Input & Output

example_1.py — Basic Tree

$ Input: edges = [[0,1],[0,2],[1,3],[1,4]]

› Output: 4

💡 Note: Tree structure: 0->1,2 where 1->3,4. Node 0 is not good (children have subtree sizes 3 and 1). Node 1 is good (children 3,4 both have subtree size 1). Nodes 2,3,4 are good (leaves). Total: 4 good nodes.

example_2.py — Single Node

$ Input: edges = []

› Output: 1

💡 Note: Single node tree with just node 0. A single node has no children, so it's considered good by definition.

example_3.py — Balanced Tree

$ Input: edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]]

› Output: 6

💡 Note: Perfect binary tree where node 0 has children 1,2, each with subtree size 3. Node 1 has children 3,4 (size 1 each). Node 2 has children 5,6 (size 1 each). All nodes are good since children have equal subtree sizes. Total: 6 good nodes.

Constraints

1 ≤ n ≤ 10⁵ where n is the number of nodes
edges.length == n - 1 (valid tree structure)
0 ≤ a_i, b_i < n
The given edges form a valid tree (connected and acyclic)

Visualization

Tap to expand

Understanding the Visualization

Start from Leaves

Begin with employees who manage no one - they're automatically balanced

Calculate Team Sizes

For each manager, sum up team sizes of direct reports

Check Balance

Compare if all direct reports have equal team sizes

Propagate Upward

Move up the hierarchy using calculated team sizes

Key Takeaway

🎯 Key Insight: Post-order DFS ensures we calculate team sizes from bottom-up, allowing us to check balance conditions efficiently in O(n) time.

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal solution uses a single post-order DFS traversal to calculate subtree sizes and count good nodes efficiently. By processing children before parents, we ensure that when checking if a node is good, we already know all its children's subtree sizes. This achieves O(n) time complexity compared to the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple DFS)	O(n²)	O(n)	For each node, run separate DFS to calculate all children's subtree sizes
Single DFS Traversal (Optimal)	O(n)	O(h)	Use post-order DFS to calculate subtree sizes and count good nodes in one pass

Brute Force (Multiple DFS) — Algorithm Steps

Build adjacency list from edges
For each node from 0 to n-1:
- Find all its children in the rooted tree
- For each child, run DFS to calculate subtree size
- Check if all subtree sizes are equal
- If yes, increment good node counter
Return total count of good nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Node 0

Run DFS from each child to calculate subtree sizes

Check Node 1

Again run DFS from each child - notice the repeated work

Continue Process

Repeat for all nodes, doing redundant calculations

Code -

solution.c — C

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

#define MAX_N 100000

struct Node {
    int* children;
    int childCount;
    int capacity;
};

struct Node graph[MAX_N];
int parentMap[MAX_N];
int n;

void addEdge(int a, int b) {
    // Add b to a's adjacency list
    if (graph[a].childCount == graph[a].capacity) {
        graph[a].capacity = graph[a].capacity ? graph[a].capacity * 2 : 1;
        graph[a].children = realloc(graph[a].children, graph[a].capacity * sizeof(int));
    }
    graph[a].children[graph[a].childCount++] = b;
    
    // Add a to b's adjacency list
    if (graph[b].childCount == graph[b].capacity) {
        graph[b].capacity = graph[b].capacity ? graph[b].capacity * 2 : 1;
        graph[b].children = realloc(graph[b].children, graph[b].capacity * sizeof(int));
    }
    graph[b].children[graph[b].childCount++] = a;
}

int dfsSubtreeSize(int node, int parent) {
    int size = 1;
    for (int i = 0; i < graph[node].childCount; i++) {
        int child = graph[node].children[i];
        if (child != parent) {
            size += dfsSubtreeSize(child, node);
        }
    }
    return size;
}

int countGoodNodes(int edges[][2], int edgeCount) {
    if (edgeCount == 0) return 1;
    
    n = edgeCount + 1;
    
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graph[i].children = NULL;
        graph[i].childCount = 0;
        graph[i].capacity = 0;
    }
    
    // Build adjacency list
    for (int i = 0; i < edgeCount; i++) {
        addEdge(edges[i][0], edges[i][1]);
    }
    
    // Build parent map using BFS
    int queue[MAX_N];
    int visited[MAX_N] = {0};
    int front = 0, rear = 0;
    
    parentMap[0] = -1;
    queue[rear++] = 0;
    visited[0] = 1;
    
    while (front < rear) {
        int curr = queue[front++];
        for (int i = 0; i < graph[curr].childCount; i++) {
            int neighbor = graph[curr].children[i];
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                parentMap[neighbor] = curr;
                queue[rear++] = neighbor;
            }
        }
    }
    
    int goodCount = 0;
    
    for (int node = 0; node < n; node++) {
        int parent = parentMap[node];
        
        // Get children of current node
        int children[MAX_N];
        int childCount = 0;
        
        for (int i = 0; i < graph[node].childCount; i++) {
            int neighbor = graph[node].children[i];
            if (neighbor != parent) {
                children[childCount++] = neighbor;
            }
        }
        
        if (childCount == 0) {
            goodCount++;
        } else {
            // Calculate subtree sizes
            int subtreeSizes[MAX_N];
            for (int i = 0; i < childCount; i++) {
                subtreeSizes[i] = dfsSubtreeSize(children[i], node);
            }
            
            // Check if all sizes are equal
            int allEqual = 1;
            for (int i = 1; i < childCount; i++) {
                if (subtreeSizes[i] != subtreeSizes[0]) {
                    allEqual = 0;
                    break;
                }
            }
            
            if (allEqual) {
                goodCount++;
            }
        }
    }
    
    // Clean up
    for (int i = 0; i < n; i++) {
        free(graph[i].children);
    }
    
    return goodCount;
}

int main() {
    // Simplified input parsing
    int edgeCount;
    scanf("%d", &edgeCount);
    
    int edges[MAX_N][2];
    for (int i = 0; i < edgeCount; i++) {
        scanf("%d %d", &edges[i][0], &edges[i][1]);
    }
    
    printf("%d\n", countGoodNodes(edges, edgeCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse the entire tree to calculate subtree sizes

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and recursion stack depth up to n

⚡ Linearithmic Space

41.3K Views

Medium Frequency

~18 min Avg. Time

1.8K 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 DFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler