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: 7

💡 Note: Optimal solution: paths converge at node 2. Path 0→2 (cost 2) + path 1→2 (cost 3) + shared path 2→3→5 (cost 2). Total unique edges: 0→2 (2) + 1→2 (3) + 2→3 (1) + 3→5 (1) = 7.

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

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

✓ Brute Force (All Path Enumeration)

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

Generate all possible paths from src1 to dest and src2 to dest, then find the combination with minimum total weight considering shared edges.

Three Dijkstra's Algorithm (Optimal)

⏱️ Time: O(E log V) Space: O(V + E)

The key insight is that the optimal solution has three patterns: 1) Independent paths, 2) Paths converge at some node then share path to dest, 3) One path is subset of another. We can solve this efficiently using three shortest-path computations.

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;
    long long weight;
} Edge;

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

typedef struct {
    long long dist;
    int node;
} HeapNode;

static HeapNode heap_nodes[MAX_NODES * MAX_NODES];
static int heap_size;

void heapPush(long long dist, int node) {
    int i = heap_size++;
    heap_nodes[i].dist = dist;
    heap_nodes[i].node = node;
    
    while (i > 0 && heap_nodes[i].dist < heap_nodes[(i-1)/2].dist) {
        HeapNode temp = heap_nodes[i];
        heap_nodes[i] = heap_nodes[(i-1)/2];
        heap_nodes[(i-1)/2] = temp;
        i = (i-1)/2;
    }
}

HeapNode heapPop() {
    HeapNode result = heap_nodes[0];
    heap_nodes[0] = heap_nodes[--heap_size];
    
    int i = 0;
    while (1) {
        int left = 2*i + 1;
        int right = 2*i + 2;
        int smallest = i;
        
        if (left < heap_size && heap_nodes[left].dist < heap_nodes[smallest].dist)
            smallest = left;
        if (right < heap_size && heap_nodes[right].dist < heap_nodes[smallest].dist)
            smallest = right;
            
        if (smallest == i) break;
        
        HeapNode temp = heap_nodes[i];
        heap_nodes[i] = heap_nodes[smallest];
        heap_nodes[smallest] = temp;
        i = smallest;
    }
    
    return result;
}

static long long dijkstra_dist[MAX_NODES];

void dijkstra(int start, AdjList* adj_list, long long* dist, int n) {
    for (int i = 0; i < n; i++) {
        dist[i] = LLONG_MAX;
    }
    dist[start] = 0;
    
    heap_size = 0;
    heapPush(0, start);
    
    while (heap_size > 0) {
        HeapNode current = heapPop();
        long long d = current.dist;
        int u = current.node;
        
        if (d > dist[u]) continue;
        
        for (int i = 0; i < adj_list[u].count; i++) {
            int v = adj_list[u].edges[i].to;
            long long w = adj_list[u].edges[i].weight;
            
            if (dist[u] + w < dist[v]) {
                dist[v] = dist[u] + w;
                heapPush(dist[v], v);
            }
        }
    }
}

void parseArray(const char* str, int edges[][3], int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        if (*p == '[') {
            p++;
            int edge[3];
            for (int i = 0; i < 3; i++) {
                while (*p == ' ' || *p == ',') p++;
                edge[i] = (int)strtol(p, (char**)&p, 10);
            }
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            
            edges[*size][0] = edge[0];
            edges[*size][1] = edge[1];
            edges[*size][2] = edge[2];
            (*size)++;
        } else {
            while (*p && *p != '[' && *p != ']') p++;
        }
    }
}

static AdjList graph[MAX_NODES];
static AdjList reverse_graph[MAX_NODES];
static long long dist_from_src1[MAX_NODES];
static long long dist_from_src2[MAX_NODES];
static long long dist_to_dest[MAX_NODES];

long long solve() {
    int n;
    scanf("%d", &n);
    getchar();
    
    char edges_str[100000];
    fgets(edges_str, sizeof(edges_str), stdin);
    edges_str[strcspn(edges_str, "\n")] = 0;
    
    int src1, src2, dest;
    scanf("%d", &src1);
    scanf("%d", &src2);
    scanf("%d", &dest);
    
    // Parse edges
    int edges[MAX_EDGES][3];
    int edgesSize;
    parseArray(edges_str, edges, &edgesSize);
    
    // Initialize graphs
    for (int i = 0; i < n; i++) {
        graph[i].count = 0;
        reverse_graph[i].count = 0;
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0];
        int v = edges[i][1];
        long long w = edges[i][2];
        
        graph[u].edges[graph[u].count++] = (Edge){v, w};
        reverse_graph[v].edges[reverse_graph[v].count++] = (Edge){u, w};
    }
    
    dijkstra(src1, graph, dist_from_src1, n);
    dijkstra(src2, graph, dist_from_src2, n);
    dijkstra(dest, reverse_graph, dist_to_dest, n);
    
    // Check if both sources can reach dest
    if (dist_from_src1[dest] == LLONG_MAX || dist_from_src2[dest] == LLONG_MAX) {
        return -1;
    }
    
    long long min_weight = LLONG_MAX;
    
    // Try all possible intermediate nodes (including dest itself)
    for (int intermediate = 0; intermediate < n; intermediate++) {
        if (dist_from_src1[intermediate] != LLONG_MAX && 
            dist_from_src2[intermediate] != LLONG_MAX && 
            dist_to_dest[intermediate] != LLONG_MAX) {
            
            long long total_weight = dist_from_src1[intermediate] + 
                                   dist_from_src2[intermediate] + 
                                   dist_to_dest[intermediate];
            if (total_weight < min_weight) {
                min_weight = total_weight;
            }
        }
    }
    
    return min_weight != LLONG_MAX ? min_weight : -1;
}

int main() {
    printf("%lld\n", solve());
    return 0;
}

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