Number of Nodes in the Sub-Tree With the Same Label

Number of Nodes in the Sub-Tree With the Same Label - Problem

Tree Node Counting Challenge

Imagine you're analyzing a company's organizational chart where each employee has a department label (like 'a', 'b', 'c'). Your task is to help each employee count how many people in their entire team hierarchy (including themselves) work in the same department.

You're given:
• A tree structure with n employees numbered from 0 to n-1
• Employee 0 is the CEO (root of the tree)
• Each employee has a department label from the string labels
• The edges array shows the reporting relationships

Goal: For each employee i, count how many people in their subtree (team + all subordinates) have the same department label as employee i.

Example: If employee 3 works in department 'b' and has 2 subordinates also in department 'b', the answer for employee 3 would be 3 (including themselves).

Input & Output

example_1.py — Basic Tree

$ Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], labels = "abaedcd"

› Output: [2,1,1,1,1,1,1]

💡 Note: Node 0 has label 'a' and its subtree contains nodes {0,1,2,3,4,5,6} with labels 'abaedcd'. Only nodes 0 and 2 have label 'a', so result[0] = 2. Each other node has a unique label in their subtree, so they all get count 1.

example_2.py — Multiple Same Labels

$ Input: n = 4, edges = [[0,1],[1,2],[0,3]], labels = "bbbb"

› Output: [4,2,1,1]

💡 Note: All nodes have label 'b'. Node 0's subtree includes all nodes {0,1,2,3}, so result[0] = 4. Node 1's subtree includes {1,2}, so result[1] = 2. Nodes 2 and 3 are leaves with only themselves, so result[2] = result[3] = 1.

example_3.py — Single Node

$ Input: n = 1, edges = [], labels = "a"

› Output: [1]

💡 Note: Only one node with label 'a'. Its subtree contains only itself, so the result is [1].

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
edges[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
labels.length == n
labels consists of lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Build the Organization Chart

Convert the edges into a tree structure representing reporting relationships

Start from the Bottom

Use post-order DFS to process leaf employees first, then move up the hierarchy

Aggregate Department Counts

Each manager collects department statistics from their direct reports

Add Own Department

Each person adds their own department to the count and records their result

Key Takeaway

🎯 Key Insight: Use post-order DFS with frequency arrays to count labels efficiently in a single traversal, avoiding redundant subtree visits.

Asked in

f Facebook 35 a Amazon 28 G Google 22 ⊞ Microsoft 18

The optimal approach uses a single DFS traversal with frequency counting. By processing the tree in post-order (bottom-up), we collect label frequencies from children, combine them, and add the current node's label. This eliminates redundant traversals and achieves O(n) time complexity instead of the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple DFS)	O(n²)	O(n)	For each node, perform separate DFS to count matching labels in subtree
Single DFS with Label Counting (Optimal)	O(n)	O(n)	Use single DFS traversal with frequency counting to solve for all nodes efficiently

Brute Force (Multiple DFS) — Algorithm Steps

Build adjacency list from edges array
For each node i from 0 to n-1:
Start DFS from node i to count nodes with label[i]
Store the count in result array
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with node 0

Perform DFS from node 0 to count nodes with label 'a'

Move to node 1

Perform DFS from node 1 to count nodes with label 'b'

Continue for all nodes

Repeat DFS for each remaining node

Code -

solution.c — C

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

int dfs(int node, int parent, char targetLabel, int** graph, int* graphSize, char* labels) {
    int count = (labels[node] == targetLabel) ? 1 : 0;
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor != parent) {
            count += dfs(neighbor, node, targetLabel, graph, graphSize, labels);
        }
    }
    return count;
}

int* countSubTrees(int n, int** edges, int edgesSize, int* edgesColSize, char* labels, int* returnSize) {
    // Build adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSize = (int*)calloc(n, sizeof(int));
    
    // Count edges for each node
    for (int i = 0; i < edgesSize; i++) {
        graphSize[edges[i][0]]++;
        graphSize[edges[i][1]]++;
    }
    
    // Allocate memory for adjacency lists
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(graphSize[i] * sizeof(int));
        graphSize[i] = 0; // Reset for building
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        graph[a][graphSize[a]++] = b;
        graph[b][graphSize[b]++] = a;
    }
    
    int* result = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        result[i] = dfs(i, -1, labels[i], graph, graphSize, labels);
    }
    
    *returnSize = n;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we perform DFS that can visit up to n nodes

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and recursion stack depth up to n

⚡ Linearithmic Space

68.0K Views

Medium Frequency

~25 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