Minimum Height Trees - Practice Coding Problems

Minimum Height Trees - Problem

Imagine you're a city planner tasked with placing a central communication tower in a connected network of cities. The cities are connected by roads forming a tree structure - meaning every city can reach every other city through exactly one path, with no circular routes.

Given n cities labeled from 0 to n-1 and an array of n-1 roads where edges[i] = [a, b] represents a direct road between cities a and b, you need to find the optimal locations for your communication tower.

The height of your communication network is the maximum number of road hops needed to reach the farthest city from your tower location. Your goal is to minimize this maximum distance - find all possible tower locations that result in the smallest possible network height.

Return a list of all optimal tower locations (city labels) that minimize the communication network height.

Input & Output

example_1.py — Basic Tree

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

› Output: [1]

💡 Note: Node 1 is connected to nodes 0, 2, and 3. When rooted at 1, all other nodes are at distance 1, giving height 1. Any other root would have height 2.

example_2.py — 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 can serve as roots for minimum height trees. When rooted at either, the maximum distance to any node is 2.

example_3.py — Single Node

$ Input: n = 1, edges = []

› Output: [0]

💡 Note: With only one node, it must be the root, and the tree height is 0.

Visualization

Tap to expand

Understanding the Visualization

Build Graph

Create adjacency list and identify initial leaf nodes (degree = 1)

Remove Leaves

Remove all leaf nodes and update their neighbors' degrees

Find New Leaves

Neighbors of removed leaves may become new leaf nodes

Repeat

Continue until only 1-2 nodes remain - these are the centers

Key Takeaway

🎯 Key Insight: The center of a tree is found by repeatedly removing leaf nodes - it's like peeling layers of an onion to find the core. There can be at most 2 centers in any tree.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is processed exactly once, each edge is examined at most twice

✓ Linear Growth

Space Complexity

O(n)

Space for adjacency list, degree array, and queue

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 2 × 10⁴
edges.length == n - 1
0 ≤ a_i, b_i < n
a_i ≠ b_i
The given input is guaranteed to be a tree

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a topological sort approach that repeatedly removes leaf nodes until only the tree's center(s) remain. This works because the center nodes minimize the maximum distance to any other node. The algorithm runs in O(n) time and handles all edge cases naturally, including trees with 1 or 2 centers.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Root)	O(n²)	O(n)	Try each node as root and calculate tree height using DFS
Topological Sort (Optimal)	O(n)	O(n)	Remove leaves iteratively until only center nodes remain

Brute Force (Try Every Root) — Algorithm Steps

Build adjacency list representation of the tree
For each node i from 0 to n-1:
- Use DFS to calculate tree height when i is the root
- Compare with current minimum height
Collect all nodes that achieve the minimum height

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Root 0

Calculate height when node 0 is root using DFS

Try Root 1

Calculate height when node 1 is root using DFS

Continue

Repeat for all nodes and track minimum height

Code -

solution.c — C

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

int dfsHeight(int node, int parent, int** adj, int* adjSizes) {
    int maxHeight = 0;
    for (int i = 0; i < adjSizes[node]; i++) {
        int neighbor = adj[node][i];
        if (neighbor != parent) {
            int height = 1 + dfsHeight(neighbor, node, adj, adjSizes);
            if (height > maxHeight) {
                maxHeight = height;
            }
        }
    }
    return maxHeight;
}

int* findMinHeightTrees(int n, int** edges, int edgesSize, int* edgesColSize, int* returnSize) {
    if (n == 1) {
        int* result = (int*)malloc(sizeof(int));
        result[0] = 0;
        *returnSize = 1;
        return result;
    }
    
    // Build adjacency list
    int** adj = (int**)malloc(n * sizeof(int*));
    int* adjSizes = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        adj[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        adj[a][adjSizes[a]++] = b;
        adj[b][adjSizes[b]++] = a;
    }
    
    int minHeight = INT_MAX;
    int* result = (int*)malloc(n * sizeof(int));
    int resultSize = 0;
    
    // Try each node as root
    for (int root = 0; root < n; root++) {
        int height = dfsHeight(root, -1, adj, adjSizes);
        if (height < minHeight) {
            minHeight = height;
            resultSize = 1;
            result[0] = root;
        } else if (height == minHeight) {
            result[resultSize++] = root;
        }
    }
    
    *returnSize = resultSize;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We try n different roots, and for each root we traverse all n nodes to find height

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 2 × 10⁴
edges.length == n - 1
0 ≤ a_i, b_i < n
a_i ≠ b_i
The given input is guaranteed to be a tree

28.7K Views

Medium Frequency

~25 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try Every Root) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler