Min Cost to Connect All Points

Min Cost to Connect All Points - Problem

Minimum Spanning Tree Problem: Imagine you're a city planner tasked with connecting multiple districts with roads. You have n districts represented as points on a 2D coordinate plane, where each point points[i] = [xi, yi] represents the coordinates of district i.

The cost of building a road between two districts is equal to their Manhattan distance: |xi - xj| + |yi - yj|. Your goal is to find the minimum total cost to connect all districts such that there's exactly one path between any two districts (forming a tree structure).

Input: An array of 2D coordinates representing district locations
Output: The minimum cost to connect all districts with roads

Input & Output

example_1.py — Basic Triangle

$ Input: points = [[0,0],[2,2],[3,10],[5,2],[7,0]]

› Output: 20

💡 Note: Connect points to form MST: (0,0)→(7,0) cost 7, (7,0)→(5,2) cost 4, (5,2)→(2,2) cost 3, (2,2)→(3,10) cost 9. Total: 7+4+3+6=20

example_2.py — Simple Square

$ Input: points = [[3,12],[-2,5],[-4,1]]

› Output: 18

💡 Note: Three points form a triangle. Cheapest connections: (-4,1)→(-2,5) cost 6, (-2,5)→(3,12) cost 12. Total: 6+12=18

example_3.py — Single Point

$ Input: points = [[0,0]]

› Output: 0

💡 Note: Single point needs no connections, so cost is 0

Constraints

1 ≤ points.length ≤ 1000
-10⁶ ≤ xi, yi ≤ 10⁶
All pairs (xi, yi) are distinct
Manhattan distance only - not Euclidean distance

Visualization

Tap to expand

Asked in

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

This is a classic Minimum Spanning Tree (MST) problem. The optimal solution uses Prim's Algorithm with O(n²) time complexity. Start with any point and repeatedly add the cheapest edge that connects a new point to the existing tree. The key insight is that we only need exactly n-1 edges to connect n points optimally.

Common Approaches

✓ Brute Force (All Possible Spanning Trees)

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

This approach generates every possible way to connect all points using exactly n-1 edges, calculates the total Manhattan distance for each configuration, and returns the minimum cost. While theoretically correct, this becomes computationally infeasible for even small inputs.

Prim's Algorithm (Optimal)

⏱️ Time: O(n²) Space: O(n)

Prim's algorithm builds the MST by starting with an arbitrary point and repeatedly adding the cheapest edge that connects a new point to the existing tree. This greedy approach guarantees the optimal solution for MST problems.

Brute Force (All Possible Spanning Trees) — Algorithm Steps

Generate all possible combinations of n-1 edges from all possible edges
For each combination, check if it forms a connected spanning tree
Calculate total Manhattan distance for valid spanning trees
Return the minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Edges

Create all possible connections between points with their Manhattan distances

Try All Combinations

Test every possible combination of n-1 edges to see if they form a connected tree

Check Connectivity

For each valid combination, verify all points are connected

Find Minimum

Return the combination with the lowest total cost

Code -

solution.c — C

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

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int min_int(int a, int b) {
    return a < b ? a : b;
}

bool is_connected(Edge* selected_edges, int edge_count, int n) {
    if (edge_count != n - 1) {
        return false;
    }
    
    // Build adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* sizes = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < edge_count; i++) {
        int u = selected_edges[i].u;
        int v = selected_edges[i].v;
        graph[u][sizes[u]++] = v;
        graph[v][sizes[v]++] = u;
    }
    
    // DFS to check connectivity
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int* stack = (int*)malloc(n * sizeof(int));
    int stack_size = 0;
    
    stack[stack_size++] = 0;
    visited[0] = true;
    int count = 1;
    
    while (stack_size > 0) {
        int node = stack[--stack_size];
        for (int i = 0; i < sizes[node]; i++) {
            int neighbor = graph[node][i];
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                stack[stack_size++] = neighbor;
                count++;
            }
        }
    }
    
    bool result = (count == n);
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(sizes);
    free(visited);
    free(stack);
    
    return result;
}

bool next_combination(int* combination, int k, int max_val) {
    for (int i = k - 1; i >= 0; i--) {
        if (combination[i] < max_val - k + i) {
            combination[i]++;
            for (int j = i + 1; j < k; j++) {
                combination[j] = combination[j - 1] + 1;
            }
            return true;
        }
    }
    return false;
}

int minCostConnectPoints(int** points, int pointsSize) {
    int n = pointsSize;
    if (n <= 1) {
        return 0;
    }
    
    // Generate all possible edges with their costs
    int max_edges = n * (n - 1) / 2;
    Edge* edges = (Edge*)malloc(max_edges * sizeof(Edge));
    int edge_count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int cost = abs_val(points[i][0] - points[j][0]) + abs_val(points[i][1] - points[j][1]);
            edges[edge_count].cost = cost;
            edges[edge_count].u = i;
            edges[edge_count].v = j;
            edge_count++;
        }
    }
    
    int min_cost = INT_MAX;
    int* combination = (int*)malloc((n - 1) * sizeof(int));
    
    // Initialize first combination
    for (int i = 0; i < n - 1; i++) {
        combination[i] = i;
    }
    
    // Try all combinations of n-1 edges
    do {
        Edge* selected = (Edge*)malloc((n - 1) * sizeof(Edge));
        for (int i = 0; i < n - 1; i++) {
            selected[i] = edges[combination[i]];
        }
        
        if (is_connected(selected, n - 1, n)) {
            int total_cost = 0;
            for (int i = 0; i < n - 1; i++) {
                total_cost += selected[i].cost;
            }
            min_cost = min_int(min_cost, total_cost);
        }
        
        free(selected);
    } while (next_combination(combination, n - 1, edge_count));
    
    free(edges);
    free(combination);
    return min_cost;
}

int parse_number(const char** p) {
    int sign = 1;
    int num = 0;
    
    if (**p == '-') {
        sign = -1;
        (*p)++;
    }
    
    while (**p >= '0' && **p <= '9') {
        num = num * 10 + (**p - '0');
        (*p)++;
    }
    
    return sign * num;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    const char* p = input;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    int** points = NULL;
    int n = 0;
    int capacity = 100;
    points = (int**)malloc(capacity * sizeof(int*));
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '\n' || *p == '\t') p++;
        
        if (*p == '[') {
            p++; // Skip '['
            
            if (n >= capacity) {
                capacity *= 2;
                points = (int**)realloc(points, capacity * sizeof(int*));
            }
            
            points[n] = (int*)malloc(2 * sizeof(int));
            
            // Parse first number
            while (*p == ' ') p++;
            points[n][0] = parse_number(&p);
            
            // Skip comma
            while (*p == ' ' || *p == ',') p++;
            
            // Parse second number
            points[n][1] = parse_number(&p);
            
            // Skip to ']'
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            
            n++;
        } else if (*p == ']') {
            break;
        } else {
            p++;
        }
    }
    
    printf("%d\n", minCostConnectPoints(points, n));
    
    for (int i = 0; i < n; i++) {
        free(points[i]);
    }
    free(points);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n²) × n)

We have O(n²) possible edges, need to check O(2^(n²)) combinations, and verify connectivity takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(n²)

Need to store all possible edges and current spanning tree being evaluated

⚡ Linearithmic Space

89.5K Views

High Frequency

~25 min Avg. Time

2.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 Possible Spanning Trees) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler