Maximize the Number of Target Nodes After Connecting Trees I

Maximize the Number of Target Nodes After Connecting Trees I - Problem

Tree Connection Optimization Challenge

You're given two separate undirected trees and need to strategically connect them to maximize reachability. The first tree has n nodes labeled [0, n-1] and the second tree has m nodes labeled [0, m-1].

Key Concepts:
• A node u is target to node v if the shortest path between them has ≤ k edges
• Each node is always target to itself
• You can connect any node from tree 1 to any node from tree 2 with a single edge

Goal: For each node i in the first tree, find the maximum number of nodes that can be target to i after optimally connecting the trees.

Input:
• edges1: Array of edges for the first tree
• edges2: Array of edges for the second tree
• k: Maximum allowed distance for target relationship

Output: Array where answer[i] = maximum target nodes for node i

Input & Output

example_1.py — Basic Tree Connection

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

› Output: [3, 6, 3, 5, 5]

💡 Note: For node 0 in tree1: it can reach nodes {0,1,2} in tree1 (distance ≤ 2). With optimal bridge connection, no additional nodes from tree2 are reachable within remaining distance, so answer is 3.

example_2.py — Larger Distance Budget

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

› Output: [6, 5, 5]

💡 Note: With k=3, nodes can reach further. Node 0 can reach all nodes in tree1, and with optimal bridge, can also reach all nodes in tree2, giving total of 6 nodes.

example_3.py — Small Distance Budget

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

› Output: [2, 3, 2]

💡 Note: With k=1, each node can only reach immediate neighbors. Node 1 has the most connections and benefits most from optimal bridge placement.

Constraints

2 ≤ n, m ≤ 1000
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
1 ≤ k ≤ n + m
The input represents valid trees

Visualization

Tap to expand

Understanding the Visualization

Survey Neighborhoods

Map all distances within each neighborhood (tree)

Calculate Base Reach

For each resident, count reachable locations in home neighborhood

Test Bridge Positions

For each possible bridge, calculate additional reachable locations

Select Optimal Bridge

Choose bridge position that maximizes total accessibility

Key Takeaway

🎯 Key Insight: Pre-computing all distances allows us to efficiently test bridge positions without recalculating paths, leading to significant performance improvement over brute force approaches.

Asked in

G Google 28 f Meta 22 a Amazon 18 ⊞ Microsoft 15

The optimal approach uses precomputation of distances within each tree, then efficiently tests all possible bridge connections. Key insight: separate the problem into tree1 reachability + optimal tree2 connection to avoid redundant calculations and achieve O(n² + m² + nm) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Possible Connections)	O(n * n * m * (n + m))	O(n + m)	Try every possible connection between trees for each query node
Optimized with Precomputation	O(n² + m² + nm)	O(n² + m²)	Pre-calculate distances within trees, then optimize bridge selection

Brute Force (All Possible Connections) — Algorithm Steps

For each node i in tree1:
Try every possible connection (u from tree1, v from tree2)
Create temporary combined graph with the connection
Run BFS from node i to count nodes within distance k
Keep track of maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Trees

Start with two separate trees

Try Connection

Connect node u from tree1 to node v from tree2

Count Reachable

Run BFS from query node to count nodes within distance k

Track Maximum

Keep the best result found so far

Code -

solution.c — C

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

#define MAX_NODES 1000

typedef struct {
    int nodes[MAX_NODES];
    int count;
} AdjList;

int bfsCount(AdjList graph[], int start, int maxDist, int totalNodes) {
    if (maxDist < 0) return 0;
    
    int queue[MAX_NODES * 2][2];
    int visited[MAX_NODES] = {0};
    int front = 0, rear = 0;
    int count = 0;
    
    queue[rear][0] = start;
    queue[rear][1] = 0;
    rear++;
    visited[start] = 1;
    
    while (front < rear) {
        int node = queue[front][0];
        int dist = queue[front][1];
        front++;
        count++;
        
        if (dist < maxDist) {
            for (int i = 0; i < graph[node].count; i++) {
                int neighbor = graph[node].nodes[i];
                if (!visited[neighbor]) {
                    visited[neighbor] = 1;
                    queue[rear][0] = neighbor;
                    queue[rear][1] = dist + 1;
                    rear++;
                }
            }
        }
    }
    return count;
}

int* maxTargetNodes(int** edges1, int edges1Size, int* edges1ColSize,
                    int** edges2, int edges2Size, int* edges2ColSize,
                    int k, int* returnSize) {
    int n = edges1Size + 1;
    int m = edges2Size + 1;
    *returnSize = n;
    
    int* result = (int*)malloc(n * sizeof(int));
    
    // Build graphs
    AdjList graph1[MAX_NODES] = {0};
    AdjList graph2[MAX_NODES] = {0};
    
    for (int i = 0; i < edges1Size; i++) {
        int u = edges1[i][0], v = edges1[i][1];
        graph1[u].nodes[graph1[u].count++] = v;
        graph1[v].nodes[graph1[v].count++] = u;
    }
    
    for (int i = 0; i < edges2Size; i++) {
        int u = edges2[i][0], v = edges2[i][1];
        graph2[u].nodes[graph2[u].count++] = v;
        graph2[v].nodes[graph2[v].count++] = u;
    }
    
    for (int i = 0; i < n; i++) {
        int maxTargets = 0;
        
        for (int u = 0; u < n; u++) {
            for (int v = 0; v < m; v++) {
                AdjList combined[MAX_NODES];
                memcpy(combined, graph1, sizeof(graph1));
                
                // Copy graph2 with offset
                for (int j = 0; j < m; j++) {
                    combined[n + j].count = 0;
                    for (int l = 0; l < graph2[j].count; l++) {
                        combined[n + j].nodes[combined[n + j].count++] = n + graph2[j].nodes[l];
                    }
                }
                
                // Add bridge
                combined[u].nodes[combined[u].count++] = n + v;
                combined[n + v].nodes[combined[n + v].count++] = u;
                
                int targets = bfsCount(combined, i, k, n + m);
                if (targets > maxTargets) {
                    maxTargets = targets;
                }
            }
        }
        result[i] = maxTargets;
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

For each of n nodes, try n*m connections, each requiring BFS over n+m nodes

✓ Linear Growth

Space Complexity

O(n + m)

Space for building temporary graphs and BFS queue

⚡ Linearithmic Space

34.7K Views

Medium Frequency

~25 min Avg. Time

1.2K 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 (All Possible Connections) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler