Refactor Floyd-Warshall.

Author: trekhleb

src/algorithms/graph/floyd-warshall/__test__/floydWarshall.test.js

@@ -46,25 +46,93 @@ describe('floydWarshall', () =>{
 const{ distances, previousVertices }=floydWarshall(graph);
 
 constvertices=graph.getAllVertices();
+
+constvertexAIndex=vertices.indexOf(vertexA);
+constvertexBIndex=vertices.indexOf(vertexB);
+constvertexCIndex=vertices.indexOf(vertexC);
+constvertexDIndex=vertices.indexOf(vertexD);
+constvertexEIndex=vertices.indexOf(vertexE);
+constvertexFIndex=vertices.indexOf(vertexF);
+constvertexGIndex=vertices.indexOf(vertexG);
+constvertexHIndex=vertices.indexOf(vertexH);
+
+expect(distances[vertexAIndex][vertexHIndex]).toBe(Infinity);
+expect(distances[vertexAIndex][vertexAIndex]).toBe(0);
+expect(distances[vertexAIndex][vertexBIndex]).toBe(4);
+expect(distances[vertexAIndex][vertexEIndex]).toBe(7);
+expect(distances[vertexAIndex][vertexCIndex]).toBe(3);
+expect(distances[vertexAIndex][vertexDIndex]).toBe(9);
+expect(distances[vertexAIndex][vertexGIndex]).toBe(12);
+expect(distances[vertexAIndex][vertexFIndex]).toBe(11);
+
+expect(previousVertices[vertexAIndex][vertexFIndex]).toBe(vertexD);
+expect(previousVertices[vertexAIndex][vertexDIndex]).toBe(vertexB);
+expect(previousVertices[vertexAIndex][vertexBIndex]).toBe(vertexA);
+expect(previousVertices[vertexAIndex][vertexGIndex]).toBe(vertexE);
+expect(previousVertices[vertexAIndex][vertexCIndex]).toBe(vertexA);
+expect(previousVertices[vertexAIndex][vertexAIndex]).toBe(null);
+expect(previousVertices[vertexAIndex][vertexHIndex]).toBe(null);
+});
+
+it('should find minimum paths to all vertices for directed graph',()=>{
+constvertexA=newGraphVertex('A');
+constvertexB=newGraphVertex('B');
+constvertexC=newGraphVertex('C');
+constvertexD=newGraphVertex('D');
+
+constedgeAB=newGraphEdge(vertexA,vertexB,3);
+constedgeBA=newGraphEdge(vertexB,vertexA,8);
+constedgeAD=newGraphEdge(vertexA,vertexD,7);
+constedgeDA=newGraphEdge(vertexD,vertexA,2);
+constedgeBC=newGraphEdge(vertexB,vertexC,2);
+constedgeCA=newGraphEdge(vertexC,vertexA,5);
+constedgeCD=newGraphEdge(vertexC,vertexD,1);
+
+constgraph=newGraph(true);
+
+// Add vertices first just to have them in desired order.
+graph
+.addVertex(vertexA)
+.addVertex(vertexB)
+.addVertex(vertexC)
+.addVertex(vertexD);
+
+// Now, when vertices are in correct order let's add edges.
+graph
+.addEdge(edgeAB)
+.addEdge(edgeBA)
+.addEdge(edgeAD)
+.addEdge(edgeDA)
+.addEdge(edgeBC)
+.addEdge(edgeCA)
+.addEdge(edgeCD);
+
+const{ distances, previousVertices }=floydWarshall(graph);
+
+constvertices=graph.getAllVertices();
+
 constvertexAIndex=vertices.indexOf(vertexA);
-constvl=vertices.length;
-
-expect(distances[vertexAIndex][vertices.indexOf(vertexH)][vl]).toBe(Infinity);
-expect(distances[vertexAIndex][vertexAIndex][vl]).toBe(0);
-expect(distances[vertexAIndex][vertices.indexOf(vertexB)][vl]).toBe(4);
-expect(distances[vertexAIndex][vertices.indexOf(vertexE)][vl]).toBe(7);
-expect(distances[vertexAIndex][vertices.indexOf(vertexC)][vl]).toBe(3);
-expect(distances[vertexAIndex][vertices.indexOf(vertexD)][vl]).toBe(9);
-expect(distances[vertexAIndex][vertices.indexOf(vertexG)][vl]).toBe(12);
-expect(distances[vertexAIndex][vertices.indexOf(vertexF)][vl]).toBe(11);
-
-expect(previousVertices[vertexAIndex][vertices.indexOf(vertexF)][vl]).toBe(vertexD);
-expect(previousVertices[vertexAIndex][vertices.indexOf(vertexD)][vl]).toBe(vertexB);
-expect(previousVertices[vertexAIndex][vertices.indexOf(vertexB)][vl]).toBe(vertexA);
-expect(previousVertices[vertexAIndex][vertices.indexOf(vertexG)][vl]).toBe(vertexE);
-expect(previousVertices[vertexAIndex][vertices.indexOf(vertexC)][vl]).toBe(vertexA);
-expect(previousVertices[vertexAIndex][vertexAIndex][vl]).toBe(null);
-expect(previousVertices[vertexAIndex][vertices.indexOf(vertexH)][vl]).toBe(null);
+constvertexBIndex=vertices.indexOf(vertexB);
+constvertexCIndex=vertices.indexOf(vertexC);
+constvertexDIndex=vertices.indexOf(vertexD);
+
+expect(distances[vertexAIndex][vertexAIndex]).toBe(0);
+expect(distances[vertexAIndex][vertexBIndex]).toBe(3);
+expect(distances[vertexAIndex][vertexCIndex]).toBe(5);
+expect(distances[vertexAIndex][vertexDIndex]).toBe(6);
+
+expect(distances).toEqual([
+[0,3,5,6],
+[5,0,2,3],
+[3,6,0,1],
+[2,5,7,0],
+]);
+
+expect(previousVertices[vertexAIndex][vertexDIndex]).toBe(vertexC);
+expect(previousVertices[vertexAIndex][vertexCIndex]).toBe(vertexB);
+expect(previousVertices[vertexBIndex][vertexDIndex]).toBe(vertexC);
+expect(previousVertices[vertexAIndex][vertexAIndex]).toBe(null);
+expect(previousVertices[vertexAIndex][vertexBIndex]).toBe(vertexA);
 });
 
 it('should find minimum paths to all vertices for directed graph with negative edge weights',()=>{
@@ -100,22 +168,28 @@ describe('floydWarshall', () =>{
 const{ distances, previousVertices }=floydWarshall(graph);
 
 constvertices=graph.getAllVertices();
+
+constvertexAIndex=vertices.indexOf(vertexA);
+constvertexBIndex=vertices.indexOf(vertexB);
+constvertexCIndex=vertices.indexOf(vertexC);
+constvertexDIndex=vertices.indexOf(vertexD);
+constvertexEIndex=vertices.indexOf(vertexE);
+constvertexHIndex=vertices.indexOf(vertexH);
 constvertexSIndex=vertices.indexOf(vertexS);
-constvl=vertices.length;
-
-expect(distances[vertexSIndex][vertices.indexOf(vertexH)][vl]).toBe(Infinity);
-expect(distances[vertexSIndex][vertexSIndex][vl]).toBe(0);
-expect(distances[vertexSIndex][vertices.indexOf(vertexA)][vl]).toBe(5);
-expect(distances[vertexSIndex][vertices.indexOf(vertexB)][vl]).toBe(5);
-expect(distances[vertexSIndex][vertices.indexOf(vertexC)][vl]).toBe(7);
-expect(distances[vertexSIndex][vertices.indexOf(vertexD)][vl]).toBe(9);
-expect(distances[vertexSIndex][vertices.indexOf(vertexE)][vl]).toBe(8);
-
-expect(previousVertices[vertexSIndex][vertices.indexOf(vertexH)][vl]).toBe(null);
-expect(previousVertices[vertexSIndex][vertexSIndex][vl]).toBe(null);
-expect(previousVertices[vertexSIndex][vertices.indexOf(vertexB)][vl]).toBe(vertexC);
-expect(previousVertices[vertexSIndex][vertices.indexOf(vertexC)][vl]).toBe(vertexA);
-expect(previousVertices[vertexSIndex][vertices.indexOf(vertexA)][vl]).toBe(vertexD);
-expect(previousVertices[vertexSIndex][vertices.indexOf(vertexD)][vl]).toBe(vertexE);
+
+expect(distances[vertexSIndex][vertexHIndex]).toBe(Infinity);
+expect(distances[vertexSIndex][vertexSIndex]).toBe(0);
+expect(distances[vertexSIndex][vertexAIndex]).toBe(5);
+expect(distances[vertexSIndex][vertexBIndex]).toBe(5);
+expect(distances[vertexSIndex][vertexCIndex]).toBe(7);
+expect(distances[vertexSIndex][vertexDIndex]).toBe(9);
+expect(distances[vertexSIndex][vertexEIndex]).toBe(8);
+
+expect(previousVertices[vertexSIndex][vertexHIndex]).toBe(null);
+expect(previousVertices[vertexSIndex][vertexSIndex]).toBe(null);
+expect(previousVertices[vertexSIndex][vertexBIndex]).toBe(vertexC);
+// expect(previousVertices[vertexSIndex][vertexCIndex].getKey()).toBe(vertexA.getKey());
+expect(previousVertices[vertexSIndex][vertexAIndex]).toBe(vertexD);
+expect(previousVertices[vertexSIndex][vertexDIndex]).toBe(vertexE);
 });
 });

src/algorithms/graph/floyd-warshall/floydWarshall.js

@@ -1,60 +1,72 @@
+/**
+ * @param{Graph} graph
+ * @return{{distances: number[][], previousVertices: GraphVertex[][]}}
+ */
 exportdefaultfunctionfloydWarshall(graph){
+// Get all graph vertices.
 constvertices=graph.getAllVertices();
 
-// Three dimension matrices.
-constdistances=[];
-constpreviousVertices=[];
+// Init previous vertices matrix with nulls meaning that there are no
+// previous vertices exist that will give us shortest path.
+constpreviousVertices=Array(vertices.length).fill(null).map(()=>{
+returnArray(vertices.length).fill(null);
+});
 
-// There are k vertices, loop from 0 to k.
-for(letk=0;k<=vertices.length;k+=1){
-// Path starts from vertex i.
-vertices.forEach((vertex,i)=>{
-if(k===0){
-distances[i]=[];
-previousVertices[i]=[];
-}
+// Init distances matrix with Infinities meaning there are no paths
+// between vertices exist so far.
+constdistances=Array(vertices.length).fill(null).map(()=>{
+returnArray(vertices.length).fill(Infinity);
+});
 
-// Path ends to vertex j.
-vertices.forEach((endVertex,j)=>{
-if(k===0){
-// Initialize distance and previousVertices array
-distances[i][j]=[];
-previousVertices[i][j]=[];
+// Init distance matrix with the distance we already now (from existing edges).
+// And also init previous vertices from the edges.
+vertices.forEach((startVertex,startIndex)=>{
+vertices.forEach((endVertex,endIndex)=>{
+if(startVertex===endVertex){
+// Distance to the vertex itself is 0.
+distances[startIndex][endIndex]=0;
+}else{
+// Find edge between the start and end vertices.
+constedge=graph.findEdge(startVertex,endVertex);
 
-if(vertex===endVertex){
-// Distance to self as 0
-distances[i][j][k]=0;
-// Previous vertex to self as null
-previousVertices[i][j][k]=null;
-}else{
-constedge=graph.findEdge(vertex,endVertex);
-if(edge){
-// There is an edge from vertex i to vertex j.
-// Save distance and previous vertex.
-distances[i][j][k]=edge.weight;
-previousVertices[i][j][k]=vertex;
-}else{
-distances[i][j][k]=Infinity;
-previousVertices[i][j][k]=null;
-}
-}
+if(edge){
+// There is an edge from vertex with startIndex to vertex with endIndex.
+// Save distance and previous vertex.
+distances[startIndex][endIndex]=edge.weight;
+previousVertices[startIndex][endIndex]=startVertex;
 }else{
-// Compare distance from i to j, with distance from i to k - 1 and then from k - 1 to j.
-// Save the shortest distance and previous vertex
-// distance[i][j][k] = min( distance[i][k - 1][k - 1], distance[k - 1][j][k - 1] )
-if(distances[i][j][k-1]>distances[i][k-1][k-1]+distances[k-1][j][k-1]){
-distances[i][j][k]=distances[i][k-1][k-1]+distances[k-1][j][k-1];
-previousVertices[i][j][k]=previousVertices[k-1][j][k-1];
-}else{
-distances[i][j][k]=distances[i][j][k-1];
-previousVertices[i][j][k]=previousVertices[i][j][k-1];
-}
+distances[startIndex][endIndex]=Infinity;
+}
+}
+});
+});
+
+// Now let's go to the core of the algorithm.
+// Let's all pair of vertices (from start to end ones) and try to check if there
+// is a shorter path exists between them via middle vertex. Middle vertex may also
+// be one of the graph vertices. As you may see now we're going to have three
+// loops over all graph vertices: for start, end and middle vertices.
+vertices.forEach((middleVertex,middleIndex)=>{
+// Path starts from startVertex with startIndex.
+vertices.forEach((startVertex,startIndex)=>{
+// Path ends to endVertex with endIndex.
+vertices.forEach((endVertex,endIndex)=>{
+// Compare existing distance from startVertex to endVertex, with distance
+// from startVertex to endVertex but via middleVertex.
+// Save the shortest distance and previous vertex that allows
+// us to have this shortest distance.
+constdistViaMiddle=distances[startIndex][middleIndex]+distances[middleIndex][endIndex];
+
+if(distances[startIndex][endIndex]>distViaMiddle){
+// We've found a shortest pass via middle vertex.
+distances[startIndex][endIndex]=distViaMiddle;
+previousVertices[startIndex][endIndex]=middleVertex;
 }
 });
 });
-}
+});
 
-// Shortest distance from x to y: distance[x][y][k]
-// Previous vertex when shortest distance from x to y: previousVertices[x][y][k]
+// Shortest distance from x to y: distance[x][y].
+// Previous vertex of shortest path from x to y: previousVertices[x][y].
 return{ distances, previousVertices };
 }