Maximum Subtree of the Same Color

Maximum Subtree of the Same Color - Problem

You are given a 2D integer array edges representing a tree with n nodes, numbered from 0 to n - 1, rooted at node 0, where edges[i] = [ui, vi] means there is an edge between the nodes vi and ui.

You are also given a 0-indexed integer array colors of size n, where colors[i] is the color assigned to node i.

We want to find a node v such that every node in the subtree of v has the same color. Return the size of such subtree with the maximum number of nodes possible.

Input & Output

Example 1 — Basic Tree

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

› Output: 2

💡 Note: Node 1 has a subtree containing nodes {1, 4} both with color 1. This is the largest same-color subtree with size 2.

Example 2 — All Same Color

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

› Output: 3

💡 Note: All nodes have color 1, so the entire tree starting from node 0 forms a same-color subtree of size 3.

Example 3 — No Large Subtrees

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

› Output: 1

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

Constraints

2 ≤ edges.length ≤ 10⁵
0 ≤ edges[i][0], edges[i][1] < n
1 ≤ colors[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Meta 18

The key insight is to use DFS traversal to explore each possible subtree and check if all nodes have the same color. The optimal approach performs DFS from each node to find the largest uniform subtree. Best approach: DFS with subtree validation. Time: O(n²), Space: O(n)

Common Approaches

✓ Brute Force - Check Every Node

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

Build the tree from edges, then for each node, perform DFS to explore its entire subtree and count nodes if they all have the same color as the root node.

Optimized DFS - Single Traversal

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

Perform one DFS traversal starting from root. For each node, check if its subtree has uniform color and track the maximum size found.

Brute Force - Check Every Node — Algorithm Steps

Step 1: Build adjacency list representation of the tree
Step 2: For each node, perform DFS to check if entire subtree has same color
Step 3: Return the maximum subtree size found

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Tree

Create adjacency list from edges

Check Each Node

For each node, DFS to find same-color subtree size

Return Maximum

Track and return the largest subtree found

Code -

solution.c — C

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

typedef struct {
    int* data;
    int size;
    int capacity;
} Vector;

Vector* createVector() {
    Vector* v = malloc(sizeof(Vector));
    v->capacity = 10;
    v->size = 0;
    v->data = malloc(v->capacity * sizeof(int));
    return v;
}

void pushVector(Vector* v, int val) {
    if (v->size == v->capacity) {
        v->capacity *= 2;
        v->data = realloc(v->data, v->capacity * sizeof(int));
    }
    v->data[v->size++] = val;
}

void freeVector(Vector* v) {
    free(v->data);
    free(v);
}

int dfs(int node, int parent, int targetColor, Vector** adj, int* colors) {
    if (colors[node] != targetColor) {
        return 0;
    }
    
    int size = 1;
    for (int i = 0; i < adj[node]->size; i++) {
        int neighbor = adj[node]->data[i];
        if (neighbor != parent) {
            int childSize = dfs(neighbor, node, targetColor, adj, colors);
            size += childSize;
        }
    }
    return size;
}

int solution(int edges[][2], int edgeCount, int* colors, int n) {
    if (n == 1) return 1;
    
    // Build adjacency list using dynamic vectors
    Vector** adj = malloc(n * sizeof(Vector*));
    for (int i = 0; i < n; i++) {
        adj[i] = createVector();
    }
    
    for (int i = 0; i < edgeCount; i++) {
        int u = edges[i][0], v = edges[i][1];
        pushVector(adj[u], v);
        pushVector(adj[v], u);
    }
    
    int maxSize = 1;
    
    // Try each node as root of a same-color subtree
    for (int i = 0; i < n; i++) {
        int subtreeSize = dfs(i, -1, colors[i], adj, colors);
        if (subtreeSize > maxSize) {
            maxSize = subtreeSize;
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        freeVector(adj[i]);
    }
    free(adj);
    
    return maxSize;
}

static int edges[50000][2];
static int colors[100000];

int parseEdges(char* line, int edges[][2]) {
    int count = 0;
    char* ptr = line;
    
    // Find first '['
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return 0;
    ptr++; // skip first '['
    
    while (*ptr) {
        // Look for inner '['
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr) break;
        ptr++; // skip inner '['
        
        // Parse first number
        char* endptr;
        int u = (int)strtol(ptr, &endptr, 10);
        ptr = endptr;
        
        // Skip comma
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
        
        // Parse second number
        int v = (int)strtol(ptr, &endptr, 10);
        ptr = endptr;
        
        edges[count][0] = u;
        edges[count][1] = v;
        count++;
        
        // Skip to end of inner array
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
    }
    return count;
}

int parseColors(char* line, int* colors) {
    int count = 0;
    char* ptr = line;
    
    // Find first '['
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return 0;
    ptr++; // skip '['
    
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\n' || *ptr == '\t')) ptr++;
        if (*ptr == ']' || !*ptr) break;
        
        // Parse number
        char* endptr;
        int val = (int)strtol(ptr, &endptr, 10);
        if (ptr != endptr) {
            colors[count++] = val;
            ptr = endptr;
        } else {
            ptr++;
        }
    }
    return count;
}

int main() {
    char line1[10000], line2[10000];
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    
    int edgeCount = parseEdges(line1, edges);
    int colorCount = parseColors(line2, colors);
    
    printf("%d\n", solution(edges, edgeCount, colors, colorCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse the entire subtree in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Adjacency list storage and recursion stack depth up to n

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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 Node — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler