Maximize the Number of Target Nodes After Connecting Trees II

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

🌳 Maximize Target Nodes After Tree Connection

Imagine you have two separate tree networks that you can temporarily connect with a single bridge! Your mission is to find the optimal connection strategy to maximize reachable nodes.

Given two undirected trees:

Tree 1: n nodes labeled [0, n-1] with edges defined by edges1
Tree 2: m nodes labeled [0, m-1] with edges defined by edges2

Key Concept: Node u is target to node v if the path between them has an even number of edges (including 0 - every node targets itself).

Your Goal: For each node i in Tree 1, determine the maximum number of nodes that can be target to i after optimally connecting one node from Tree 1 to any node in Tree 2.

Important: Each query is independent - you remove the bridge before testing the next node.

Input & Output

example_1.py — Basic Tree Connection

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

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

💡 Note: Tree1 has 4 nodes, Tree2 has 2 nodes. For node 0 in tree1, optimal connection gives access to all 6 nodes with even-path distance. Other nodes have fewer optimal connections due to their position in the tree structure.

example_2.py — Single Node Trees

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

› Output: [2]

💡 Note: Each tree has only one node. When connected, node 0 in tree1 can reach itself (distance 0) and the single node in tree2 (distance 1 via bridge, but we need even distances). So it reaches 1 + 1 = 2 nodes total.

example_3.py — Larger Trees

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

› Output: [4, 3, 4]

💡 Note: Both trees are paths of length 3. Using bipartite coloring, we can optimally connect to maximize even-distance reachability. Different starting nodes in tree1 have different optimal target counts based on their color.

Visualization

Tap to expand

Understanding the Visualization

Problem Understanding

Two trees need optimal bridge connection for maximum even-path reachability

Brute Force Reality

Testing all n×m bridge combinations is prohibitively expensive

Bipartite Insight

Trees are bipartite! Nodes can be colored by distance parity

Optimal Strategy

Connect same colors to maximize even-distance paths

Key Takeaway

🎯 Key Insight: The bipartite property of trees allows us to solve this optimization problem in linear time by simply coloring nodes based on distance parity and connecting same-colored nodes optimally.

Time & Space Complexity

Time Complexity

⏱️

O(n² × m × (n + m))

For each of n queries, try n×m bridge combinations, each requiring O(n+m) BFS

⚠ Quadratic Growth

Space Complexity

O(n + m)

Space for adjacency lists and BFS queue

⚡ Linearithmic Space

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
The input represents valid trees

Asked in

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

The optimal solution leverages the bipartite property of trees. Color nodes based on distance parity from root (even=blue, odd=red), then connect same-colored nodes to maximize even-path reachability. This reduces complexity from O(n²m(n+m)) brute force to O(n+m) optimal solution.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Connections)	O(n² × m × (n + m))	O(n + m)	Test every possible bridge connection and calculate target nodes for each query
Optimized Approach (Bipartite Coloring)	O(n + m)	O(n + m)	Use tree bipartite property - color nodes and connect same colors optimally

Brute Force (Try All Connections) — Algorithm Steps

For each query node i in tree1
Try all possible bridge connections (u in tree1, v in tree2)
For each bridge, run BFS to count nodes reachable from i with even distance
Return the maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Trees

Two separate tree networks

Try Bridge 1

Connect nodes and count even-path reachability

Try Bridge 2

Test different connection point

Find Maximum

Select best bridge configuration

Code -

solution.c — C

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

#define MAX_NODES 1000

typedef struct {
    int adj[MAX_NODES][MAX_NODES];
    int degree[MAX_NODES];
} Graph;

Graph buildGraph(int** edges, int edgesSize, int numNodes) {
    Graph g;
    memset(&g, 0, sizeof(Graph));
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        g.adj[u][g.degree[u]++] = v;
        g.adj[v][g.degree[v]++] = u;
    }
    return g;
}

int countEvenDistanceNodes(Graph* g, int start, int numNodes) {
    int queue[MAX_NODES * 2];
    int dist[MAX_NODES];
    int visited[MAX_NODES] = {0};
    int front = 0, rear = 0;
    
    queue[rear++] = start;
    visited[start] = 1;
    dist[start] = 0;
    int evenCount = 1;
    
    while (front < rear) {
        int node = queue[front++];
        
        for (int i = 0; i < g->degree[node]; i++) {
            int neighbor = g->adj[node][i];
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                dist[neighbor] = dist[node] + 1;
                if (dist[neighbor] % 2 == 0) {
                    evenCount++;
                }
                queue[rear++] = neighbor;
            }
        }
    }
    return evenCount;
}

int* maxTargetNodes(int** edges1, int edges1Size, int* edges1ColSize, 
                   int** edges2, int edges2Size, int* edges2ColSize, 
                   int* returnSize) {
    int n = edges1Size + 1;
    int m = edges2Size + 1;
    *returnSize = n;
    
    Graph graph1 = buildGraph(edges1, edges1Size, n);
    Graph graph2 = buildGraph(edges2, edges2Size, m);
    
    int* result = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        int maxTargets = countEvenDistanceNodes(&graph1, i, n);
        
        for (int u = 0; u < n; u++) {
            for (int v = 0; v < m; v++) {
                Graph combined = graph1;
                
                // Add edges from graph2
                for (int node = 0; node < m; node++) {
                    for (int j = 0; j < graph2.degree[node]; j++) {
                        int neighbor = graph2.adj[node][j];
                        if (node < neighbor) { // Avoid duplicates
                            combined.adj[node][combined.degree[node]++] = neighbor;
                            combined.adj[neighbor][combined.degree[neighbor]++] = node;
                        }
                    }
                }
                
                // Add bridge
                combined.adj[u][combined.degree[u]++] = v;
                combined.adj[v][combined.degree[v]++] = u;
                
                int targets = countEvenDistanceNodes(&combined, i, n + m);
                if (targets > maxTargets) {
                    maxTargets = targets;
                }
            }
        }
        result[i] = maxTargets;
    }
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m × (n + m))

For each of n queries, try n×m bridge combinations, each requiring O(n+m) BFS

⚠ Quadratic Growth

Space Complexity

O(n + m)

Space for adjacency lists and BFS queue

⚡ Linearithmic Space

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
The input represents valid trees

7.9K Views

Medium Frequency

~35 min Avg. Time

245 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

🌳 Maximize Target Nodes After Tree Connection

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Connections) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler