Min Cost to Connect All Points - Practice Coding Problems

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

Understanding the Visualization

Calculate All Distances

Find Manhattan distance between every pair of points

Start MST Construction

Pick any starting point and mark it as connected

Grow the Tree

Always add the cheapest edge connecting MST to a new point

Complete Connection

Continue until all points are connected with n-1 edges

Key Takeaway

🎯 Key Insight: MST problems require exactly n-1 edges to connect n points optimally. Prim's greedy approach of always choosing the cheapest available connection guarantees the minimum total cost.

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

Approach	Time	Space	Notes
✓ Prim's Algorithm (Optimal)	O(n²)	O(n)	Grow the minimum spanning tree one edge at a time, always choosing the cheapest connection
Brute Force (All Possible Spanning Trees)	O(2^(n²) × n)	O(n²)	Generate all possible spanning trees and find the minimum cost one

Prim's Algorithm (Optimal) — Algorithm Steps

Start with any point and add it to the MST
Find the cheapest edge connecting MST to a non-MST point
Add that edge and point to the MST
Repeat until all points are connected
Return total cost of selected edges

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Point A

Choose any starting point and mark it as part of MST

Find Cheapest Connection

Find the cheapest edge from MST to any non-MST point

Add to MST

Add the selected edge and point to the MST

Repeat Until Complete

Continue until all points are connected

Code -

solution.c — C

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

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

int minCostConnectPoints(int** points, int pointsSize) {
    if (pointsSize <= 1) return 0;
    
    bool* inMST = (bool*)calloc(pointsSize, sizeof(bool));
    int* minCost = (int*)malloc(pointsSize * sizeof(int));
    
    for (int i = 0; i < pointsSize; i++) {
        minCost[i] = INT_MAX;
    }
    minCost[0] = 0;
    
    int totalCost = 0;
    
    for (int i = 0; i < pointsSize; i++) {
        int u = -1;
        for (int v = 0; v < pointsSize; v++) {
            if (!inMST[v] && (u == -1 || minCost[v] < minCost[u])) {
                u = v;
            }
        }
        
        inMST[u] = true;
        totalCost += minCost[u];
        
        for (int v = 0; v < pointsSize; v++) {
            if (!inMST[v]) {
                int cost = abs_val(points[u][0] - points[v][0]) + abs_val(points[u][1] - points[v][1]);
                if (cost < minCost[v]) {
                    minCost[v] = cost;
                }
            }
        }
    }
    
    free(inMST);
    free(minCost);
    return totalCost;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int** points = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        points[i] = (int*)malloc(2 * sizeof(int));
        scanf("%d %d", &points[i][0], &points[i][1]);
    }
    
    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(n²)

For each of n iterations, we check at most n edges to find the minimum, giving us O(n²) total time

⚠ Quadratic Growth

Space Complexity

O(n)

Need arrays to track visited nodes and minimum distances to MST

⚡ 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

Prim's Algorithm (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler