Find Minimum Diameter After Merging Two Trees

Find Minimum Diameter After Merging Two Trees - Problem

Imagine you have two separate trees - like two different family trees or organizational charts - and you need to connect them with a single bridge to create one unified tree structure.

Given two undirected trees with n and m nodes respectively:

Tree 1: nodes numbered 0 to n-1, connected by edges in edges1
Tree 2: nodes numbered 0 to m-1, connected by edges in edges2

You must connect exactly one node from tree 1 to one node from tree 2 with a new edge. Your goal is to minimize the diameter of the resulting merged tree.

The diameter is the length of the longest path between any two nodes in the tree - think of it as the "worst-case distance" you'd have to travel to get from one end of the tree to the other.

Return: The minimum possible diameter after optimally connecting the two trees.

Input & Output

example_1.py — Basic Case

$ Input: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]

› Output: 3

💡 Note: Tree1 has diameter 2 (from node 1 to 3 via 0). Tree2 has diameter 1. Optimal connection gives diameter max(2, 1, ceil(2/2) + ceil(1/2) + 1) = max(2, 1, 3) = 3.

example_2.py — Equal Trees

$ Input: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[3,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[3,7]]

› Output: 5

💡 Note: Both trees have the same structure with diameter 4. The optimal diameter is max(4, 4, ceil(4/2) + ceil(4/2) + 1) = max(4, 4, 5) = 5.

example_3.py — Single Nodes

$ Input: edges1 = [], edges2 = []

› Output: 1

💡 Note: Both trees have single nodes (diameter 0). After connecting them: max(0, 0, ceil(0/2) + ceil(0/2) + 1) = max(0, 0, 1) = 1.

Constraints

1 ≤ n, m ≤ 10⁵
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
0 ≤ a_i, b_i < n
0 ≤ u_i, v_i < m
Both input graphs are trees (connected and acyclic)

Visualization

Tap to expand

Understanding the Visualization

Measure Each Island

Find the diameter (longest road) in each island's road network

Locate Centers

Identify the central locations that minimize travel distances

Three Journey Types

Consider journeys within island1, within island2, or across the bridge

Bridge Journey Length

Cross-bridge journey = radius1 + bridge(1) + radius2

Choose Worst Case

The longest of these three journey types is your answer

Key Takeaway

🎯 Key Insight: The optimal diameter is determined by the worst-case journey among three types: staying within each original tree, or crossing the bridge. Connecting the centers of both trees minimizes the cross-bridge journey length.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses a mathematical insight: the minimum diameter when connecting two trees is max(d₁, d₂, ⌈d₁/2⌉ + ⌈d₂/2⌉ + 1), where d₁ and d₂ are the original diameters. This formula accounts for three scenarios: keeping the original diameter of tree1, tree2, or creating a new longest path through the connecting bridge. The solution runs in O(n+m) time by calculating each tree's diameter using two BFS passes, avoiding the brute force O(nm(n+m)) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Connections)	O(nm(n+m))	O(n+m)	Try connecting every node from tree1 to every node from tree2 and calculate diameter each time
Optimal Tree Centers (Mathematical)	O(n+m)	O(n+m)	Find diameter of each tree, then connect their centers using the optimal diameter formula

Brute Force (Try All Connections) — Algorithm Steps

For each node i in tree1 and each node j in tree2:
Create merged tree by adding edge (i,j)
Calculate diameter of merged tree using two BFS passes
Track minimum diameter found
Return the minimum diameter across all connections

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Connection Points

Choose one node from tree 1 and one from tree 2

Build Merged Tree

Create new graph with both trees connected by chosen edge

Calculate Diameter

Use two BFS passes to find longest path in merged tree

Track Minimum

Keep track of the smallest diameter found so far

Repeat

Try all n×m possible connections

Code -

solution.c — C

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

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

IntList* createList() {
    IntList* list = malloc(sizeof(IntList));
    list->capacity = 4;
    list->data = malloc(list->capacity * sizeof(int));
    list->size = 0;
    return list;
}

void addToList(IntList* list, int val) {
    if (list->size == list->capacity) {
        list->capacity *= 2;
        list->data = realloc(list->data, list->capacity * sizeof(int));
    }
    list->data[list->size++] = val;
}

IntList** buildGraph(int** edges, int edgesSize, int n) {
    IntList** graph = malloc(n * sizeof(IntList*));
    for (int i = 0; i < n; i++) {
        graph[i] = createList();
    }
    
    for (int i = 0; i < edgesSize; i++) {
        addToList(graph[edges[i][0]], edges[i][1]);
        addToList(graph[edges[i][1]], edges[i][0]);
    }
    
    return graph;
}

typedef struct {
    int node;
    int dist;
} QueueItem;

int* bfsFarthest(IntList** graph, int start, int n) {
    int* visited = calloc(n, sizeof(int));
    QueueItem* queue = malloc(n * sizeof(QueueItem));
    int front = 0, rear = 0;
    
    queue[rear++] = (QueueItem){start, 0};
    visited[start] = 1;
    
    int farthestNode = start, maxDist = 0;
    
    while (front < rear) {
        QueueItem current = queue[front++];
        
        if (current.dist > maxDist) {
            maxDist = current.dist;
            farthestNode = current.node;
        }
        
        for (int i = 0; i < graph[current.node]->size; i++) {
            int neighbor = graph[current.node]->data[i];
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                queue[rear++] = (QueueItem){neighbor, current.dist + 1};
            }
        }
    }
    
    free(visited);
    free(queue);
    
    int* result = malloc(2 * sizeof(int));
    result[0] = farthestNode;
    result[1] = maxDist;
    return result;
}

int getDiameter(IntList** graph, int n) {
    if (n == 1) return 0;
    
    int* result1 = bfsFarthest(graph, 0, n);
    int* result2 = bfsFarthest(graph, result1[0], n);
    
    int diameter = result2[1];
    free(result1);
    free(result2);
    
    return diameter;
}

int minimumDiameterAfterMerge(int** edges1, int edges1Size, int* edges1ColSize, 
                             int** edges2, int edges2Size, int* edges2ColSize) {
    int n1 = edges1Size + 1, n2 = edges2Size + 1;
    IntList** graph1 = buildGraph(edges1, edges1Size, n1);
    IntList** graph2 = buildGraph(edges2, edges2Size, n2);
    
    int minDiameter = INT_MAX;
    
    for (int i = 0; i < n1; i++) {
        for (int j = 0; j < n2; j++) {
            IntList** merged = malloc((n1 + n2) * sizeof(IntList*));
            for (int k = 0; k < n1 + n2; k++) {
                merged[k] = createList();
            }
            
            // Add tree1 edges
            for (int node = 0; node < n1; node++) {
                for (int idx = 0; idx < graph1[node]->size; idx++) {
                    addToList(merged[node], graph1[node]->data[idx]);
                }
            }
            
            // Add tree2 edges
            for (int node = 0; node < n2; node++) {
                for (int idx = 0; idx < graph2[node]->size; idx++) {
                    addToList(merged[node + n1], graph2[node]->data[idx] + n1);
                }
            }
            
            // Add connection edge
            addToList(merged[i], j + n1);
            addToList(merged[j + n1], i);
            
            int diameter = getDiameter(merged, n1 + n2);
            if (diameter < minDiameter) {
                minDiameter = diameter;
            }
            
            // Free merged graph
            for (int k = 0; k < n1 + n2; k++) {
                free(merged[k]->data);
                free(merged[k]);
            }
            free(merged);
        }
    }
    
    return minDiameter;
}

Time & Space Complexity

Time Complexity

⏱️

O(nm(n+m))

O(nm) connections to try, each requiring O(n+m) diameter calculation

✓ Linear Growth

Space Complexity

O(n+m)

Space to build adjacency list and BFS queue

⚡ Linearithmic Space

43.6K Views

Medium-High 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 (Try All Connections) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler