Minimum Spanning Tree - Problem

Given a weighted undirected graph, implement Kruskal's algorithm to find the minimum spanning tree (MST). The graph is represented as a list of edges, where each edge contains two vertices and a weight.

A minimum spanning tree is a subset of edges that connects all vertices with the minimum total weight and contains no cycles. The result should be a list of edges in the MST.

Return the edges of the MST as a list of [u, v, weight] arrays, sorted by weight in ascending order.

Input & Output

Example 1 — Simple Triangle Graph

$ Input: edges = [[0,1,1],[1,2,2],[0,2,3]]

› Output: [[0,1,1],[1,2,2]]

💡 Note: Three vertices (0,1,2) with edges: (0,1):1, (1,2):2, (0,2):3. The MST uses the two cheapest edges (0,1):1 and (1,2):2 with total weight 3. Edge (0,2):3 would create a cycle.

Example 2 — Four Vertex Graph

$ Input: edges = [[0,1,4],[0,2,1],[1,2,2],[1,3,5],[2,3,3]]

› Output: [[0,2,1],[1,2,2],[2,3,3]]

💡 Note: Four vertices need 3 edges for MST. Sorted by weight: (0,2):1, (1,2):2, (2,3):3, (0,1):4, (1,3):5. Take first 3 edges that don't create cycles: (0,2):1, (1,2):2, (2,3):3. Total weight: 6.

Example 3 — Linear Chain

$ Input: edges = [[0,1,1],[1,2,1],[2,3,1]]

› Output: [[0,1,1],[1,2,1],[2,3,1]]

💡 Note: Linear chain graph where all edges have equal weight 1. All edges are needed for MST since no cycles exist. Total weight: 3.

Constraints

1 ≤ edges.length ≤ 1000
0 ≤ u, v ≤ 100
1 ≤ weight ≤ 1000
The graph is connected

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 A Apple 28

The optimal approach uses Kruskal's algorithm: sort edges by weight and greedily add the cheapest edge that doesn't create a cycle using Union-Find for efficient cycle detection. Time: O(m log m), Space: O(n).

Common Approaches

✓ Brute Force - Try All Subsets

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

Generate all possible subsets of edges, check if each subset forms a valid spanning tree (connected and acyclic), then return the one with minimum total weight.

Kruskal's Algorithm (Optimal)

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

Sort all edges by weight in ascending order, then iterate through them. For each edge, use Union-Find to check if adding it would create a cycle. If not, add it to the MST.

Brute Force - Try All Subsets — Algorithm Steps

Generate all 2^m possible subsets of edges
For each subset, verify it connects all vertices
Check that it has exactly n-1 edges and no cycles
Track the subset with minimum total weight

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all possible combinations of edges

Validate Each

Check if subset connects all vertices without cycles

Find Minimum

Track the valid subset with lowest total weight

Code -

solution.c — C

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

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

int* vertices;
int vertexCount;
Edge* bestMst;
int bestMstSize;
int minWeight;

void dfs(int node, int** graph, int* graphSizes, int* visited, int n);
int isConnected(Edge* edges, int edgeCount, int* uniqueVertices, int n);
int getUniqueVertices(Edge* edges, int edgeCount, int* uniqueVertices);

Edge* solution(Edge* edges, int edgeCount, int* returnSize) {
    *returnSize = 0;
    if (edgeCount == 0) return NULL;
    
    int uniqueVertices[1000];
    int n = getUniqueVertices(edges, edgeCount, uniqueVertices);
    
    if (n <= 1) return NULL;
    
    minWeight = INT_MAX;
    bestMst = NULL;
    bestMstSize = 0;
    
    // Try all possible subsets
    for (int mask = 1; mask < (1 << edgeCount); mask++) {
        Edge subset[edgeCount];
        int subsetSize = 0;
        
        for (int i = 0; i < edgeCount; i++) {
            if (mask & (1 << i)) {
                subset[subsetSize++] = edges[i];
            }
        }
        
        if (subsetSize != n - 1) continue;
        
        if (isConnected(subset, subsetSize, uniqueVertices, n)) {
            int totalWeight = 0;
            for (int i = 0; i < subsetSize; i++) {
                totalWeight += subset[i].weight;
            }
            
            if (totalWeight < minWeight) {
                minWeight = totalWeight;
                bestMstSize = subsetSize;
                
                if (bestMst) free(bestMst);
                bestMst = (Edge*)malloc(subsetSize * sizeof(Edge));
                memcpy(bestMst, subset, subsetSize * sizeof(Edge));
                
                // Sort by weight
                for (int i = 0; i < subsetSize - 1; i++) {
                    for (int j = i + 1; j < subsetSize; j++) {
                        if (bestMst[i].weight > bestMst[j].weight) {
                            Edge temp = bestMst[i];
                            bestMst[i] = bestMst[j];
                            bestMst[j] = temp;
                        }
                    }
                }
            }
        }
    }
    
    *returnSize = bestMstSize;
    return bestMst;
}

int getUniqueVertices(Edge* edges, int edgeCount, int* uniqueVertices) {
    int temp[1000];
    int count = 0;
    
    for (int i = 0; i < edgeCount; i++) {
        int found1 = 0, found2 = 0;
        for (int j = 0; j < count; j++) {
            if (temp[j] == edges[i].u) found1 = 1;
            if (temp[j] == edges[i].v) found2 = 1;
        }
        if (!found1) temp[count++] = edges[i].u;
        if (!found2) temp[count++] = edges[i].v;
    }
    
    memcpy(uniqueVertices, temp, count * sizeof(int));
    return count;
}

int isConnected(Edge* edges, int edgeCount, int* uniqueVertices, int n) {
    if (edgeCount == 0) return n <= 1;
    
    int** graph = (int**)malloc(1000 * sizeof(int*));
    int* graphSizes = (int*)calloc(1000, sizeof(int));
    
    for (int i = 0; i < 1000; i++) {
        graph[i] = (int*)malloc(1000 * 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;
    }
    
    int visited[1000] = {0};
    dfs(uniqueVertices[0], graph, graphSizes, visited, n);
    
    int connectedCount = 0;
    for (int i = 0; i < n; i++) {
        if (visited[uniqueVertices[i]]) connectedCount++;
    }
    
    for (int i = 0; i < 1000; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSizes);
    
    return connectedCount == n;
}

void dfs(int node, int** graph, int* graphSizes, int* visited, int n) {
    visited[node] = 1;
    for (int i = 0; i < graphSizes[node]; i++) {
        int neighbor = graph[node][i];
        if (!visited[neighbor]) {
            dfs(neighbor, graph, graphSizes, visited, n);
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    Edge edges[1000];
    int edgeCount = 0;
    
    // Parse JSON manually
    char* ptr = line + 1; // Skip opening bracket
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            int u, v, w;
            sscanf(ptr + 1, "%d,%d,%d", &u, &v, &w);
            edges[edgeCount++] = (Edge){u, v, w};
            while (*ptr && *ptr != ']') ptr++;
        }
        ptr++;
    }
    
    int resultSize;
    Edge* result = solution(edges, edgeCount, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("[%d,%d,%d]", result[i].u, result[i].v, result[i].weight);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m)

Must check all 2^m possible subsets of m edges

⚡ Linearithmic

Space Complexity

O(n)

Storage for tracking connected components and current best MST

⚡ Linearithmic Space

34.5K Views

Medium Frequency

~25 min Avg. Time

892 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

Minimum Spanning Tree - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Subsets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler