dist-javascript-algorithms-and-data-structures
Version:
Algorithms and data-structures implemented on JavaScript
155 lines (143 loc) • 8.81 kB
JavaScript
"use strict";
var _GraphVertex = _interopRequireDefault(require("../../../../data-structures/graph/GraphVertex"));
var _GraphEdge = _interopRequireDefault(require("../../../../data-structures/graph/GraphEdge"));
var _Graph = _interopRequireDefault(require("../../../../data-structures/graph/Graph"));
var _floydWarshall = _interopRequireDefault(require("../floydWarshall"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
describe('floydWarshall', () => {
it('should find minimum paths to all vertices for undirected graph', () => {
const vertexA = new _GraphVertex.default('A');
const vertexB = new _GraphVertex.default('B');
const vertexC = new _GraphVertex.default('C');
const vertexD = new _GraphVertex.default('D');
const vertexE = new _GraphVertex.default('E');
const vertexF = new _GraphVertex.default('F');
const vertexG = new _GraphVertex.default('G');
const vertexH = new _GraphVertex.default('H');
const edgeAB = new _GraphEdge.default(vertexA, vertexB, 4);
const edgeAE = new _GraphEdge.default(vertexA, vertexE, 7);
const edgeAC = new _GraphEdge.default(vertexA, vertexC, 3);
const edgeBC = new _GraphEdge.default(vertexB, vertexC, 6);
const edgeBD = new _GraphEdge.default(vertexB, vertexD, 5);
const edgeEC = new _GraphEdge.default(vertexE, vertexC, 8);
const edgeED = new _GraphEdge.default(vertexE, vertexD, 2);
const edgeDC = new _GraphEdge.default(vertexD, vertexC, 11);
const edgeDG = new _GraphEdge.default(vertexD, vertexG, 10);
const edgeDF = new _GraphEdge.default(vertexD, vertexF, 2);
const edgeFG = new _GraphEdge.default(vertexF, vertexG, 3);
const edgeEG = new _GraphEdge.default(vertexE, vertexG, 5);
const graph = new _Graph.default(); // Add vertices first just to have them in desired order.
graph.addVertex(vertexA).addVertex(vertexB).addVertex(vertexC).addVertex(vertexD).addVertex(vertexE).addVertex(vertexF).addVertex(vertexG).addVertex(vertexH); // Now, when vertices are in correct order let's add edges.
graph.addEdge(edgeAB).addEdge(edgeAE).addEdge(edgeAC).addEdge(edgeBC).addEdge(edgeBD).addEdge(edgeEC).addEdge(edgeED).addEdge(edgeDC).addEdge(edgeDG).addEdge(edgeDF).addEdge(edgeFG).addEdge(edgeEG);
const {
distances,
nextVertices
} = (0, _floydWarshall.default)(graph);
const vertices = graph.getAllVertices();
const vertexAIndex = vertices.indexOf(vertexA);
const vertexBIndex = vertices.indexOf(vertexB);
const vertexCIndex = vertices.indexOf(vertexC);
const vertexDIndex = vertices.indexOf(vertexD);
const vertexEIndex = vertices.indexOf(vertexE);
const vertexFIndex = vertices.indexOf(vertexF);
const vertexGIndex = vertices.indexOf(vertexG);
const vertexHIndex = 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(nextVertices[vertexAIndex][vertexFIndex]).toBe(vertexD);
expect(nextVertices[vertexAIndex][vertexDIndex]).toBe(vertexB);
expect(nextVertices[vertexAIndex][vertexBIndex]).toBe(vertexA);
expect(nextVertices[vertexAIndex][vertexGIndex]).toBe(vertexE);
expect(nextVertices[vertexAIndex][vertexCIndex]).toBe(vertexA);
expect(nextVertices[vertexAIndex][vertexAIndex]).toBe(null);
expect(nextVertices[vertexAIndex][vertexHIndex]).toBe(null);
});
it('should find minimum paths to all vertices for directed graph', () => {
const vertexA = new _GraphVertex.default('A');
const vertexB = new _GraphVertex.default('B');
const vertexC = new _GraphVertex.default('C');
const vertexD = new _GraphVertex.default('D');
const edgeAB = new _GraphEdge.default(vertexA, vertexB, 3);
const edgeBA = new _GraphEdge.default(vertexB, vertexA, 8);
const edgeAD = new _GraphEdge.default(vertexA, vertexD, 7);
const edgeDA = new _GraphEdge.default(vertexD, vertexA, 2);
const edgeBC = new _GraphEdge.default(vertexB, vertexC, 2);
const edgeCA = new _GraphEdge.default(vertexC, vertexA, 5);
const edgeCD = new _GraphEdge.default(vertexC, vertexD, 1);
const graph = new _Graph.default(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,
nextVertices
} = (0, _floydWarshall.default)(graph);
const vertices = graph.getAllVertices();
const vertexAIndex = vertices.indexOf(vertexA);
const vertexBIndex = vertices.indexOf(vertexB);
const vertexCIndex = vertices.indexOf(vertexC);
const vertexDIndex = 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(nextVertices[vertexAIndex][vertexDIndex]).toBe(vertexC);
expect(nextVertices[vertexAIndex][vertexCIndex]).toBe(vertexB);
expect(nextVertices[vertexBIndex][vertexDIndex]).toBe(vertexC);
expect(nextVertices[vertexAIndex][vertexAIndex]).toBe(null);
expect(nextVertices[vertexAIndex][vertexBIndex]).toBe(vertexA);
});
it('should find minimum paths to all vertices for directed graph with negative edge weights', () => {
const vertexA = new _GraphVertex.default('A');
const vertexB = new _GraphVertex.default('B');
const vertexC = new _GraphVertex.default('C');
const vertexD = new _GraphVertex.default('D');
const vertexE = new _GraphVertex.default('E');
const vertexF = new _GraphVertex.default('F');
const vertexG = new _GraphVertex.default('G');
const edgeFE = new _GraphEdge.default(vertexF, vertexE, 8);
const edgeFA = new _GraphEdge.default(vertexF, vertexA, 10);
const edgeED = new _GraphEdge.default(vertexE, vertexD, 1);
const edgeDA = new _GraphEdge.default(vertexD, vertexA, -4);
const edgeDC = new _GraphEdge.default(vertexD, vertexC, -1);
const edgeAC = new _GraphEdge.default(vertexA, vertexC, 2);
const edgeCB = new _GraphEdge.default(vertexC, vertexB, -2);
const edgeBA = new _GraphEdge.default(vertexB, vertexA, 1);
const graph = new _Graph.default(true); // Add vertices first just to have them in desired order.
graph.addVertex(vertexA).addVertex(vertexB).addVertex(vertexC).addVertex(vertexD).addVertex(vertexE).addVertex(vertexF).addVertex(vertexG); // Now, when vertices are in correct order let's add edges.
graph.addEdge(edgeFE).addEdge(edgeFA).addEdge(edgeED).addEdge(edgeDA).addEdge(edgeDC).addEdge(edgeAC).addEdge(edgeCB).addEdge(edgeBA);
const {
distances,
nextVertices
} = (0, _floydWarshall.default)(graph);
const vertices = graph.getAllVertices();
const vertexAIndex = vertices.indexOf(vertexA);
const vertexBIndex = vertices.indexOf(vertexB);
const vertexCIndex = vertices.indexOf(vertexC);
const vertexDIndex = vertices.indexOf(vertexD);
const vertexEIndex = vertices.indexOf(vertexE);
const vertexGIndex = vertices.indexOf(vertexG);
const vertexFIndex = vertices.indexOf(vertexF);
expect(distances[vertexFIndex][vertexGIndex]).toBe(Infinity);
expect(distances[vertexFIndex][vertexFIndex]).toBe(0);
expect(distances[vertexFIndex][vertexAIndex]).toBe(5);
expect(distances[vertexFIndex][vertexBIndex]).toBe(5);
expect(distances[vertexFIndex][vertexCIndex]).toBe(7);
expect(distances[vertexFIndex][vertexDIndex]).toBe(9);
expect(distances[vertexFIndex][vertexEIndex]).toBe(8);
expect(nextVertices[vertexFIndex][vertexGIndex]).toBe(null);
expect(nextVertices[vertexFIndex][vertexFIndex]).toBe(null);
expect(nextVertices[vertexAIndex][vertexBIndex]).toBe(vertexC);
expect(nextVertices[vertexAIndex][vertexCIndex]).toBe(vertexA);
expect(nextVertices[vertexFIndex][vertexBIndex]).toBe(vertexE);
expect(nextVertices[vertexEIndex][vertexBIndex]).toBe(vertexD);
expect(nextVertices[vertexDIndex][vertexBIndex]).toBe(vertexC);
expect(nextVertices[vertexCIndex][vertexBIndex]).toBe(vertexC);
});
});