Minimum Spanning Tree
Given a connected and undirected graph, find the minimum spanning tree of the graph. The minimum spanning tree is a subgraph that connects all the vertices together while minimizing the total edge cost.
Constraints:
- The graph is connected and undirected
- The graph has no self-loops or multiple edges between any two vertices
- The graph has a non-negative edge weight
Examples:
Input: [[0, 0, 2], [0, 1, 3], [1, 2, 1], [2, 0, 1]]
Output: [[0, 1, 1], [1, 2, 1], [2, 0, 1]]
Explanation: The minimum spanning tree has edges (0, 1) with weight 1, (1, 2) with weight 1, and (2, 0) with weight 1, with a total weight of 3.
Solutions
Kruskal's Algorithm
Kruskal's algorithm is a greedy algorithm that finds the minimum spanning tree of a graph. It works by sorting the edges of the graph by weight and then iterating over the sorted edges. For each edge, it checks if the two vertices of the edge are in the same connected component. If they are not, it adds the edge to the result and merges the two components.
function findMinimumSpanningTree(edges) {
const parent = {};
const rank = {};
const result = [];
// Initialize the parent and rank arrays
for (let i = 0; i < edges.length; i++) {
parent[i] = i;
rank[i] = 0;
}
// Sort the edges by weight
edges.sort((a, b) => a[2] - b[2]);
// Iterate over the sorted edges and add them to the result if they do not form a cycle
for (let i = 0; i < edges.length; i++) {
const [u, v, weight] = edges[i];
if (find(parent, u) !== find(parent, v)) {
result.push([u, v, weight]);
union(parent, rank, u, v);
}
}
return result;
}
function find(parent, i) {
if (parent[i] === i) return i;
return find(parent, parent[i]);
}
function union(parent, rank, u, v) {
const rootU = find(parent, u);
const rootV = find(parent, v);
if (rank[rootU] < rank[rootV]) {
parent[rootU] = rootV;
} else if (rank[rootU] > rank[rootV]) {
parent[rootV] = rootU;
} else {
parent[rootV] = rootU;
rank[rootU]++;
}
}
Follow-up:
How would you modify the algorithm to find the maximum spanning tree of a graph?
