public void ShortestPathTo_FindShortestPath_WhenThereIsPossibleMultiplePaths(ShortestPathAlgorithm alg) { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddVertex("d"); graph.AddEdge("a", "b", 1); graph.AddEdge("b", "c", 1); graph.AddEdge("c", "a", 1); graph.AddEdge("c", "d", 1); graph.AddEdge("b", "d", 1); var algorithm = CreateAlgorithm(alg, graph, "a"); var result = algorithm.ShortestPathTo("d"); Assert.NotNull(result); Assert.Equal(3, result.Count()); Assert.Contains("a", result); Assert.Contains("b", result); Assert.Contains("d", result); Assert.Equal(2, algorithm.DistanceTo("d")); }
public void FindShortestPath_DeadNodes() { Dictionary <string, List <string> > graph = new Dictionary <string, List <string> >(); graph.Add("a", new List <string>() { "c", "b", "g" }); graph.Add("b", new List <string>() { "a", "g" }); graph.Add("c", new List <string>() { "a", "d" }); graph.Add("d", new List <string>() { "c", "e", "i" }); graph.Add("e", new List <string>() { "d", "g", "h", "i" }); graph.Add("f", new List <string>() { "g" }); graph.Add("g", new List <string>() { "a", "f", "e" }); graph.Add("h", new List <string>() { "e" }); graph.Add("i", new List <string>() { "d", "e" }); //should be ignored graph.Add("j", new List <string>()); graph.Add("k", new List <string>()); ShortestPathAlgorithm shortestPathAlgorithm = new ShortestPathAlgorithm(); List <string> result; bool found = shortestPathAlgorithm.TryFindShortestPath(graph, "a", "h", out result); string[] resultArray = result.ToArray(); Assert.IsTrue(found); Assert.AreEqual(4, resultArray.Count()); Assert.AreEqual("a", resultArray[0]); Assert.AreEqual("g", resultArray[1]); Assert.AreEqual("e", resultArray[2]); Assert.AreEqual("h", resultArray[3]); }
public void Constructor_Throw_WhenSourceIsNotPartOfGraph(ShortestPathAlgorithm alg) { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddVertex("d"); Assert.Throws <ArgumentException>(() => CreateAlgorithm(alg, graph, "x")); }
private static IShortestPath <string> CreateAlgorithm(ShortestPathAlgorithm algEnum, DirectedWeightedSparseGraph <string> Graph, string Source) { switch (algEnum) { case ShortestPathAlgorithm.DIJKSTRA: return(new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(Graph, Source)); case ShortestPathAlgorithm.BELLMAN_FORD: return(new BellmanFordShortestPaths <DirectedWeightedSparseGraph <string>, string>(Graph, Source)); case ShortestPathAlgorithm.BREADTH_FIRST: return(new BreadthFirstShortestPaths <string>(Graph, Source)); } throw new ArgumentException("unkown algorithm: " + algEnum); }
public void FindShortestPath_ImpossiblePath_startAtDeadEnd() { Dictionary <string, List <string> > graph = new Dictionary <string, List <string> >(); graph.Add("a", new List <string>() { "c", "b", "g" }); graph.Add("b", new List <string>() { "a", "g" }); graph.Add("c", new List <string>() { "a", "d" }); graph.Add("d", new List <string>() { "c", "e", "i" }); graph.Add("e", new List <string>() { "d", "g", "h", "i" }); graph.Add("f", new List <string>() { "g" }); graph.Add("g", new List <string>() { "a", "f", "e" }); graph.Add("h", new List <string>() { "e" }); graph.Add("i", new List <string>() { "d", "e" }); //should be ignored graph.Add("j", new List <string>()); graph.Add("k", new List <string>()); ShortestPathAlgorithm shortestPathAlgorithm = new ShortestPathAlgorithm(); List <string> result; bool found = shortestPathAlgorithm.TryFindShortestPath(graph, "k", "a", out result); string[] resultArray = result.ToArray(); Assert.IsFalse(found); }
public void ShortestPathTo_Throw_WhenDestinationIsNotInGraph(ShortestPathAlgorithm alg) { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddVertex("d"); var algorithm = CreateAlgorithm(alg, graph, "a"); Assert.Throws <ArgumentException>(() => algorithm.ShortestPathTo("z")); }
public void DistanceTo_Throw_WhenVertexIsNotInGraph(ShortestPathAlgorithm alg) { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddEdge("a", "b", 1); var algorithm = CreateAlgorithm(alg, graph, "a"); Assert.Throws <ArgumentException>(() => algorithm.DistanceTo("z")); }
public void DistanceTo_ReturnInfinity_WhenVertexIsNotAchievable(ShortestPathAlgorithm alg) { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddEdge("a", "b", 1); var algorithm = CreateAlgorithm(alg, graph, "a"); Assert.Equal(long.MaxValue, algorithm.DistanceTo("c")); }
public void HasPathTo_ReturnFalse_WhenVertexIsNotAchievable(ShortestPathAlgorithm alg) { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddEdge("a", "b", 1); var algorithm = CreateAlgorithm(alg, graph, "a"); Assert.False(algorithm.HasPathTo("c")); }
public void Finds_shortest_paths_in_complex_maps(Map map, string startId, string endId, string expectedPath, int expectedDistance) { var shortestPath = new ShortestPathAlgorithm(); Path path = shortestPath.Find(map, startId, endId); if (expectedPath == null) { Assert.Null(path); } else { Assert.Equal(expectedPath, string.Join(',', path.NodeIds)); Assert.Equal(expectedDistance, path.Distance); } }
public void Finds_shortest_path_between_two_points_with_one_edge() { Map map = new Map("t1", new Node("a"), new Node("b")); map.AddEdge("a", "b", 1); var shortestPath = new ShortestPathAlgorithm(); Path p = shortestPath.Find(map, "a", "b"); Assert.Equal(2, p.NodeIds.Length); Assert.Equal("a", p.NodeIds.ElementAt(0)); Assert.Equal("b", p.NodeIds.ElementAt(1)); Assert.Equal(1, p.Distance); }
public void TestWith8Nodes() { // https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/ var node0 = new Node("0"); var node1 = new Node("1"); var node2 = new Node("2"); var node3 = new Node("3"); var node4 = new Node("4"); var node5 = new Node("5"); var node6 = new Node("6"); var node7 = new Node("7"); var node8 = new Node("8"); AddTwoWayConnection(node0, node1, 4); AddTwoWayConnection(node0, node7, 8); AddTwoWayConnection(node1, node7, 11); AddTwoWayConnection(node1, node2, 8); AddTwoWayConnection(node2, node5, 4); AddTwoWayConnection(node2, node8, 2); AddTwoWayConnection(node2, node3, 7); AddTwoWayConnection(node3, node5, 14); AddTwoWayConnection(node3, node4, 9); AddTwoWayConnection(node4, node5, 10); AddTwoWayConnection(node5, node6, 2); AddTwoWayConnection(node6, node8, 6); AddTwoWayConnection(node6, node7, 1); AddTwoWayConnection(node7, node8, 7); var nodes = new List <Node> { node0, node1, node2, node3, node4, node5, node6, node7, node8 }; var algorithm = new ShortestPathAlgorithm(nodes); var result = algorithm.Run(node0); result.Should().NotBeNull(); Print(result); }
public void ShortestPathTo_ReturnNull_WhenDestinationIsNotAchievable(ShortestPathAlgorithm alg) { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddVertex("d"); graph.AddEdge("a", "b", 1); graph.AddEdge("b", "c", 1); graph.AddEdge("c", "a", 1); var algorithm = CreateAlgorithm(alg, graph, "a"); Assert.Null(algorithm.ShortestPathTo("d")); }
public void ShortestPathTo_ReturnSingleVertex_WhenDestinationIsSameAsSource(ShortestPathAlgorithm alg) { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddVertex("d"); graph.AddEdge("a", "b", 1); graph.AddEdge("b", "c", 1); graph.AddEdge("c", "a", 1); var algorithm = CreateAlgorithm(alg, graph, "a"); var result = algorithm.ShortestPathTo("a"); Assert.NotNull(result); Assert.Single(result); Assert.Equal("a", result.Single()); }
public void TestFromAtoBtoCtoD() { var nodeA = new Node("A"); var nodeB = new Node("B"); var nodeC = new Node("C"); var nodeD = new Node("D"); nodeA.AddConnection(nodeB, 10); nodeB.AddConnection(nodeC, 10); nodeC.AddConnection(nodeD, 10); var nodes = new List <Node> { nodeA, nodeB, nodeC, nodeD }; var algorithm = new ShortestPathAlgorithm(nodes); var result = algorithm.Run(nodeA); result.Should().NotBeNull(); Print(result); }
public void ShortestPathTo_FindShortestPath_WhenEdgeHaveDifferentWeight(ShortestPathAlgorithm alg) { var vertices = new[] { "r", "s", "t", "x", "y", "z" }; var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertices(vertices); graph.AddEdge("r", "s", 7); graph.AddEdge("r", "t", 6); graph.AddEdge("s", "t", 5); graph.AddEdge("s", "x", 9); graph.AddEdge("t", "x", 10); graph.AddEdge("t", "y", 7); graph.AddEdge("t", "z", 5); graph.AddEdge("x", "y", 2); graph.AddEdge("x", "z", 4); graph.AddEdge("y", "z", 1); var algorithm = CreateAlgorithm(alg, graph, "s"); var shortestToZ = algorithm.ShortestPathTo("z"); Assert.NotNull(shortestToZ); Assert.Equal(3, shortestToZ.Count()); Assert.Contains("s", shortestToZ); Assert.Contains("t", shortestToZ); Assert.Contains("z", shortestToZ); Assert.Equal(10, algorithm.DistanceTo("z")); var shortestToY = algorithm.ShortestPathTo("y"); Assert.NotNull(shortestToY); Assert.Equal(3, shortestToY.Count()); Assert.Contains("s", shortestToY); Assert.Contains("x", shortestToY); Assert.Contains("y", shortestToY); Assert.Equal(11, algorithm.DistanceTo("y")); }
private void TestShortestPathsAlgorithm(IWeightedGraph <int, double> graph, IVertex <int> source, IVertex <int> target, double pathCosts, ShortestPathAlgorithm algorithm, double precision = 0.1) { IWeightedGraph <int, double> shortestPath = null; switch (algorithm) { case ShortestPathAlgorithm.Dijkstra: shortestPath = Dijkstra.FindShortestPath(graph, source, target, 0.0, double.MaxValue, (x, y) => x + y); break; case ShortestPathAlgorithm.BellmanFordMoore: shortestPath = BellmanFordMoore.FindShortestPath(graph, source, target, 0.0, double.MaxValue, (x, y) => x + y); break; default: throw new NotSupportedException($"Testing shortest path for the {algorithm} algorithm is currently not supported."); } AssertDoublesNearlyEqual(pathCosts, shortestPath.GetAllEdges().Sum(e => e.Weight), precision); }
public void Constructor_Throw_WhenAnyEdgeWeightIsLessThanZeroShortestPathAlgorithm(ShortestPathAlgorithm alg) { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddEdge("a", "b", -1); Assert.Throws <ArgumentException>(() => CreateAlgorithm(alg, graph, "a")); }
public void Constructor_Throw_WhenSourceVertexIsNull(ShortestPathAlgorithm alg) { var graph = new DirectedWeightedSparseGraph <string>(); Assert.Throws <ArgumentNullException>(() => CreateAlgorithm(alg, graph, null)); }
public void Constructor_Throw_WhenGraphInNull(ShortestPathAlgorithm alg) { Assert.Throws <ArgumentNullException>(() => CreateAlgorithm(alg, null, "vertex")); }