Network Cable Cost

Network Cable Cost - Problem

Graph MST Kruskal Prim Union Find Medium

A company has n offices numbered 0 to n - 1. You can install network cables between offices.

You are given a 2D array cables where cables[i] = [u, v, cost] represents a cable option connecting office u to office v with installation cost cost.

Return the minimum total cost to connect all offices, or -1 if it's impossible.

Input & Output

Example 1

$ Input: n=4, cables=[[0,1,10],[0,2,6],[0,3,5],[1,3,15],[2,3,4]]

› Output: 19

💡 Note: Pick cables (2,3,4)+(0,3,5)+(0,1,10)=19.

Example 2

$ Input: n=3, cables=[[0,1,1],[1,2,2],[0,2,3]]

› Output: 3

💡 Note: Pick (0,1,1)+(1,2,2)=3.

Example 3

$ Input: n=4, cables=[[0,1,1],[2,3,2]]

› Output: -1

💡 Note: Cannot connect all offices.

Constraints

1 ≤ n ≤ 2×10^5
0 ≤ cables.length ≤ 2×10^5
0 ≤ u, v < n
1 ≤ cost ≤ 10^6

Visualization

Tap to expand

Asked in

a Amazon 0 G Google 0

Both Kruskal's and Prim's find the MST. Kruskal's sorts edges and uses Union-Find. Prim's grows from a node using a priority queue.

Common Approaches

✓ Kruskal's Algorithm

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

Sort cables by cost. Use Union-Find to add cheapest non-cycle edge until n-1 edges used.

Prim's Algorithm

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

Start from node 0. Use priority queue to always pick the cheapest edge to an unvisited node.

Kruskal's Algorithm — Algorithm Steps

Sort cables by cost
Init Union-Find
Add cheapest edge if no cycle
Stop at n-1 edges

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort

By weight: 4,5,6,10,15

Add

(2,3,4)→(0,3,5)→(0,1,10)

Done

3 edges, total=19

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXN 200001
#define MAXE 200001
int parent[MAXN], rnk[MAXN];
int find(int x) {
    while (parent[x] != x) {
        parent[x] = parent[parent[x]];
        x = parent[x];
    }
    return x;
}
int unite(int a, int b) {
    int ra = find(a), rb = find(b);
    if (ra == rb)
        return 0;
    if (rnk[ra] < rnk[rb]) {
        int t = ra;
        ra = rb;
        rb = t;
    }
    parent[rb] = ra;
    if (rnk[ra] == rnk[rb])
        rnk[ra]++;
    return 1;
}
int eu[MAXE], ev[MAXE], ew[MAXE], eidx[MAXE];
int cmp(const void *a, const void *b) {
    return ew[*(int *)a] - ew[*(int *)b];
}
int main() {
    int n, ch, num, neg, ec = 0, i;
    while ((ch = getchar()) != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')))
        ;
    neg = 0;
    num = 0;
    if (ch == '-') {
        neg = 1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        num = num * 10 + (ch - '0');
        ch = getchar();
    }
    n = neg ? -num : num;
    for (i = 0; i < n; i++) {
        parent[i] = i;
        rnk[i] = 0;
    }
    while ((ch = getchar()) != EOF && ch != '[')
        ;
    while (1) {
        ch = getchar();
        if (ch == EOF || ch == ']')
            break;
        if (ch == '[') {
            int vals[3], vi = 0;
            while (vi < 3) {
                while ((ch = getchar()) != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')))
                    ;
                neg = 0;
                num = 0;
                if (ch == '-') {
                    neg = 1;
                    ch = getchar();
                }
                while (ch >= '0' && ch <= '9') {
                    num = num * 10 + (ch - '0');
                    ch = getchar();
                }
                vals[vi++] = neg ? -num : num;
            }
            eu[ec] = vals[0];
            ev[ec] = vals[1];
            ew[ec] = vals[2];
            eidx[ec] = ec;
            ec++;
            while (ch != ']' && ch != EOF)
                ch = getchar();
        }
    }
    qsort(eidx, ec, sizeof(int), cmp);
    long long total = 0;
    int used = 0;
    for (i = 0; i < ec && used < n - 1; i++) {
        int idx2 = eidx[i];
        if (unite(eu[idx2], ev[idx2])) {
            total += ew[idx2];
            used++;
        }
    }
    if (used == n - 1)
        printf("%lld\n", total);
    else
        printf("-1\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(E log E)

Sorting dominates

⚡ Linearithmic

Space Complexity

O(V)

Union-Find arrays

✓ Linear Space

8 Views

High Frequency

~20 min Avg. Time

0 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

Kruskal's Algorithm — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler