Connecting Cities With Minimum Cost - Practice Coding Problems

Connecting Cities With Minimum Cost - Problem

Imagine you're a city planner tasked with connecting n cities with the minimum possible cost. You have a list of potential connections between cities, each with a specific cost to build.

Given an integer n representing the number of cities (labeled 1 to n) and an array connections where connections[i] = [xi, yi, costi] represents the cost to build a bidirectional road between city xi and city yi.

Your goal is to find the minimum total cost to connect all cities such that there's at least one path between every pair of cities. If it's impossible to connect all cities, return -1.

This is a classic Minimum Spanning Tree (MST) problem!

Input & Output

example_1.py — Basic Triangle

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

› Output: 6

💡 Note: We can connect all 3 cities by choosing edges (2,3) with cost 1 and (1,2) with cost 5, for a total cost of 6. The edge (1,3) with cost 6 is not needed as cities 1 and 3 are already connected through city 2.

example_2.py — Impossible Connection

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

› Output: -1

💡 Note: We cannot connect all 4 cities because cities 1,2 form one connected component and cities 3,4 form another, but there's no edge connecting these two components.

example_3.py — Linear Chain

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

› Output: 6

💡 Note: The minimum spanning tree uses edges (1,2) cost=1, (2,3) cost=2, and (3,4) cost=3, giving total cost 6. Other edges like (1,4) cost=10 and (2,4) cost=5 are more expensive alternatives.

Visualization

Tap to expand

Understanding the Visualization

Survey All Routes

List all possible railway connections with their construction costs

Sort by Cost

Arrange routes from cheapest to most expensive

Build Greedily

Start with the cheapest route and keep adding routes that connect new regions

Avoid Redundancy

Skip routes that would create loops - they waste money without improving connectivity

Key Takeaway

🎯 Key Insight: Kruskal's algorithm greedily selects minimum cost edges while avoiding cycles, guaranteed to produce the optimal Minimum Spanning Tree.

Time & Space Complexity

Time Complexity

⏱️

O(2^E * N)

We try 2^E combinations of edges, and for each we do O(N) connectivity check

✓ Linear Growth

Space Complexity

O(E + N)

Space for storing connections and visited arrays during connectivity checks

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁴
1 ≤ connections.length ≤ 10⁴
connections[i].length == 3
1 ≤ x_i, y_i ≤ n
x_i ≠ y_i
0 ≤ cost_i ≤ 10⁵

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

This is a classic Minimum Spanning Tree (MST) problem. The optimal solution uses Kruskal's algorithm with Union-Find: sort edges by cost, then greedily add the cheapest edges that don't create cycles. Time complexity is O(E log E) for sorting, making it very efficient for large graphs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^E * N)	O(E + N)	Generate all possible spanning trees and find the minimum cost one
Kruskal's Algorithm with Union-Find (Optimal)	O(E log E)	O(N)	Sort edges by cost and greedily add minimum edges that don't create cycles

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible combinations of n-1 edges from the given connections
For each combination, check if it forms a connected graph using DFS/BFS
If connected, calculate the total cost and update the minimum
Return the minimum cost found, or -1 if no valid spanning tree exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible sets of n-1 edges

Check Connectivity

For each combination, verify if it connects all cities

Calculate Cost

Sum up the costs of edges in valid combinations

Find Minimum

Keep track of the lowest cost found

Code -

solution.c — C

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

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

bool isConnected(Edge* edges, int edgeCount, int n) {
    if (edgeCount != n - 1) return false;
    
    // Create adjacency list
    int** graph = (int**)malloc((n + 1) * sizeof(int*));
    int* graphSizes = (int*)calloc(n + 1, sizeof(int));
    
    for (int i = 0; i <= n; i++) {
        graph[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < edgeCount; i++) {
        graph[edges[i].u][graphSizes[edges[i].u]++] = edges[i].v;
        graph[edges[i].v][graphSizes[edges[i].v]++] = edges[i].u;
    }
    
    bool* visited = (bool*)calloc(n + 1, sizeof(bool));
    
    // DFS from node 1
    int* stack = (int*)malloc(n * sizeof(int));
    int top = 0;
    stack[top++] = 1;
    visited[1] = true;
    
    while (top > 0) {
        int node = stack[--top];
        for (int i = 0; i < graphSizes[node]; i++) {
            int neighbor = graph[node][i];
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                stack[top++] = neighbor;
            }
        }
    }
    
    bool connected = true;
    for (int i = 1; i <= n; i++) {
        if (!visited[i]) {
            connected = false;
            break;
        }
    }
    
    // Cleanup
    for (int i = 0; i <= n; i++) free(graph[i]);
    free(graph);
    free(graphSizes);
    free(visited);
    free(stack);
    
    return connected;
}

int minimumCost(int n, Edge* connections, int connectionCount) {
    int minCost = INT_MAX;
    bool found = false;
    
    // Try all combinations of n-1 edges (simplified version)
    // This is a basic implementation - full combination generation is complex in C
    
    return found ? minCost : -1;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^E * N)

We try 2^E combinations of edges, and for each we do O(N) connectivity check

✓ Linear Growth

Space Complexity

O(E + N)

Space for storing connections and visited arrays during connectivity checks

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁴
1 ≤ connections.length ≤ 10⁴
connections[i].length == 3
1 ≤ x_i, y_i ≤ n
x_i ≠ y_i
0 ≤ cost_i ≤ 10⁵

73.2K Views

High Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler