Minimum Height Trees

Minimum Height Trees - Problem

A tree is an undirected graph in which any two vertices are connected by exactly one path. In other words, any connected graph without simple cycles is a tree.

Given a tree of n nodes labelled from 0 to n - 1, and an array of n - 1 edges where edges[i] = [aᵢ, bᵢ] indicates that there is an undirected edge between the two nodes aᵢ and bᵢ in the tree, you can choose any node of the tree as the root.

When you select a node x as the root, the result tree has height h. Among all possible rooted trees, those with minimum height (i.e. min(h)) are called minimum height trees (MHTs).

Return a list of all MHTs' root labels. You can return the answer in any order.

The height of a rooted tree is the number of edges on the longest downward path between the root and a leaf.

Input & Output

Example 1 — Basic Tree

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

› Output: [1]

💡 Note: Node 1 is connected to all other nodes. When 1 is root, max path length is 1 (1→0, 1→2, or 1→3). Any other root gives height 2.

Example 2 — Linear Tree

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

› Output: [3,4]

💡 Note: Both nodes 3 and 4 are centers. Root 3 gives max path 3→4→5 (length 2). Root 4 gives max path 0→3→4 or 1→3→4 (length 2).

Example 3 — Single Node

$ Input: n = 1, edges = []

› Output: [0]

💡 Note: Only one node exists, so it must be the root with height 0.

Constraints

1 ≤ n ≤ 2 × 10⁴
edges.length == n - 1
0 ≤ aᵢ, bᵢ < n
aᵢ ≠ bᵢ
All the pairs (aᵢ, bᵢ) are distinct
The given input is guaranteed to be a tree and there will be no repeated edges

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is that minimum height trees have their roots at the center nodes of the tree. The optimal approach uses BFS topological sort to remove leaf nodes layer by layer until only 1-2 center nodes remain. Time: O(n), Space: O(n)

Common Approaches

✓ BFS Topological Sort (Optimal)

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

Start with all leaf nodes (degree 1) and remove them level by level. After removing leaves, new leaves are created. The last 1-2 nodes remaining are the centers and give minimum height trees.

Brute Force - Try Every Root

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

For each node, make it the root and perform DFS to find the maximum depth. Track the minimum height found and collect all nodes that achieve this minimum height.

BFS Topological Sort (Optimal) — Algorithm Steps

Step 1: Build adjacency list and count degrees
Step 2: Add all leaf nodes (degree 1) to queue
Step 3: Remove leaves layer by layer, updating degrees
Step 4: The last 1-2 remaining nodes are the answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Identify all leaf nodes (degree 1)

Remove Leaves

Remove leaves and update degrees

Center Found

Remaining 1-2 nodes are the centers

Code -

solution.c — C

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

int* solution(int n, int** edges, int edgesSize, int* returnSize) {
    *returnSize = 0;
    if (n == 1) {
        int* result = (int*)malloc(sizeof(int));
        result[0] = 0;
        *returnSize = 1;
        return result;
    }
    
    // Build adjacency list and degree count
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSize = (int*)calloc(n, sizeof(int));
    int* degree = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(n * sizeof(int));
    }
    
    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;
        degree[a]++;
        degree[b]++;
    }
    
    // Find initial leaves
    int* queue = (int*)malloc(n * sizeof(int));
    int front = 0, rear = 0;
    
    for (int i = 0; i < n; i++) {
        if (degree[i] == 1) {
            queue[rear++] = i;
        }
    }
    
    int remaining = n;
    
    // Remove leaves layer by layer
    while (remaining > 2) {
        int leavesCount = rear - front;
        remaining -= leavesCount;
        
        int newRear = rear;
        for (int i = 0; i < leavesCount; i++) {
            int leaf = queue[front + i];
            for (int j = 0; j < graphSize[leaf]; j++) {
                int neighbor = graph[leaf][j];
                degree[neighbor]--;
                if (degree[neighbor] == 1) {
                    queue[newRear++] = neighbor;
                }
            }
        }
        front = rear;
        rear = newRear;
    }
    
    int* result = (int*)malloc((rear - front) * sizeof(int));
    *returnSize = rear - front;
    for (int i = 0; i < *returnSize; i++) {
        result[i] = queue[front + i];
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSize);
    free(degree);
    free(queue);
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    static char line[10000];
    scanf(" %s", line);
    
    int edgesSize = 0;
    int** edges = NULL;
    
    // Handle empty array case
    if (strcmp(line, "[]") != 0) {
        // Count edges first
        for (int i = 0; line[i]; i++) {
            if (line[i] == '[' && i > 0) edgesSize++;
        }
        
        edges = (int**)malloc(edgesSize * sizeof(int*));
        for (int i = 0; i < edgesSize; i++) {
            edges[i] = (int*)malloc(2 * sizeof(int));
        }
        
        // Parse edges
        int edgeIdx = 0;
        int i = 0;
        while (line[i] && edgeIdx < edgesSize) {
            if (line[i] == '[' && i > 0) {
                i++; // skip '['
                
                // Parse first number
                int num = 0;
                while (line[i] >= '0' && line[i] <= '9') {
                    num = num * 10 + (line[i] - '0');
                    i++;
                }
                edges[edgeIdx][0] = num;
                
                // Skip comma
                while (line[i] == ',' || line[i] == ' ') i++;
                
                // Parse second number
                num = 0;
                while (line[i] >= '0' && line[i] <= '9') {
                    num = num * 10 + (line[i] - '0');
                    i++;
                }
                edges[edgeIdx][1] = num;
                
                edgeIdx++;
            }
            i++;
        }
    }
    
    int returnSize;
    int* result = solution(n, edges, edgesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    if (edges) {
        for (int i = 0; i < edgesSize; i++) {
            free(edges[i]);
        }
        free(edges);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node and edge is processed exactly once

⚠ Quadratic Growth

Space Complexity

O(n)

Adjacency list, degree array, and BFS queue storage

⚡ Linearithmic Space

95.0K Views

Medium Frequency

~25 min Avg. Time

2.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

BFS Topological Sort (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler