Minimum Weighted Subgraph With the Required Paths II

Minimum Weighted Subgraph With the Required Paths II - Problem

You are given an undirected weighted tree with n nodes, numbered from 0 to n - 1. It is represented by a 2D integer array edges of length n - 1, where edges[i] = [u_i, v_i, w_i] indicates that there is an edge between nodes u_i and v_i with weight w_i.

Additionally, you are given a 2D integer array queries, where queries[j] = [src1_j, src2_j, dest_j].

Return an array answer of length equal to queries.length, where answer[j] is the minimum total weight of a subtree such that it is possible to reach dest_j from both src1_j and src2_j using edges in this subtree.

A subtree here is any connected subset of nodes and edges of the original tree forming a valid tree.

Input & Output

Example 1 — Basic Tree Query

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

› Output: [4]

💡 Note: To connect nodes 0 and 3 to destination 2, we need the path 0→1→2 (weight 2) and path 3→2 (weight 2). Total minimum weight is 4.

Example 2 — Multiple Queries

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

› Output: [6,5]

💡 Note: Query 1: Connect 0,2 to 3 via node 1, weight = 1+2+3 = 6. Query 2: Connect 2,3 to 1, weight = 2+3 = 5.

Example 3 — Same Source and Destination

$ Input: edges = [[0,1,1],[1,2,1]], queries = [[0,0,1]]

› Output: [1]

💡 Note: Both sources are node 0, destination is 1. Only need path 0→1 with weight 1.

Constraints

1 ≤ n ≤ 10⁴
edges.length == n - 1
0 ≤ u_i, v_i ≤ n - 1
1 ≤ w_i ≤ 10⁶
1 ≤ queries.length ≤ 10⁴
0 ≤ src1_j, src2_j, dest_j ≤ n - 1

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The optimal approach uses DFS to build the tree structure and finds the Lowest Common Ancestor (LCA) of the three query nodes. The minimal subtree consists of paths from the LCA to each node. Time: O(n + q × n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Subtrees

⏱️ Time: O(2^n × n²) Space: O(n)

For each query, generate all possible subtrees and find the minimum weight subtree that connects both sources to the destination. This involves checking 2^n possible subsets.

DFS with LCA (Lowest Common Ancestor)

⏱️ Time: O(n + q × n) Space: O(n)

Build the tree using DFS, then for each query find the Lowest Common Ancestor of the three nodes (src1, src2, dest). The minimal subtree is the union of paths from LCA to each node.

Brute Force - Try All Subtrees — Algorithm Steps

Generate all possible edge subsets
For each subset, check if it forms a valid tree
Verify if both sources can reach destination
Track minimum weight among valid subtrees

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^(n-1) possible edge combinations

Check Connectivity

For each subset, verify both sources reach destination

Track Minimum

Keep the lowest weight among valid subtrees

Code -

solution.c — C

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

typedef struct {
    int* neighbors;
    int count;
    int capacity;
} AdjList;

int canReach(AdjList* graph, int n, int start, int end) {
    if (start == end) return 1;
    
    int* visited = calloc(n, sizeof(int));
    int queue[1000];
    int front = 0, rear = 0;
    
    queue[rear++] = start;
    visited[start] = 1;
    
    while (front < rear) {
        int node = queue[front++];
        if (node == end) {
            free(visited);
            return 1;
        }
        
        for (int i = 0; i < graph[node].count; i++) {
            int neighbor = graph[node].neighbors[i];
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                queue[rear++] = neighbor;
            }
        }
    }
    
    free(visited);
    return 0;
}

int* solution(int edges[][3], int edgesSize, int queries[][3], int queriesSize, int* returnSize) {
    int n = edgesSize + 1;
    int* results = malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int q = 0; q < queriesSize; q++) {
        int src1 = queries[q][0], src2 = queries[q][1], dest = queries[q][2];
        int minWeight = INT_MAX;
        
        // Try all possible subsets (simplified version)
        for (int mask = 1; mask < (1 << edgesSize) && mask < 256; mask++) {
            AdjList graph[100] = {0}; // Initialize graph
            int totalWeight = 0;
            
            // Build subset and graph
            for (int i = 0; i < edgesSize; i++) {
                if (mask & (1 << i)) {
                    totalWeight += edges[i][2];
                    int u = edges[i][0], v = edges[i][1];
                    
                    // Add edge u -> v
                    if (graph[u].count >= graph[u].capacity) {
                        graph[u].capacity = graph[u].capacity == 0 ? 4 : graph[u].capacity * 2;
                        graph[u].neighbors = realloc(graph[u].neighbors, graph[u].capacity * sizeof(int));
                    }
                    graph[u].neighbors[graph[u].count++] = v;
                    
                    // Add edge v -> u
                    if (graph[v].count >= graph[v].capacity) {
                        graph[v].capacity = graph[v].capacity == 0 ? 4 : graph[v].capacity * 2;
                        graph[v].neighbors = realloc(graph[v].neighbors, graph[v].capacity * sizeof(int));
                    }
                    graph[v].neighbors[graph[v].count++] = u;
                }
            }
            
            // Check connectivity
            if (canReach(graph, n, src1, dest) && canReach(graph, n, src2, dest)) {
                if (totalWeight < minWeight) {
                    minWeight = totalWeight;
                }
            }
            
            // Clean up
            for (int i = 0; i < n; i++) {
                if (graph[i].neighbors) {
                    free(graph[i].neighbors);
                }
            }
        }
        
        results[q] = (minWeight == INT_MAX) ? -1 : minWeight;
    }
    
    return results;
}

int main() {
    // Simple example
    int edges[][3] = {{0,1,1},{1,2,1},{2,3,2}};
    int queries[][3] = {{0,3,2}};
    int returnSize;
    
    int* result = solution(edges, 3, queries, 1, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n²)

2^n subsets, each requiring O(n²) to check connectivity

✓ Linear Growth

Space Complexity

O(n)

Space for storing current subset and connectivity check

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

450 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 Subtrees — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler