Maximum Subtree of the Same Color - Practice Coding Problems

Maximum Subtree of the Same Color - Problem

You're given a tree with n nodes numbered from 0 to n-1, rooted at node 0. The tree structure is defined by a 2D array edges where edges[i] = [u_i, v_i] represents an edge between nodes u_i and v_i.

Each node is painted with a color represented by the array colors, where colors[i] is the color of node i.

Your goal is to find the largest subtree where all nodes have the same color. A subtree rooted at node v includes node v and all its descendants.

Return the maximum number of nodes in such a monochromatic subtree.

Example: If we have a tree where node 2 and all its children have color 'red', and this subtree contains 5 nodes, while no other subtree has more than 5 nodes of the same color, then the answer is 5.

Input & Output

example_1.py — Basic Tree

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

› Output: 3

💡 Note: The subtree rooted at node 2 contains nodes {2,3,4} all with color 2, giving us the maximum size of 3.

example_2.py — Single Node

$ Input: edges = [], colors = [1]

› Output: 1

💡 Note: With only one node, the maximum monochromatic subtree has size 1.

example_3.py — All Different Colors

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

› Output: 1

💡 Note: Every node has a different color, so the maximum monochromatic subtree size is 1 (any single node).

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
0 ≤ u_i, v_i < n
1 ≤ colors[i] ≤ 10⁵
The input represents a valid tree (connected and acyclic)

Visualization

Tap to expand

Understanding the Visualization

Build Tree Structure

Convert edge list to adjacency list representation

Start DFS from Root

Begin post-order traversal from node 0

Process Leaf Nodes

Leaf nodes are always monochromatic (size 1)

Check Parent Nodes

For each parent, verify if all children have the same color

Calculate Subtree Sizes

If monochromatic, sum up all children sizes + 1

Track Maximum

Keep track of the largest monochromatic subtree found

Key Takeaway

🎯 Key Insight: Post-order DFS allows us to solve this efficiently in O(n) time by processing children before parents and building up subtree information bottom-up.

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses post-order DFS traversal to process each node exactly once. By visiting children before parents, we can efficiently determine if a subtree is monochromatic and calculate its size in O(n) time. The key insight is that a subtree is monochromatic if and only if all its children are monochromatic and have the same color as the current node.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Subtree)	O(n²)	O(n)	For each node, perform DFS to check if its subtree is monochromatic
Single DFS with Memoization	O(n)	O(n)	Use post-order DFS to calculate subtree information in one pass

Brute Force (Check Every Subtree) — Algorithm Steps

Build adjacency list representation of the tree
For each node from 0 to n-1, start a DFS to check its subtree
In the DFS, verify all nodes in the subtree have the same color as the root
Count the size of valid monochromatic subtrees
Return the maximum size found

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Root

Choose a node to check its subtree

DFS Traversal

Visit all descendants and verify same color

Count & Record

If valid, count nodes and update maximum

Repeat

Repeat for all nodes as potential roots

Code -

solution.c — C

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

#define MAX_N 1000

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
int colors[MAX_N];
int n;

int dfsCheck(int node, int parent, int targetColor) {
    if (colors[node] != targetColor) return 0;
    
    int size = 1;
    for (int i = 0; i < graphSize[node]; i++) {
        int child = graph[node][i];
        if (child != parent) {
            int childSize = dfsCheck(child, node, targetColor);
            if (childSize == 0) return 0;
            size += childSize;
        }
    }
    return size;
}

int largestColorSubtree(int edges[][2], int edgesSize, int* colorsArr, int colorsSize) {
    if (edgesSize == 0) return 1;
    
    n = colorsSize;
    memset(graphSize, 0, sizeof(graphSize));
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    for (int i = 0; i < n; i++) {
        colors[i] = colorsArr[i];
    }
    
    int maxSize = 1;
    for (int root = 0; root < n; root++) {
        int subtreeSize = dfsCheck(root, -1, colors[root]);
        if (subtreeSize > maxSize) {
            maxSize = subtreeSize;
        }
    }
    
    return maxSize;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially visit all n nodes in DFS

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and recursion stack (tree height)

⚡ Linearithmic Space

42.3K Views

Medium-High Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check Every Subtree) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler