Connecting Cities With Minimum Cost

Connecting Cities With Minimum Cost - Problem

There are n cities labeled from 1 to n. You are given the integer n and an array connections where connections[i] = [xi, yi, costi] indicates that the cost of connecting city xi and city yi (bidirectional connection) is costi.

Return the minimum cost to connect all the n cities such that there is at least one path between each pair of cities. If it is impossible to connect all the n cities, return -1.

The cost is the sum of the connections' costs used.

Input & Output

Example 1 — Basic Connected Graph

$ Input: n = 3, connections = [[1,2,5],[1,3,6],[2,3,1]]

› Output: 6

💡 Note: We need to connect all 3 cities. The minimum spanning tree uses edges [2,3,1] and [1,2,5], giving total cost 1 + 5 = 6.

Example 2 — Impossible to Connect

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

› Output: -1

💡 Note: Cities 1,2 form one component and cities 3,4 form another component. There's no way to connect them since no connection exists between the components.

Example 3 — Single City

$ Input: n = 1, connections = []

› Output: 0

💡 Note: Only one city exists, so no connections are needed. The cost is 0.

Constraints

1 ≤ n ≤ 10⁴
0 ≤ connections.length ≤ 10⁴
connections[i].length == 3
1 ≤ xi, yi ≤ n
xi ≠ yi
0 ≤ costi ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 F Facebook 35 M Microsoft 31

This is a classic Minimum Spanning Tree (MST) problem. The optimal approach uses Kruskal's algorithm with Union-Find: sort connections by cost, then greedily add the cheapest connections that don't create cycles. Time: O(m log m), Space: O(n).

Common Approaches

✓ Prefix Sum

⏱️ Time: N/A Space: N/A

Brute Force - Try All Subsets

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

Generate all possible subsets of connections and for each subset that connects all cities, calculate the total cost. Return the minimum cost found.

Kruskal's Algorithm with Union-Find

⏱️ Time: O(m log m) Space: O(n)

Sort all connections by cost in ascending order. Use Union-Find data structure to efficiently track connected components. Greedily add the cheapest connection that connects two different components until all cities are connected.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int u, v, cost;
} Edge;

int parent[1001];
int rank_arr[1001];

int find(int x) {
    if (parent[x] != x) {
        parent[x] = find(parent[x]);
    }
    return parent[x];
}

int unite(int x, int y) {
    int px = find(x), py = find(y);
    if (px == py) return 0;
    
    if (rank_arr[px] < rank_arr[py]) {
        parent[px] = py;
    } else if (rank_arr[px] > rank_arr[py]) {
        parent[py] = px;
    } else {
        parent[py] = px;
        rank_arr[px]++;
    }
    return 1;
}

int compareEdges(const void* a, const void* b) {
    Edge* ea = (Edge*)a;
    Edge* eb = (Edge*)b;
    return ea->cost - eb->cost;
}

int parseConnections(char* line, Edge* edges) {
    int len = strlen(line);
    if (len < 2) return 0;
    
    int edgeCount = 0;
    int i = 1; // Skip first '['
    
    while (i < len) {
        if (line[i] == '[') {
            // Found start of an edge
            int j = i + 1;
            int values[3];
            int valueCount = 0;
            int numStart = j;
            
            while (j < len && line[j] != ']') {
                if (line[j] == ',' || line[j] == ']') {
                    char temp = line[j];
                    line[j] = '\0';
                    values[valueCount++] = atoi(line + numStart);
                    line[j] = temp;
                    numStart = j + 1;
                }
                j++;
            }
            
            // Handle last number
            if (j < len && line[j] == ']') {
                char temp = line[j];
                line[j] = '\0';
                if (numStart < j) {
                    values[valueCount++] = atoi(line + numStart);
                }
                line[j] = temp;
            }
            
            if (valueCount == 3) {
                edges[edgeCount].u = values[0];
                edges[edgeCount].v = values[1];
                edges[edgeCount].cost = values[2];
                edgeCount++;
            }
            
            i = j + 1;
        } else {
            i++;
        }
    }
    
    return edgeCount;
}

int main() {
    char line[10000];
    
    // Read n
    if (!fgets(line, sizeof(line), stdin)) return 1;
    int n = atoi(line);
    
    // Read connections
    if (!fgets(line, sizeof(line), stdin)) return 1;
    
    // Remove newline
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') line[len-1] = '\0';
    
    Edge edges[10000];
    int edgeCount = parseConnections(line, edges);
    
    // Handle special case: single city
    if (n == 1) {
        printf("0\n");
        return 0;
    }
    
    // Initialize Union-Find
    for (int i = 1; i <= n; i++) {
        parent[i] = i;
        rank_arr[i] = 0;
    }
    
    // Sort edges by cost
    qsort(edges, edgeCount, sizeof(Edge), compareEdges);
    
    // Kruskal's algorithm
    int totalCost = 0;
    int edgesUsed = 0;
    
    for (int i = 0; i < edgeCount && edgesUsed < n - 1; i++) {
        if (unite(edges[i].u, edges[i].v)) {
            totalCost += edges[i].cost;
            edgesUsed++;
        }
    }
    
    // Check if all cities are connected
    if (edgesUsed == n - 1) {
        printf("%d\n", totalCost);
    } else {
        printf("-1\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

67.0K Views

High Frequency

~25 min Avg. Time

956 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