Minimum Weighted Subgraph With the Required Paths

Minimum Weighted Subgraph With the Required Paths - Problem

Minimum Weighted Subgraph With the Required Paths

You're given a weighted directed graph with n nodes (numbered 0 to n-1) and need to find the minimum weight subgraph that allows both src1 and src2 to reach a common destination dest.

The graph is represented by an array edges where edges[i] = [from, to, weight] represents a directed edge from node from to node to with the given weight.

Goal: Find the minimum total weight of edges needed to create paths from both src1 → dest and src2 → dest. The paths can share common edges (which helps minimize the total weight).

Key Insight: The optimal subgraph will likely have paths that converge at some intermediate node before reaching the destination, allowing edge sharing to minimize total weight.

Input & Output

example_1.py — Basic convergence case

$ Input: n = 6, edges = [[0,2,2],[0,5,6],[1,2,3],[1,4,5],[2,3,1],[2,4,2],[3,5,1],[4,5,1]], src1 = 0, src2 = 1, dest = 5

› Output: 9

💡 Note: Optimal path: src1(0)→2→4→5 (cost 5) and src2(1)→2→4→5 (cost 6), sharing edge 2→4→5, total unique edges cost = 2+3+2+1 = 8. Actually, better: 0→2 (2) + 1→2 (3) + 2→3 (1) + 3→5 (1) = 7, but paths don't converge. Best is 0→2→3→5 (4) + 1→4→5 (6) = 10 total weight, or convergence at node 2: 0→2 (2) + 1→2 (3) + 2→4→5 (3) = 8.

example_2.py — No shared path optimal

$ Input: n = 3, edges = [[0,1,1],[2,1,1]], src1 = 0, src2 = 2, dest = 1

› Output: 2

💡 Note: Both sources go directly to destination: 0→1 (cost 1) + 2→1 (cost 1) = total cost 2. No benefit from trying to converge paths since they already end at the same destination.

example_3.py — Impossible case

$ Input: n = 4, edges = [[0,1,1],[1,2,1]], src1 = 0, src2 = 3, dest = 2

› Output: -1

💡 Note: src2 (node 3) has no outgoing edges, so it's impossible to reach dest (node 2) from src2. Since both sources must be able to reach the destination, return -1.

Constraints

3 ≤ n ≤ 10⁵
0 ≤ edges.length ≤ 10⁵
edges[i].length == 3
0 ≤ from_i, to_i, src1, src2, dest ≤ n - 1
from_i ≠ to_i
src1, src2, and dest are pairwise distinct
1 ≤ weight_i ≤ 10⁵

Visualization

Tap to expand

Option 1 - Independent: W1→Customer ($8) + W2→Customer ($7) = $15Option 2 - Converge: W1→DC ($5) + W2→DC ($3) + DC→Customer ($2) = $10 ✓Result: Converging at distribution center saves $5 in shipping costs!

Understanding the Visualization

Map all routes from Warehouse 1

Calculate the shortest delivery cost from warehouse 1 to every distribution center

Map all routes from Warehouse 2

Calculate the shortest delivery cost from warehouse 2 to every distribution center

Map routes to customer

Calculate the shortest delivery cost from every distribution center to the final customer

Find optimal strategy

Compare independent deliveries vs. converging at distribution centers and sharing final delivery

Key Takeaway

🎯 Key Insight: The optimal solution considers both independent paths and convergence strategies, using three shortest-path computations to efficiently evaluate all possibilities.

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22 Apple 18

The optimal solution uses three Dijkstra's algorithm runs to find the minimum weighted subgraph. Key insight: the optimal solution either uses independent paths or converges at an intermediate node to share the final path segment. By computing shortest distances from both sources and to the destination, we can efficiently check all possible convergence points in O(E log V) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Path Enumeration)	O(2^n)	O(2^n)	Enumerate all possible paths from both sources and find minimum weight combination
Three Dijkstra's Algorithm (Optimal)	O(E log V)	O(V + E)	Run Dijkstra from src1, src2, and reverse from dest to find optimal convergence point

Brute Force (All Path Enumeration) — Algorithm Steps

Use DFS to find all paths from src1 to dest
Use DFS to find all paths from src2 to dest
For each combination of paths, calculate total weight (counting shared edges once)
Return the minimum weight found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find all src1→dest paths

Use DFS to explore every possible path from src1 to dest

Find all src2→dest paths

Use DFS to explore every possible path from src2 to dest

Combine paths optimally

For each pair of paths, calculate total weight considering shared edges

Code -

solution.c — C

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

#define MAX_NODES 1000
#define MAX_EDGES 10000

typedef struct {
    int to, weight;
} Edge;

typedef struct {
    Edge edges[MAX_EDGES];
    int count;
} AdjList;

AdjList graph[MAX_NODES];
int visited[MAX_NODES];
int currentPath[MAX_NODES];
int pathLength;
long long minWeight = LLONG_MAX;

void dfs(int start, int dest, long long currentWeight, int pathSet[][MAX_NODES], long long weights[], int* pathCount, int maxPaths) {
    if (start == dest) {
        if (*pathCount < maxPaths) {
            memcpy(pathSet[*pathCount], currentPath, sizeof(int) * pathLength);
            weights[*pathCount] = currentWeight;
            (*pathCount)++;
        }
        return;
    }
    
    for (int i = 0; i < graph[start].count; i++) {
        Edge edge = graph[start].edges[i];
        if (!visited[edge.to]) {
            visited[edge.to] = 1;
            currentPath[pathLength++] = edge.to;
            
            dfs(edge.to, dest, currentWeight + edge.weight, pathSet, weights, pathCount, maxPaths);
            
            pathLength--;
            visited[edge.to] = 0;
        }
    }
}

long long minimumWeight(int n, int** edges, int edgesSize, int* edgesColSize, int src1, int src2, int dest) {
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graph[i].count = 0;
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int from = edges[i][0], to = edges[i][1], weight = edges[i][2];
        graph[from].edges[graph[from].count++] = (Edge){to, weight};
    }
    
    // Find paths from src1 to dest
    int paths1[100][MAX_NODES];
    long long weights1[100];
    int pathCount1 = 0;
    
    memset(visited, 0, sizeof(visited));
    pathLength = 1;
    currentPath[0] = src1;
    visited[src1] = 1;
    dfs(src1, dest, 0, paths1, weights1, &pathCount1, 100);
    
    // Find paths from src2 to dest
    int paths2[100][MAX_NODES];
    long long weights2[100];
    int pathCount2 = 0;
    
    memset(visited, 0, sizeof(visited));
    pathLength = 1;
    currentPath[0] = src2;
    visited[src2] = 1;
    dfs(src2, dest, 0, paths2, weights2, &pathCount2, 100);
    
    if (pathCount1 == 0 || pathCount2 == 0) {
        return -1;
    }
    
    // Find minimum weight combination (simplified)
    long long result = LLONG_MAX;
    for (int i = 0; i < pathCount1; i++) {
        for (int j = 0; j < pathCount2; j++) {
            // Simplified: just add weights (doesn't account for shared edges)
            long long totalWeight = weights1[i] + weights2[j];
            if (totalWeight < result) {
                result = totalWeight;
            }
        }
    }
    
    return result == LLONG_MAX ? -1 : result;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, need to explore exponentially many paths

⚠ Quadratic Growth

Space Complexity

O(2^n)

Need to store all possible paths

⚠ Quadratic Space

67.2K 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 (All Path Enumeration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler