Find Minimum Diameter After Merging Two Trees

Find Minimum Diameter After Merging Two Trees - Problem

There exist two undirected trees with n and m nodes, numbered from 0 to n - 1 and from 0 to m - 1, respectively.

You are given two 2D integer arrays edges1 and edges2 of lengths n - 1 and m - 1, respectively, where edges1[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the first tree and edges2[i] = [ui, vi] indicates that there is an edge between nodes ui and vi in the second tree.

You must connect one node from the first tree with another node from the second tree with an edge.

Return the minimum possible diameter of the resulting tree. The diameter of a tree is the length of the longest path between any two nodes in the tree.

Input & Output

Example 1 — 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. Connecting centers gives diameter 3.

Example 2 — Linear Trees

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

› Output: 4

💡 Note: Both trees are somewhat linear. The optimal connection results in diameter 4.

Example 3 — Single Nodes

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

› Output: 1

💡 Note: Two single nodes connected by one edge results in diameter 1.

Constraints

1 ≤ n, m ≤ 10⁵
edges1.length == n - 1
edges2.length == m - 1
0 ≤ a_i, b_i < n
0 ≤ u_i, v_i < m
The input is guaranteed to be two trees

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8 f Meta 6

The key insight is to find the centers of both trees and connect them optimally. Instead of trying all possible connections, we calculate the diameter of each tree separately and determine the minimum possible diameter by connecting their centers. The optimal approach runs in O(n+m) time and O(n+m) space.

Common Approaches

✓ Brute Force - Try All Connections

⏱️ Time: O(n*m*(n+m)²) Space: O(n+m)

For each possible connection between nodes from the two trees, merge the trees and calculate the diameter using BFS. Return the minimum diameter found.

Optimal - Connect Tree Centers

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

Calculate diameter and center of each tree separately. The optimal connection is between the centers, and the resulting diameter is the maximum of both individual diameters and the path through the connection.

Brute Force - Try All Connections — Algorithm Steps

Step 1: For each node in tree1
Step 2: For each node in tree2, connect them
Step 3: Calculate diameter of merged tree using BFS
Step 4: Track minimum diameter

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Trees

Two separate trees with their edges

Try Connection

Connect node i from tree1 to node j from tree2

Calculate Diameter

Use BFS to find diameter of merged tree

Track Minimum

Keep the smallest diameter found

Code -

solution.c — C

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

#define MAX_NODES 2000

static int adj[MAX_NODES][MAX_NODES];
static int adjCount[MAX_NODES];
static int visited[MAX_NODES];
static int queue[MAX_NODES];
static int dist[MAX_NODES];

int bfs(int start, int n, int* farthest) {
    memset(visited, 0, sizeof(visited));
    memset(dist, 0, sizeof(dist));
    
    int front = 0, rear = 0;
    queue[rear++] = start;
    visited[start] = 1;
    dist[start] = 0;
    
    int maxDist = 0;
    *farthest = start;
    
    while (front < rear) {
        int curr = queue[front++];
        
        if (dist[curr] > maxDist) {
            maxDist = dist[curr];
            *farthest = curr;
        }
        
        for (int i = 0; i < adjCount[curr]; i++) {
            int neighbor = adj[curr][i];
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                dist[neighbor] = dist[curr] + 1;
                queue[rear++] = neighbor;
            }
        }
    }
    
    return maxDist;
}

int calculateDiameter(int n) {
    if (n <= 1) return 0;
    
    // First BFS from node 0 to find one end of diameter
    int end1;
    bfs(0, n, &end1);
    
    // Second BFS from that end to find actual diameter
    int end2;
    int diameter = bfs(end1, n, &end2);
    
    return diameter;
}

int parseEdges(char* line, int edges[][2]) {
    if (strstr(line, "[]") != NULL) {
        return 0;
    }
    
    int count = 0;
    char* ptr = line;
    
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != ']' && *(ptr+1) != '[') {
            ptr++; // skip '['
            
            // Parse first number
            int u = 0;
            while (*ptr >= '0' && *ptr <= '9') {
                u = u * 10 + (*ptr - '0');
                ptr++;
            }
            
            // Skip comma and spaces
            while (*ptr && (*ptr == ',' || *ptr == ' ')) {
                ptr++;
            }
            
            // Parse second number
            int v = 0;
            while (*ptr >= '0' && *ptr <= '9') {
                v = v * 10 + (*ptr - '0');
                ptr++;
            }
            
            edges[count][0] = u;
            edges[count][1] = v;
            count++;
        }
        ptr++;
    }
    
    return count;
}

int solution(int edges1[][2], int n1_edges, int edges2[][2], int n2_edges) {
    int n1 = (n1_edges == 0) ? 1 : n1_edges + 1;
    int n2 = (n2_edges == 0) ? 1 : n2_edges + 1;
    
    int minDiameter = INT_MAX;
    
    // Try all possible connections between trees
    for (int i = 0; i < n1; i++) {
        for (int j = 0; j < n2; j++) {
            // Clear adjacency list
            memset(adjCount, 0, sizeof(adjCount));
            
            // Add tree1 edges
            for (int k = 0; k < n1_edges; k++) {
                int u = edges1[k][0], v = edges1[k][1];
                adj[u][adjCount[u]++] = v;
                adj[v][adjCount[v]++] = u;
            }
            
            // Add tree2 edges (offset by n1)
            for (int k = 0; k < n2_edges; k++) {
                int u = edges2[k][0] + n1, v = edges2[k][1] + n1;
                adj[u][adjCount[u]++] = v;
                adj[v][adjCount[v]++] = u;
            }
            
            // Add connection between trees
            adj[i][adjCount[i]++] = j + n1;
            adj[j + n1][adjCount[j + n1]++] = i;
            
            // Calculate diameter of merged tree
            int diameter = calculateDiameter(n1 + n2);
            if (diameter < minDiameter) {
                minDiameter = diameter;
            }
        }
    }
    
    return minDiameter;
}

int main() {
    static char line1[10000], line2[10000];
    
    if (!fgets(line1, sizeof(line1), stdin) || !fgets(line2, sizeof(line2), stdin)) {
        return 1;
    }
    
    static int edges1[1000][2], edges2[1000][2];
    int n1_edges = parseEdges(line1, edges1);
    int n2_edges = parseEdges(line2, edges2);
    
    printf("%d\n", solution(edges1, n1_edges, edges2, n2_edges));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m*(n+m)²)

Try n*m connections, each requiring O((n+m)²) diameter calculation

✓ Linear Growth

Space Complexity

O(n+m)

Space for adjacency list and BFS queue

⚡ Linearithmic Space

8.8K Views

Medium Frequency

~35 min Avg. Time

234 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