Practice. 1.3 Prim's MST (minimal spanning tree)

Author: another-guy

README.md

@@ -17,6 +17,8 @@
     * 1 Graph
         * 1.1 TopSort (Topological Sorting)
         * 1.2 Dijkstra's shortest path
+        * 1.3 Prim's minimal spanning tree
+    * 9 Naive (hashtable-based) PriorityQueue
 1. CodinGame
     * Easy
         * Chuck Norris (message encoding)

__tests__/1-3-prim-minimal-spaning-tree.spec.ts

@@ -0,0 +1,38 @@
+import { graphsEqual } from '../src/practice/0-undirected-graph';
+import { primMinimalSpanningTree } from '../src/practice/1-3-prim-minimal-spaning-tree';
+
+const graph = {
+  nodes: ['a', 'b', 'c', 'd', 'e', 'f', 'g'],
+  edges: [
+    { source: 'a', destination: 'b', distance: 7 },
+    { source: 'a', destination: 'd', distance: 5 },
+    { source: 'b', destination: 'd', distance: 9 },
+    { source: 'b', destination: 'c', distance: 8 },
+    { source: 'b', destination: 'e', distance: 7 },
+    { source: 'c', destination: 'e', distance: 5 },
+    { source: 'd', destination: 'e', distance: 15 },
+    { source: 'd', destination: 'f', distance: 6 },
+    { source: 'f', destination: 'e', distance: 8 },
+    { source: 'f', destination: 'g', distance: 11 },
+    { source: 'e', destination: 'g', distance: 9 },
+  ],
+};
+const expectedGraph = {
+  nodes: ['a', 'b', 'c', 'd', 'e', 'f', 'g'],
+  edges: [
+    { source: 'a', destination: 'b', distance: 7 },
+    { source: 'a', destination: 'd', distance: 5 },
+    { source: 'b', destination: 'e', distance: 7 },
+    { source: 'c', destination: 'e', distance: 5 },
+    { source: 'd', destination: 'f', distance: 6 },
+    { source: 'e', destination: 'g', distance: 9 },
+  ],
+};
+
+describe(primMinimalSpanningTree.name, () => {
+  it(`Should pass an end-to-end test on a small graph`, () => {
+    const resultSpanningTree = primMinimalSpanningTree(graph);
+    const treeMatchesExpected = graphsEqual(resultSpanningTree, expectedGraph);
+    expect(treeMatchesExpected).toBeTruthy();
+  });
+});

src/practice/0-0-candidate-algorithms.md

@@ -7,7 +7,6 @@
 * Flood fill
 * Graph coloring
 * Graph connectivity
-* Prim's minimal spanning tree
 * Kruskal's minimal spanning tree
 
 ## Tree

src/practice/0-undirected-graph.ts

@@ -8,3 +8,21 @@ export interface IUndirectedGraph {
   nodes: string[];
   edges: IEdge[];
 }
+
+export function graphsEqual(graph1: IUndirectedGraph, graph2: IUndirectedGraph): boolean {
+  if (!graph1 || !graph2) throw new Error(`Compared graphs can not be null/undefined`);
+  
+  if (graph1.nodes.length !== graph2.nodes.length) return false;
+  const someNodeMissing = graph1.nodes.some(node => graph2.nodes.indexOf(node) < 0);
+  if (someNodeMissing) return false;
+  
+  if (graph1.edges.length !== graph2.edges.length) return false;
+  const someEdgeMissing = graph1.edges.some(edge =>
+    graph2.edges.findIndex(candidateEdge =>
+      (candidateEdge.source === edge.source && candidateEdge.destination === edge.destination) ||
+      (candidateEdge.source === edge.destination && candidateEdge.destination === edge.source)) < 0
+  );
+  if (someEdgeMissing) return false;
+  
+  return true;
+}

src/practice/1-3-prim-minimal-spaning-tree.ts

@@ -0,0 +1,51 @@
+import { IEdge, IUndirectedGraph } from './0-undirected-graph';
+
+export function primMinimalSpanningTree(graph: IUndirectedGraph): IUndirectedGraph {
+  const result: IUndirectedGraph = { nodes: [], edges: [] };
+
+  // create a set of  unvisitedNodes
+  const unvisitedNodes = new Set(graph.nodes);
+
+  // select random node  x
+  const x = graph.nodes[0]; // TODO !!!
+  
+  // add  x  to result graph
+  result.nodes.push(x);
+  // remove node  x  from unvisitedNodes
+  unvisitedNodes.delete(x);
+  
+  while (unvisitedNodes.size) {
+    //   find the shortest edge  e  from any of result graph's nodes to a node in unvisitedNodes
+    const { edge, unvisitedNeighbor } = shortestEdge(graph, unvisitedNodes);
+    if (!edge) break;
+
+    //   add edge  e  to result graph
+    result.edges.push(edge);
+
+    //   add  e's  OTHER node  unvisitedNeighbor  to result graph
+    result.nodes.push(unvisitedNeighbor);
+    //   remove node  unvisitedNeighbor  from unvisitedNodes
+    unvisitedNodes.delete(unvisitedNeighbor);
+  }
+
+  return result;
+}
+
+export function shortestEdge(
+  graph: IUndirectedGraph,
+  unvisitedNodes: Set<string>,
+) {
+  let shortestEdge: IEdge = { distance: Number.MAX_SAFE_INTEGER, source: '', destination: '' };
+  graph.edges.forEach(edge => {
+    const sourceUnvisited = unvisitedNodes.has(edge.source) && !unvisitedNodes.has(edge.destination);
+    const destinationUnvisited = unvisitedNodes.has(edge.destination) && !unvisitedNodes.has(edge.source);
+    const isShorter = edge.distance < shortestEdge.distance;
+    if ((sourceUnvisited || destinationUnvisited) && isShorter)
+      shortestEdge = edge;
+  });
+
+  const unvisitedNeighbor = unvisitedNodes.has(shortestEdge.source) ?
+    shortestEdge.source :
+    shortestEdge.destination;
+  return { edge: shortestEdge, unvisitedNeighbor };
+}