feat: add Prim's algorithm for Minimum Spanning Tree

fix: do not decrease priority in PriorityQueue increasePriority()

data_structures/heap/heap.ts

@@ -14,7 +14,7 @@
 export abstract class Heap<T> {
  protected heap: T[];
  // A comparison function. Returns true if a should be the parent of b.
- private compare: (a: T, b: T) => boolean;
+ protected compare: (a: T, b: T) => boolean;
 
  constructor(compare: (a: T, b: T) => boolean) {
  this.heap = [];
@@ -189,6 +189,10 @@ export class PriorityQueue<T> extends MinHeap<T> {
  return;
  }
  let key = this.keys[idx];
+ if (this.compare(this.heap[key], value)) {
+ // Do not do anything if the value in the heap already has a higher priority.
+ return;
+ }
  // Increase the priority and bubble it up the heap.
  this.heap[key] = value;
  this.bubbleUp(key);

data_structures/heap/test/min_heap.test.ts

@@ -65,6 +65,11 @@ describe("MinHeap", () => {
  heap.increasePriority(81, 72);
  heap.increasePriority(9, 0);
  heap.increasePriority(43, 33);
+ // decreasing priority should do nothing
+ heap.increasePriority(72, 100);
+ heap.increasePriority(12, 24);
+ heap.increasePriority(39, 40);
+
  heap.check();
  // Elements after increasing priority
  const newElements: number[] = [

graph/prim.ts

@@ -0,0 +1,59 @@
+import { PriorityQueue } from '../data_structures/heap/heap'
+/**
+ * @function prim
+ * @description Compute a minimum spanning tree(MST) of a fully connected weighted undirected graph. The input graph is in adjacency list form. It is a multidimensional array of edges. graph[i] holds the edges for the i'th node. Each edge is a 2-tuple where the 0'th item is the destination node, and the 1'th item is the edge weight.
+ * @Complexity_Analysis
+ * Time complexity: O(Elog(V))
+ * Space Complexity: O(V)
+ * @param {[number, number][][]} graph - The graph in adjacency list form
+ * @return {Edge[], number} - [The edges of the minimum spanning tree, the sum of the weights of the edges in the tree]
+ * @see https://en.wikipedia.org/wiki/Prim%27s_algorithm
+ */
+export const prim = (graph: [number, number][][]): [Edge[], number] => {
+ if (graph.length == 0) {
+ return [[], 0];
+ }
+ let minimum_spanning_tree: Edge[] = [];
+ let total_weight = 0;
+
+ let priorityQueue = new PriorityQueue((e: Edge) => { return e.b }, graph.length, (a: Edge, b: Edge) => { return a.weight < b.weight });
+ let visited = new Set<number>();
+
+ // Start from the 0'th node. For fully connected graphs, we can start from any node and still produce the MST.
+ visited.add(0);
+ add_children(graph, priorityQueue, 0);
+
+ while (!priorityQueue.isEmpty()) {
+ // We always store the previously visited edge in `edge.a`, and the newly visited node in `edge.b`.
+ let edge = priorityQueue.extract();
+ if (visited.has(edge.b)) {
+ continue;
+ }
+ minimum_spanning_tree.push(edge);
+ total_weight += edge.weight;
+ visited.add(edge.b);
+ add_children(graph, priorityQueue, edge.b);
+ }
+
+ return [minimum_spanning_tree, total_weight];
+}
+
+const add_children = (graph: [number, number][][], priorityQueue: PriorityQueue<Edge>, node: number) => {
+ for (let i = 0; i < graph[node].length; ++i) {
+ let out_edge = graph[node][i];
+ // By increasing the priority, we ensure we only add each vertex to the queue one time, and the queue will be at most size V.
+ priorityQueue.increasePriority(out_edge[0], new Edge(node, out_edge[0], out_edge[1]));
+ }
+}
+
+export class Edge {
+ a: number = 0;
+ b: number = 0;
+ weight: number = 0;
+ constructor(a: number, b: number, weight: number) {
+ this.a = a;
+ this.b = b;
+ this.weight = weight;
+ }
+}
+

graph/test/prim.test.ts

@@ -0,0 +1,85 @@
+import { Edge, prim } from "../prim";
+
+let edge_equal = (x: Edge, y: Edge): boolean => {
+ return (x.a == y.a && x.b == y.b) || (x.a == y.b && x.b == y.a) && x.weight == y.weight;
+}
+
+let test_graph = (expected_tree_edges: Edge[], other_edges: Edge[], num_vertices: number, expected_cost: number) => {
+ // First make sure the graph is undirected
+ let graph: [number, number][][] = [];
+ for (let _ = 0; _ < num_vertices; ++_) {
+ graph.push([]);
+ }
+ for (let edge of expected_tree_edges) {
+ graph[edge.a].push([edge.b, edge.weight]);
+ graph[edge.b].push([edge.a, edge.weight]);
+ }
+ for (let edge of other_edges) {
+ graph[edge.a].push([edge.b, edge.weight]);
+ graph[edge.b].push([edge.a, edge.weight]);
+ }
+
+ let [tree_edges, cost] = prim(graph);
+ expect(cost).toStrictEqual(expected_cost);
+ for (let expected_edge of expected_tree_edges) {
+ expect(tree_edges.find(edge => edge_equal(edge, expected_edge))).toBeTruthy();
+ }
+ for (let unexpected_edge of other_edges) {
+ expect(tree_edges.find(edge => edge_equal(edge, unexpected_edge))).toBeFalsy();
+ }
+};
+
+
+describe("prim", () => {
+
+ it("should return empty tree for empty graph", () => {
+ expect(prim([])).toStrictEqual([[], 0]);
+ });
+
+ it("should return empty tree for single element graph", () => {
+ expect(prim([])).toStrictEqual([[], 0]);
+ });
+
+ it("should return correct value for two element graph", () => {
+ expect(prim([[[1, 5]], []])).toStrictEqual([[new Edge(0, 1, 5)], 5]);
+ });
+
+ it("should return the correct value", () => {
+ let expected_tree_edges = [
+ new Edge(0, 1, 1),
+ new Edge(1, 3, 2),
+ new Edge(3, 2, 3),
+ ];
+
+ let other_edges = [
+ new Edge(0, 2, 4),
+ new Edge(0, 3, 5),
+ new Edge(1, 2, 6),
+ ];
+
+ test_graph(expected_tree_edges, other_edges, 4, 6);
+ });
+
+ it("should return the correct value", () => {
+ let expected_tree_edges = [
+ new Edge(0, 2, 2),
+ new Edge(1, 3, 9),
+ new Edge(2, 6, 74),
+ new Edge(2, 7, 8),
+ new Edge(3, 4, 3),
+ new Edge(4, 9, 9),
+ new Edge(5, 7, 5),
+ new Edge(7, 9, 4),
+ new Edge(8, 9, 2),
+ ]
+
+ let other_edges = [
+ new Edge(0, 1, 10),
+ new Edge(2, 4, 47),
+ new Edge(4, 5, 42),
+ ];
+
+ test_graph(expected_tree_edges, other_edges, 10, 116);
+ });
+
+})