public void DoTest() { DirectedWeightedSparseGraph <string> graph = new DirectedWeightedSparseGraph <string>(); // Add vertices var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" }; graph.AddVertices(verticesSet1); // Add edges graph.AddEdge("a", "s", 1); graph.AddEdge("a", "z", 1); graph.AddEdge("s", "x", 1); graph.AddEdge("x", "d", 1); graph.AddEdge("x", "c", 1); graph.AddEdge("d", "f", 1); graph.AddEdge("d", "c", 1); graph.AddEdge("c", "f", 1); graph.AddEdge("c", "v", 1); graph.AddEdge("v", "f", 1); // Print the nodes in graph Console.WriteLine(" [*] DFS PrintAll: "); DepthFirstSearcher.PrintAll(graph, "a"); Console.WriteLine("\r\n"); var list = DepthFirstSearcher.FindAllPaths(graph, "a", "f"); foreach (var path in list) { Console.WriteLine(string.Join(",", path)); } Assert.AreEqual(5, list.Count); }
public void ShortestPathTo_FindShortestPath_WhenThereIsPossibleMultiplePaths() { 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 dijkstra = new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "a"); var result = dijkstra.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, dijkstra.DistanceTo("d")); }
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 Constructor_Throw_WhenSourceIsNotPartOfGraph() { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddVertex("d"); Assert.Throws <ArgumentException>(() => new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "x")); }
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")); }
public void Constructor_Throw_WhenAnyEdgeWeightIsLessThanZero() { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddEdge("a", "b", -1); Assert.Throws <ArgumentException>(() => new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "a")); }
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 ShortestPathTo_Throw_WhenDestinationIsNotInGraph() { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddVertex("d"); var dijkstra = new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "a"); Assert.Throws <ArgumentException>(() => dijkstra.ShortestPathTo("z")); }
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_ReturnInfinity_WhenVertexIsNotAchievable() { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddEdge("a", "b", 1); var dijkstra = new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "a"); Assert.Equal(long.MaxValue, dijkstra.DistanceTo("c")); }
public void HasPathTo_ReturnFalse_WhenVertexIsNotAchievable() { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddEdge("a", "b", 1); var dijkstra = new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "a"); Assert.False(dijkstra.HasPathTo("c")); }
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 DistanceTo_Throw_WhenVertexIsNotInGraph() { var graph = new DirectedWeightedSparseGraph <string>(); graph.AddVertex("a"); graph.AddVertex("b"); graph.AddVertex("c"); graph.AddEdge("a", "b", 1); var dijkstra = new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "a"); Assert.Throws <ArgumentException>(() => dijkstra.DistanceTo("z")); }
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 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_ReturnNull_WhenDestinationIsNotAchievable() { 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 dijkstra = new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "a"); Assert.Null(dijkstra.ShortestPathTo("d")); }
public void ShortestPathTo_ReturnSingleVertex_WhenDestinationIsSameAsSource() { 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 dijkstra = new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "a"); var result = dijkstra.ShortestPathTo("a"); Assert.NotNull(result); Assert.Single(result); Assert.Equal("a", result.Single()); }
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 TravelPath(DirectedWeightedSparseGraph <TravelHyperNode> graph, IEnumerable <TravelHyperNode> nodes) { StartStation = null; TotalTime = -1; ReservationTime = -1; Price = -1; ReservationArc = null; _nodepath = nodes.ToList(); for (int i = 0; i < _nodepath.Count - 1; i++) { if (_nodepath[i].Price == 0 && _nodepath[i + 1].Price != 0) { StartStation = _nodepath[i].Station; ReservationTime = Convert.ToInt32(_nodepath[i].Time); Price = _nodepath[i + 1].Price; ReservationArc = graph.GetEdge(_nodepath[i], _nodepath[i + 1]); } } }
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")); }
public void ShortestPathTo_FindShortestPath_WhenEdgeHaveDifferentWeight() { 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 dijkstra = new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "s"); var shortestToZ = dijkstra.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, dijkstra.DistanceTo("z")); var shortestToY = dijkstra.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, dijkstra.DistanceTo("y")); }
public void Constructor_Throw_WhenSourceVertexIsNull(ShortestPathAlgorithm alg) { var graph = new DirectedWeightedSparseGraph <string>(); Assert.Throws <ArgumentNullException>(() => CreateAlgorithm(alg, graph, null)); }
public static void DoTest() { var graph = new DirectedWeightedSparseGraph<string>(); var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" }; graph.AddVertices(verticesSet1); graph.AddEdge("a", "s", 1); graph.AddEdge("a", "z", 2); graph.AddEdge("s", "x", 3); graph.AddEdge("x", "d", 1); graph.AddEdge("x", "c", 2); graph.AddEdge("x", "a", 3); graph.AddEdge("d", "f", 1); graph.AddEdge("d", "c", 2); graph.AddEdge("d", "s", 3); graph.AddEdge("c", "f", 1); graph.AddEdge("c", "v", 2); graph.AddEdge("c", "d", 3); graph.AddEdge("v", "f", 1); graph.AddEdge("f", "c", 2); var allEdges = graph.Edges.ToList(); Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count."); Debug.Assert(graph.EdgesCount == 14, "Wrong edges count."); Debug.Assert(graph.EdgesCount == allEdges.Count, "Wrong edges count."); Debug.Assert(graph.OutgoingEdges("a").ToList().Count == 2, "Wrong outgoing edges from 'a'."); Debug.Assert(graph.OutgoingEdges("s").ToList().Count == 1, "Wrong outgoing edges from 's'."); Debug.Assert(graph.OutgoingEdges("d").ToList().Count == 3, "Wrong outgoing edges from 'd'."); Debug.Assert(graph.OutgoingEdges("x").ToList().Count == 3, "Wrong outgoing edges from 'x'."); Debug.Assert(graph.OutgoingEdges("c").ToList().Count == 3, "Wrong outgoing edges from 'c'."); Debug.Assert(graph.OutgoingEdges("v").ToList().Count == 1, "Wrong outgoing edges from 'v'."); Debug.Assert(graph.OutgoingEdges("f").ToList().Count == 1, "Wrong outgoing edges from 'f'."); Debug.Assert(graph.OutgoingEdges("z").ToList().Count == 0, "Wrong outgoing edges from 'z'."); Debug.Assert(graph.IncomingEdges("a").ToList().Count == 1, "Wrong incoming edges from 'a'."); Debug.Assert(graph.IncomingEdges("s").ToList().Count == 2, "Wrong incoming edges from 's'."); Debug.Assert(graph.IncomingEdges("d").ToList().Count == 2, "Wrong incoming edges from 'd'."); Debug.Assert(graph.IncomingEdges("x").ToList().Count == 1, "Wrong incoming edges from 'x'."); Debug.Assert(graph.IncomingEdges("c").ToList().Count == 3, "Wrong incoming edges from 'c'."); Debug.Assert(graph.IncomingEdges("v").ToList().Count == 1, "Wrong incoming edges from 'v'."); Debug.Assert(graph.IncomingEdges("f").ToList().Count == 3, "Wrong incoming edges from 'f'."); Debug.Assert(graph.IncomingEdges("z").ToList().Count == 1, "Wrong incoming edges from 'z'."); Console.WriteLine("[*] Directed Weighted Sparse Graph:"); Console.WriteLine("Graph nodes and edges:"); Console.WriteLine(graph.ToReadable() + "\r\n"); // ASSERT RANDOMLY SELECTED EDGES var f_to_c = graph.HasEdge("f", "c"); var f_to_c_weight = graph.GetEdgeWeight("f", "c"); Debug.Assert(f_to_c == true, "Edge f->c doesn't exist."); Debug.Assert(f_to_c_weight == 2, "Edge f->c must have a weight of 2."); Console.WriteLine("Is there an edge from f to c? " + f_to_c + ". If yes it's weight is: " + f_to_c_weight + "."); // ASSERT RANDOMLY SELECTED EDGES var d_to_s = graph.HasEdge("d", "s"); var d_to_s_weight = graph.GetEdgeWeight("d", "s"); Debug.Assert(d_to_s == true, "Edge d->s doesn't exist."); Debug.Assert(d_to_s_weight == 3, "Edge d->s must have a weight of 3."); Console.WriteLine("Is there an edge from d to d? " + d_to_s + ". If yes it's weight is: " + d_to_s_weight + "."); Console.WriteLine(); // TRY ADDING DUPLICATE EDGES BUT WITH DIFFERENT WEIGHTS var add_d_to_s_status = graph.AddEdge("d", "s", 6); Debug.Assert(add_d_to_s_status == false, "Error! Added a duplicate edge."); var add_c_to_f_status = graph.AddEdge("c", "f", 12); Debug.Assert(add_c_to_f_status == false, "Error! Added a duplicate edge."); var add_s_to_x_status = graph.AddEdge("s", "x", 123); Debug.Assert(add_s_to_x_status == false, "Error! Added a duplicate edge."); var add_x_to_d_status = graph.AddEdge("x", "d", 34); Debug.Assert(add_x_to_d_status == false, "Error! Added a duplicate edge."); // TEST DELETING EDGES graph.RemoveEdge("d", "c"); Debug.Assert(graph.HasEdge("d", "c") == false, "Error! The edge d->c was deleted."); graph.RemoveEdge("c", "v"); Debug.Assert(graph.HasEdge("c", "v") == false, "Error! The edge c->v was deleted."); graph.RemoveEdge("a", "z"); Debug.Assert(graph.HasEdge("a", "z") == false, "Error! The edge a->z was deleted."); // ASSERT VERTICES AND EDGES COUNT Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count."); Debug.Assert(graph.EdgesCount == 11, "Wrong edges count."); Console.WriteLine("After removing edges (d-c), (c-v), (a-z):"); Console.WriteLine(graph.ToReadable() + "\r\n"); // TEST DELETING VERTICES graph.RemoveVertex("x"); Debug.Assert(graph.HasEdge("x", "a") == false, "Error! The edge x->a was deleted because vertex x was deleted."); // ASSERT VERTICES AND EDGES COUNT Debug.Assert(graph.VerticesCount == 7, "Wrong vertices count."); Debug.Assert(graph.EdgesCount == 7, "Wrong edges count."); Console.WriteLine("After removing node (x):"); Console.WriteLine(graph.ToReadable() + "\r\n"); graph.AddVertex("x"); graph.AddEdge("s", "x", 3); graph.AddEdge("x", "d", 1); graph.AddEdge("x", "c", 2); graph.AddEdge("x", "a", 3); graph.AddEdge("d", "c", 2); graph.AddEdge("c", "v", 2); graph.AddEdge("a", "z", 2); Console.WriteLine("Re-added the deleted vertices and edges to the graph."); Console.WriteLine(graph.ToReadable() + "\r\n"); // BFS from A Console.WriteLine("Walk the graph using BFS from A:"); var bfsWalk = graph.BreadthFirstWalk("a"); // output: (s) (a) (x) (z) (d) (c) (f) (v) foreach (var node in bfsWalk) Console.Write(String.Format("({0})", node)); Console.WriteLine("\r\n"); // DFS from A Console.WriteLine("Walk the graph using DFS from A:"); var dfsWalk = graph.DepthFirstWalk("a"); // output: (s) (a) (x) (z) (d) (c) (f) (v) foreach (var node in dfsWalk) Console.Write(String.Format("({0})", node)); Console.WriteLine("\r\n"); // BFS from F Console.WriteLine("Walk the graph using BFS from F:"); bfsWalk = graph.BreadthFirstWalk("f"); // output: (s) (a) (x) (z) (d) (c) (f) (v) foreach (var node in bfsWalk) Console.Write(String.Format("({0})", node)); Console.WriteLine("\r\n"); // DFS from F Console.WriteLine("Walk the graph using DFS from F:"); dfsWalk = graph.DepthFirstWalk("f"); // output: (s) (a) (x) (z) (d) (c) (f) (v) foreach (var node in dfsWalk) Console.Write(String.Format("({0})", node)); Console.WriteLine("\r\n"); Console.ReadLine(); /********************************************************************/ Console.WriteLine("***************************************************\r\n"); graph.Clear(); Console.WriteLine("Cleared the graph from all vertices and edges.\r\n"); var verticesSet2 = new string[] { "a", "b", "c", "d", "e", "f" }; graph.AddVertices(verticesSet2); graph.AddEdge("a", "b", 1); graph.AddEdge("a", "d", 2); graph.AddEdge("b", "e", 3); graph.AddEdge("d", "b", 1); graph.AddEdge("d", "e", 2); graph.AddEdge("e", "c", 3); graph.AddEdge("c", "f", 1); graph.AddEdge("f", "f", 1); Debug.Assert(graph.VerticesCount == 6, "Wrong vertices count."); Debug.Assert(graph.EdgesCount == 8, "Wrong edges count."); Console.WriteLine("[*] NEW Directed Weighted Sparse Graph:"); Console.WriteLine("Graph nodes and edges:"); Console.WriteLine(graph.ToReadable() + "\r\n"); Console.WriteLine("Walk the graph using DFS:"); dfsWalk = graph.DepthFirstWalk(); // output: (a) (b) (e) (d) (c) (f) foreach (var node in dfsWalk) Console.Write(String.Format("({0})", node)); Console.ReadLine(); }
public static void DoTest() { var graph = new DirectedWeightedSparseGraph <string>(); var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" }; graph.AddVertices(verticesSet1); graph.AddEdge("a", "s", 1); graph.AddEdge("a", "z", 2); graph.AddEdge("s", "x", 3); graph.AddEdge("x", "d", 1); graph.AddEdge("x", "c", 2); graph.AddEdge("x", "a", 3); graph.AddEdge("d", "f", 1); graph.AddEdge("d", "c", 2); graph.AddEdge("d", "s", 3); graph.AddEdge("c", "f", 1); graph.AddEdge("c", "v", 2); graph.AddEdge("c", "d", 3); graph.AddEdge("v", "f", 1); graph.AddEdge("f", "c", 2); var allEdges = graph.Edges.ToList(); Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count."); Debug.Assert(graph.EdgesCount == 14, "Wrong edges count."); Debug.Assert(graph.EdgesCount == allEdges.Count, "Wrong edges count."); Debug.Assert(graph.OutgoingEdges("a").ToList().Count == 2, "Wrong outgoing edges from 'a'."); Debug.Assert(graph.OutgoingEdges("s").ToList().Count == 1, "Wrong outgoing edges from 's'."); Debug.Assert(graph.OutgoingEdges("d").ToList().Count == 3, "Wrong outgoing edges from 'd'."); Debug.Assert(graph.OutgoingEdges("x").ToList().Count == 3, "Wrong outgoing edges from 'x'."); Debug.Assert(graph.OutgoingEdges("c").ToList().Count == 3, "Wrong outgoing edges from 'c'."); Debug.Assert(graph.OutgoingEdges("v").ToList().Count == 1, "Wrong outgoing edges from 'v'."); Debug.Assert(graph.OutgoingEdges("f").ToList().Count == 1, "Wrong outgoing edges from 'f'."); Debug.Assert(graph.OutgoingEdges("z").ToList().Count == 0, "Wrong outgoing edges from 'z'."); Debug.Assert(graph.IncomingEdges("a").ToList().Count == 1, "Wrong incoming edges from 'a'."); Debug.Assert(graph.IncomingEdges("s").ToList().Count == 2, "Wrong incoming edges from 's'."); Debug.Assert(graph.IncomingEdges("d").ToList().Count == 2, "Wrong incoming edges from 'd'."); Debug.Assert(graph.IncomingEdges("x").ToList().Count == 1, "Wrong incoming edges from 'x'."); Debug.Assert(graph.IncomingEdges("c").ToList().Count == 3, "Wrong incoming edges from 'c'."); Debug.Assert(graph.IncomingEdges("v").ToList().Count == 1, "Wrong incoming edges from 'v'."); Debug.Assert(graph.IncomingEdges("f").ToList().Count == 3, "Wrong incoming edges from 'f'."); Debug.Assert(graph.IncomingEdges("z").ToList().Count == 1, "Wrong incoming edges from 'z'."); Console.WriteLine("[*] Directed Weighted Sparse Graph:"); Console.WriteLine("Graph nodes and edges:"); Console.WriteLine(graph.ToReadable() + "\r\n"); // ASSERT RANDOMLY SELECTED EDGES var f_to_c = graph.HasEdge("f", "c"); var f_to_c_weight = graph.GetEdgeWeight("f", "c"); Debug.Assert(f_to_c == true, "Edge f->c doesn't exist."); Debug.Assert(f_to_c_weight == 2, "Edge f->c must have a weight of 2."); Console.WriteLine("Is there an edge from f to c? " + f_to_c + ". If yes it's weight is: " + f_to_c_weight + "."); // ASSERT RANDOMLY SELECTED EDGES var d_to_s = graph.HasEdge("d", "s"); var d_to_s_weight = graph.GetEdgeWeight("d", "s"); Debug.Assert(d_to_s == true, "Edge d->s doesn't exist."); Debug.Assert(d_to_s_weight == 3, "Edge d->s must have a weight of 3."); Console.WriteLine("Is there an edge from d to d? " + d_to_s + ". If yes it's weight is: " + d_to_s_weight + "."); Console.WriteLine(); // TRY ADDING DUPLICATE EDGES BUT WITH DIFFERENT WEIGHTS var add_d_to_s_status = graph.AddEdge("d", "s", 6); Debug.Assert(add_d_to_s_status == false, "Error! Added a duplicate edge."); var add_c_to_f_status = graph.AddEdge("c", "f", 12); Debug.Assert(add_c_to_f_status == false, "Error! Added a duplicate edge."); var add_s_to_x_status = graph.AddEdge("s", "x", 123); Debug.Assert(add_s_to_x_status == false, "Error! Added a duplicate edge."); var add_x_to_d_status = graph.AddEdge("x", "d", 34); Debug.Assert(add_x_to_d_status == false, "Error! Added a duplicate edge."); // TEST DELETING EDGES graph.RemoveEdge("d", "c"); Debug.Assert(graph.HasEdge("d", "c") == false, "Error! The edge d->c was deleted."); graph.RemoveEdge("c", "v"); Debug.Assert(graph.HasEdge("c", "v") == false, "Error! The edge c->v was deleted."); graph.RemoveEdge("a", "z"); Debug.Assert(graph.HasEdge("a", "z") == false, "Error! The edge a->z was deleted."); // ASSERT VERTICES AND EDGES COUNT Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count."); Debug.Assert(graph.EdgesCount == 11, "Wrong edges count."); Console.WriteLine("After removing edges (d-c), (c-v), (a-z):"); Console.WriteLine(graph.ToReadable() + "\r\n"); // TEST DELETING VERTICES graph.RemoveVertex("x"); Debug.Assert(graph.HasEdge("x", "a") == false, "Error! The edge x->a was deleted because vertex x was deleted."); // ASSERT VERTICES AND EDGES COUNT Debug.Assert(graph.VerticesCount == 7, "Wrong vertices count."); Debug.Assert(graph.EdgesCount == 7, "Wrong edges count."); Console.WriteLine("After removing node (x):"); Console.WriteLine(graph.ToReadable() + "\r\n"); graph.AddVertex("x"); graph.AddEdge("s", "x", 3); graph.AddEdge("x", "d", 1); graph.AddEdge("x", "c", 2); graph.AddEdge("x", "a", 3); graph.AddEdge("d", "c", 2); graph.AddEdge("c", "v", 2); graph.AddEdge("a", "z", 2); Console.WriteLine("Re-added the deleted vertices and edges to the graph."); Console.WriteLine(graph.ToReadable() + "\r\n"); // BFS from A Console.WriteLine("Walk the graph using BFS from A:"); var bfsWalk = graph.BreadthFirstWalk("a"); // output: (s) (a) (x) (z) (d) (c) (f) (v) foreach (var node in bfsWalk) { Console.Write(String.Format("({0})", node)); } Console.WriteLine("\r\n"); // DFS from A Console.WriteLine("Walk the graph using DFS from A:"); var dfsWalk = graph.DepthFirstWalk("a"); // output: (s) (a) (x) (z) (d) (c) (f) (v) foreach (var node in dfsWalk) { Console.Write(String.Format("({0})", node)); } Console.WriteLine("\r\n"); // BFS from F Console.WriteLine("Walk the graph using BFS from F:"); bfsWalk = graph.BreadthFirstWalk("f"); // output: (s) (a) (x) (z) (d) (c) (f) (v) foreach (var node in bfsWalk) { Console.Write(String.Format("({0})", node)); } Console.WriteLine("\r\n"); // DFS from F Console.WriteLine("Walk the graph using DFS from F:"); dfsWalk = graph.DepthFirstWalk("f"); // output: (s) (a) (x) (z) (d) (c) (f) (v) foreach (var node in dfsWalk) { Console.Write(String.Format("({0})", node)); } Console.WriteLine("\r\n"); Console.ReadLine(); /********************************************************************/ Console.WriteLine("***************************************************\r\n"); graph.Clear(); Console.WriteLine("Cleared the graph from all vertices and edges.\r\n"); var verticesSet2 = new string[] { "a", "b", "c", "d", "e", "f" }; graph.AddVertices(verticesSet2); graph.AddEdge("a", "b", 1); graph.AddEdge("a", "d", 2); graph.AddEdge("b", "e", 3); graph.AddEdge("d", "b", 1); graph.AddEdge("d", "e", 2); graph.AddEdge("e", "c", 3); graph.AddEdge("c", "f", 1); graph.AddEdge("f", "f", 1); Debug.Assert(graph.VerticesCount == 6, "Wrong vertices count."); Debug.Assert(graph.EdgesCount == 8, "Wrong edges count."); Console.WriteLine("[*] NEW Directed Weighted Sparse Graph:"); Console.WriteLine("Graph nodes and edges:"); Console.WriteLine(graph.ToReadable() + "\r\n"); Console.WriteLine("Walk the graph using DFS:"); dfsWalk = graph.DepthFirstWalk(); // output: (a) (b) (e) (d) (c) (f) foreach (var node in dfsWalk) { Console.Write(String.Format("({0})", node)); } Console.ReadLine(); }
public static void DoTest() { string[] V; IEnumerable<WeightedEdge<string>> E; DirectedWeightedSparseGraph<string> graph; DijkstraShortestPaths<DirectedWeightedSparseGraph<string>, string> dijkstra; // Init graph object graph = new DirectedWeightedSparseGraph<string>(); // Init V V = new string[6] { "r", "s", "t", "x", "y", "z" }; // Insert V graph.AddVertices(V); Debug.Assert(graph.VerticesCount == V.Length, "Wrong Vertices Count."); // Insert E var status = graph.AddEdge("r", "s", 7); Debug.Assert(status == true); status = graph.AddEdge("r", "t", 6); Debug.Assert(status == true); status = graph.AddEdge("s", "t", 5); Debug.Assert(status == true); status = graph.AddEdge("s", "x", 9); Debug.Assert(status == true); status = graph.AddEdge("t", "x", 10); Debug.Assert(status == true); status = graph.AddEdge("t", "y", 7); Debug.Assert(status == true); status = graph.AddEdge("t", "z", 5); Debug.Assert(status == true); status = graph.AddEdge("x", "y", 2); Debug.Assert(status == true); status = graph.AddEdge("x", "z", 4); Debug.Assert(status == true); status = graph.AddEdge("y", "z", 1); Debug.Assert(status == true); // Get E E = graph.Edges; Debug.Assert(graph.EdgesCount == 10, "Wrong Edges Count."); // // PRINT THE GRAPH Console.Write("[*] DIJKSTRA ON DIRECTED WEIGHTED GRAPH - TEST 01:\r\n"); Console.WriteLine("Graph representation:"); Console.WriteLine(graph.ToReadable() + "\r\n"); // Init DIJKSTRA dijkstra = new DijkstraShortestPaths<DirectedWeightedSparseGraph<string>, string>(graph, "s"); Debug.Assert(dijkstra.HasPathTo("r") == false); Debug.Assert(dijkstra.HasPathTo("z") == true); // Get shortest path to Z var pathToZ = string.Empty; foreach (var node in dijkstra.ShortestPathTo("z")) pathToZ = String.Format("{0}({1}) -> ", pathToZ, node); pathToZ = pathToZ.TrimEnd(new char[] { ' ', '-', '>' }); Console.WriteLine("Shortest path to node 'z': " + pathToZ + "\r\n"); var pathToY = string.Empty; foreach (var node in dijkstra.ShortestPathTo("y")) pathToY = String.Format("{0}({1}) -> ", pathToY, node); pathToY = pathToY.TrimEnd(new char[] { ' ', '-', '>' }); Console.WriteLine("Shortest path to node 'y': " + pathToY + "\r\n"); Console.WriteLine("*********************************************\r\n"); /***************************************************************************************/ // Clear the graph and insert new V and E to the instance graph.Clear(); V = new string[] { "A", "B", "C", "D", "E" }; // Insert new values of V graph.AddVertices(V); Debug.Assert(graph.VerticesCount == V.Length, "Wrong Vertices Count."); // Insert new value for edges status = graph.AddEdge("A", "C", 7); Debug.Assert(status == true); status = graph.AddEdge("B", "A", 19); Debug.Assert(status == true); status = graph.AddEdge("B", "C", 11); Debug.Assert(status == true); status = graph.AddEdge("C", "E", 5); Debug.Assert(status == true); status = graph.AddEdge("C", "D", 15); Debug.Assert(status == true); status = graph.AddEdge("D", "B", 4); Debug.Assert(status == true); status = graph.AddEdge("E", "D", 13); Debug.Assert(status == true); Debug.Assert(graph.EdgesCount == 7, "Wrong Edges Count."); // // PRINT THE GRAPH Console.Write("[*] DIJKSTRA ON DIRECTED WEIGHTED GRAPH - TEST 01:\r\n"); Console.WriteLine("Graph representation:"); Console.WriteLine(graph.ToReadable() + "\r\n"); // Init DIJKSTRA dijkstra = new DijkstraShortestPaths<DirectedWeightedSparseGraph<string>, string>(graph, "A"); var pathToD = string.Empty; foreach (var node in dijkstra.ShortestPathTo("D")) pathToD = String.Format("{0}({1}) -> ", pathToD, node); pathToD = pathToD.TrimEnd(new char[] { ' ', '-', '>' }); Console.WriteLine("Shortest path from 'A' to 'D': " + pathToD + "\r\n"); Console.ReadLine(); }
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 PricePath(DirectedWeightedSparseGraph <string> graph, IEnumerable <string> Strings) { _nodepath = Strings.ToList(); _graph = graph; }
public static void DoTest() { string[] V; IEnumerable<WeightedEdge<string>> E; DirectedWeightedSparseGraph<string> graph; BellmanFordShortestPaths<DirectedWeightedSparseGraph<string>, string> BellmanFord; // Init graph object graph = new DirectedWeightedSparseGraph<string>(); // Init V V = new string[6] { "r", "s", "t", "x", "y", "z" }; // Insert V graph.AddVertices(V); Debug.Assert(graph.VerticesCount == V.Length, "Wrong Vertices Count."); // Insert E var status = graph.AddEdge("r", "s", -3); Debug.Assert(status == true); status = graph.AddEdge("s", "t", 4); Debug.Assert(status == true); status = graph.AddEdge("t", "x", -1); Debug.Assert(status == true); status = graph.AddEdge("x", "y", 6); Debug.Assert(status == true); status = graph.AddEdge("y", "z", -1); Debug.Assert(status == true); status = graph.AddEdge("r", "t", 1); Debug.Assert(status == true); status = graph.AddEdge("s", "x", 7); Debug.Assert(status == true); status = graph.AddEdge("t", "y", 4); Debug.Assert(status == true); status = graph.AddEdge("t", "z", 3); Debug.Assert(status == true); status = graph.AddEdge("x", "z", 2); Debug.Assert(status == true); // NEGATIVE CYCLE (BACK-EDGE) status = graph.AddEdge("y", "t", -7); Debug.Assert(status == true); // Get E E = graph.Edges; Debug.Assert(graph.EdgesCount == 11, "Wrong Edges Count."); // // PRINT THE GRAPH Console.Write("[*] BELLMAN-FORD ON DIRECTED WEIGHTED GRAPH - TEST 01:\r\n"); Console.WriteLine("Graph representation:"); Console.WriteLine(graph.ToReadable() + "\r\n"); // WILL THROW EXCEPTION try { BellmanFord = new BellmanFordShortestPaths<DirectedWeightedSparseGraph<string>, string>(graph, "s"); } catch(Exception ex) { status = graph.RemoveEdge("y", "t"); //Debug.Assert(status == true, "Error! Edge was not deleted."); BellmanFord = new BellmanFordShortestPaths<DirectedWeightedSparseGraph<string>, string>(graph, "s"); } //Debug.Assert(graph.HasEdge("y", "t") == false, "Wrong, edge y-t must have been deleted."); Debug.Assert(BellmanFord.HasPathTo("r") == false); Debug.Assert(BellmanFord.HasPathTo("z") == true); // Get shortest path to Z var pathToZ = string.Empty; foreach (var node in BellmanFord.ShortestPathTo("z")) pathToZ = String.Format("{0}({1}) -> ", pathToZ, node); pathToZ = pathToZ.TrimEnd(new char[] { ' ', '-', '>' }); Console.WriteLine("Shortest path to node 'z': " + pathToZ + "\r\n"); var pathToY = string.Empty; foreach (var node in BellmanFord.ShortestPathTo("y")) pathToY = String.Format("{0}({1}) -> ", pathToY, node); pathToY = pathToY.TrimEnd(new char[] { ' ', '-', '>' }); Console.WriteLine("Shortest path to node 'y': " + pathToY + "\r\n"); Console.WriteLine("*********************************************\r\n"); /***************************************************************************************/ // Clear the graph and insert new V and E to the instance graph.Clear(); V = new string[] { "s", "a", "b", "c", "d" }; // Insert new values of V graph.AddVertices(V); Debug.Assert(graph.VerticesCount == V.Length, "Wrong Vertices Count."); // Insert new value for edges status = graph.AddEdge("s", "a", 1); Debug.Assert(status == true); status = graph.AddEdge("a", "b", 1); Debug.Assert(status == true); status = graph.AddEdge("b", "c", 2); Debug.Assert(status == true); status = graph.AddEdge("c", "a", -5); Debug.Assert(status == true); status = graph.AddEdge("c", "d", 2); Debug.Assert(status == true); Debug.Assert(graph.EdgesCount == 5, "Wrong Edges Count."); // PRINT THE GRAPH Console.Write("[*] BELLMAN-FORD ON DIRECTED WEIGHTED GRAPH - TEST 01:\r\n"); Console.WriteLine("Graph representation:"); Console.WriteLine(graph.ToReadable() + "\r\n"); // WILL THROW EXCEPTION try { BellmanFord = new BellmanFordShortestPaths<DirectedWeightedSparseGraph<string>, string>(graph, "b"); } catch (Exception ex) { status = graph.RemoveEdge("c", "a"); //Debug.Assert(status == true, "Error! Edge was not deleted."); BellmanFord = new BellmanFordShortestPaths<DirectedWeightedSparseGraph<string>, string>(graph, "b"); } Console.WriteLine("*********************************************\r\n"); /***************************************************************************************/ // Clear the graph and insert new V and E to the instance graph.Clear(); V = new string[] { "A", "B", "C", "D", "E" }; // Insert new values of V graph.AddVertices(V); Debug.Assert(graph.VerticesCount == V.Length, "Wrong Vertices Count."); // Insert new value for edges status = graph.AddEdge("A", "C", 7); Debug.Assert(status == true); status = graph.AddEdge("B", "A", 19); Debug.Assert(status == true); status = graph.AddEdge("B", "C", 11); Debug.Assert(status == true); status = graph.AddEdge("C", "E", 5); Debug.Assert(status == true); status = graph.AddEdge("C", "D", 15); Debug.Assert(status == true); status = graph.AddEdge("D", "B", 4); Debug.Assert(status == true); status = graph.AddEdge("E", "D", 13); Debug.Assert(status == true); Debug.Assert(graph.EdgesCount == 7, "Wrong Edges Count."); // // PRINT THE GRAPH Console.Write("[*] BELLMAN-FORD ON DIRECTED WEIGHTED GRAPH - TEST 01:\r\n"); Console.WriteLine("Graph representation:"); Console.WriteLine(graph.ToReadable() + "\r\n"); // Init BELLMAN-FORD BellmanFord = new BellmanFordShortestPaths<DirectedWeightedSparseGraph<string>, string>(graph, "A"); var pathToD = string.Empty; foreach (var node in BellmanFord.ShortestPathTo("D")) pathToD = String.Format("{0}({1}) -> ", pathToD, node); pathToD = pathToD.TrimEnd(new char[] { ' ', '-', '>' }); Console.WriteLine("Shortest path from 'A' to 'D': " + pathToD + "\r\n"); Console.WriteLine("*********************************************\r\n"); /***************************************************************************************/ //var dijkstraAllPairs = new DijkstraAllPairsShortestPaths<DirectedWeightedSparseGraph<string>, string>(graph); //var vertices = graph.Vertices; //Console.WriteLine("Dijkstra All Pairs Shortest Paths: \r\n"); //foreach (var source in vertices) //{ // foreach (var destination in vertices) // { // var shortestPath = string.Empty; // foreach (var node in dijkstraAllPairs.ShortestPath(source, destination)) // shortestPath = String.Format("{0}({1}) -> ", shortestPath, node); // shortestPath = shortestPath.TrimEnd(new char[] { ' ', '-', '>' }); // Console.WriteLine("Shortest path from '" + source + "' to '" + destination + "' is: " + shortestPath + "\r\n"); // } //} Console.ReadLine(); }
public static void DoTest() { string[] V; IEnumerable <WeightedEdge <string> > E; DirectedWeightedSparseGraph <string> graph; DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string> dijkstra; // Init graph object graph = new DirectedWeightedSparseGraph <string>(); // Init V V = new string[6] { "r", "s", "t", "x", "y", "z" }; // Insert V graph.AddVertices(V); Assert.True(graph.VerticesCount == V.Length, "Wrong Vertices Count."); // Insert E var status = graph.AddEdge("r", "s", 7); Assert.True(status == true); status = graph.AddEdge("r", "t", 6); Assert.True(status == true); status = graph.AddEdge("s", "t", 5); Assert.True(status == true); status = graph.AddEdge("s", "x", 9); Assert.True(status == true); status = graph.AddEdge("t", "x", 10); Assert.True(status == true); status = graph.AddEdge("t", "y", 7); Assert.True(status == true); status = graph.AddEdge("t", "z", 5); Assert.True(status == true); status = graph.AddEdge("x", "y", 2); Assert.True(status == true); status = graph.AddEdge("x", "z", 4); Assert.True(status == true); status = graph.AddEdge("y", "z", 1); Assert.True(status == true); // Get E E = graph.Edges; Assert.True(graph.EdgesCount == 10, "Wrong Edges Count."); // PRINT THE GRAPH // [*] DIJKSTRA ON DIRECTED WEIGHTED GRAPH - TEST 01: // Graph representation: // Init DIJKSTRA dijkstra = new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "s"); Assert.True(dijkstra.HasPathTo("r") == false); Assert.True(dijkstra.HasPathTo("z") == true); // Get shortest path to Z var pathToZ = string.Empty; foreach (var node in dijkstra.ShortestPathTo("z")) { pathToZ = String.Format("{0}({1}) -> ", pathToZ, node); } pathToZ = pathToZ.TrimEnd(new char[] { ' ', '-', '>' }); var pathToY = string.Empty; foreach (var node in dijkstra.ShortestPathTo("y")) { pathToY = String.Format("{0}({1}) -> ", pathToY, node); } pathToY = pathToY.TrimEnd(new char[] { ' ', '-', '>' }); // Console.WriteLine("Shortest path to node 'y': " + pathToY + "\r\n"); // Clear the graph and insert new V and E to the instance graph.Clear(); V = new string[] { "A", "B", "C", "D", "E" }; // Insert new values of V graph.AddVertices(V); Assert.True(graph.VerticesCount == V.Length, "Wrong Vertices Count."); // Insert new value for edges status = graph.AddEdge("A", "C", 7); Assert.True(status == true); status = graph.AddEdge("B", "A", 19); Assert.True(status == true); status = graph.AddEdge("B", "C", 11); Assert.True(status == true); status = graph.AddEdge("C", "E", 5); Assert.True(status == true); status = graph.AddEdge("C", "D", 15); Assert.True(status == true); status = graph.AddEdge("D", "B", 4); Assert.True(status == true); status = graph.AddEdge("E", "D", 13); Assert.True(status == true); Assert.True(graph.EdgesCount == 7, "Wrong Edges Count."); // [*] DIJKSTRA ON DIRECTED WEIGHTED GRAPH - TEST 01: // Graph representation: // Init DIJKSTRA dijkstra = new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "A"); var pathToD = string.Empty; foreach (var node in dijkstra.ShortestPathTo("D")) { pathToD = String.Format("{0}({1}) -> ", pathToD, node); } pathToD = pathToD.TrimEnd(new char[] { ' ', '-', '>' }); var vertices = graph.Vertices; var dijkstraAllPairs = new DijkstraAllPairsShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph); // Dijkstra All Pairs Shortest Paths: foreach (var source in vertices) { foreach (var destination in vertices) { var shortestPath = string.Empty; foreach (var node in dijkstraAllPairs.ShortestPath(source, destination)) { shortestPath = String.Format("{0}({1}) -> ", shortestPath, node); } shortestPath = shortestPath.TrimEnd(new char[] { ' ', '-', '>' }); // Console.WriteLine("Shortest path from '" + source + "' to '" + destination + "' is: " + shortestPath + "\r\n"); } } }
//增加了拉格朗日乘子之后的LR-w网络 public static DirectedWeightedSparseGraph <string> BuildLRwGraph( DPNProblemContext ctx, DiscreteTimeAdapter adapter, ITrainTrip train, IRailwayStation station, Dictionary <CustomerArrival, List <TravelPath> > PathDict, Dictionary <IEdge <TravelHyperNode>, ITrainTrip> linkTrainDict, Dictionary <CustomerArrival, Dictionary <TravelPath, decimal> > LM_mu, //拉格朗日乘子 μ TODO:int 改为path , Dictionary <IEdge <TravelHyperNode>, decimal> LM_lambda) { DirectedWeightedSparseGraph <string> graph = new DirectedWeightedSparseGraph <string>(); //Build price_transfer links decimal[] priceLevelList = ctx.PriceLevelList.ToArray(); int last = 0; int interval = ctx.ControlInterval / adapter.Resolution; if (interval >= adapter.Horizon) { throw new Exception("控制频率应小于预售期"); } for (int level = 0; level < priceLevelList.Count(); level++) { for (int time = 0; time + interval < adapter.Horizon; time += interval) { decimal cost_part1 = ctx.Pal.Sum(c => PathDict[c].Where(path => path.StartStation == station && priceLevelList[level] == path.Price && linkTrainDict[path.ReservationArc] == train && time <= path.ReservationTime && time + interval > path.ReservationTime).Sum(p => LM_mu[c][p])); decimal cost_part2 = LM_lambda.Where(i => i.Key.Source.Station == station && i.Key.Destination.Price == priceLevelList[level] && linkTrainDict[i.Key] == train && time <= i.Key.Source.Time && time + interval > i.Key.Source.Time).Sum(i => i.Value); string selfnode = $"{priceLevelList[level]}_{time}"; //价格不变 string nextnode = $"{priceLevelList[level]}_{time + interval}"; if (!graph.HasVertex(selfnode)) { graph.AddVertex(selfnode); } if (!graph.HasVertex(nextnode)) { graph.AddVertex(nextnode); } if (!graph.AddEdge(selfnode, nextnode, cost_part1 - cost_part2)) { throw new Exception("存在相同的Edge"); } //上升一段 if (level < priceLevelList.Count() - 1) { string ariseNode = $"{priceLevelList[level + 1]}_{time + interval}"; if (!graph.HasVertex(ariseNode)) { graph.AddVertex(ariseNode); } if (!graph.AddEdge(selfnode, ariseNode, cost_part1 - cost_part2 + DpnAlgorithm.ASmallCost)) { throw new Exception("存在相同的Edge"); } } //下降一段 if (level > 0) { string decreaseNode = $"{priceLevelList[level - 1]}_{time + interval}";//价格等级默认是1 if (!graph.HasVertex(decreaseNode)) { graph.AddVertex(decreaseNode); } if (!graph.AddEdge(selfnode, decreaseNode, cost_part1 - cost_part2 - DpnAlgorithm.ASmallCost)) { throw new Exception("存在相同的Edge"); } } last = time + interval; } } //Build dummy nodes and links. string dummystart = $"Start";//价格等级默认是1 if (!graph.HasVertex(dummystart)) { graph.AddVertex(dummystart); } for (int level = 0; level < priceLevelList.Count(); level++) { string selfnode = $"{priceLevelList[level]}_0";//价格等级默认是1 if (!graph.AddEdge(dummystart, selfnode, (level + 1) * ASmallCost)) { throw new Exception("存在相同的Edge"); } } string dummyend = $"End";//价格等级默认是1 if (!graph.HasVertex(dummyend)) { graph.AddVertex(dummyend); } for (int level = 0; level < priceLevelList.Count(); level++) { string selfnode = $"{priceLevelList[level]}_{last}";//价格等级默认是1 if (!graph.AddEdge(selfnode, dummyend, ASmallCost)) { throw new Exception("存在相同的Edge"); } } var min = graph.Edges.Min(e => e.Weight); if (min <= 0) { foreach (var edge in graph.Edges) { edge.Weight += -min + DpnAlgorithm.ASmallCost; } } return(graph); }
// GET: /<controller>/ public IActionResult Index() { string result = string.Empty; string[] V; IEnumerable <WeightedEdge <string> > E; DirectedWeightedSparseGraph <string> graph; DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string> dijkstra; // Init graph object graph = new DirectedWeightedSparseGraph <string>(); // Init V V = new string[6] { "r", "s", "t", "x", "y", "z" }; result = result + "Initial Verrtices: 'r', 's', 't', 'x', 'y', 'z'" + "\n"; // Insert V graph.AddVertices(V); result = result + "# of vertices: " + V.Length + "\n"; // Insert E var status = graph.AddEdge("r", "s", 7); status = graph.AddEdge("r", "t", 6); status = graph.AddEdge("s", "t", 5); status = graph.AddEdge("s", "x", 9); status = graph.AddEdge("t", "x", 10); status = graph.AddEdge("t", "y", 7); status = graph.AddEdge("t", "z", 5); status = graph.AddEdge("x", "y", 2); status = graph.AddEdge("x", "z", 4); status = graph.AddEdge("y", "z", 1); // Get E E = graph.Edges; //Debug.Assert(graph.EdgesCount == 10, "Wrong Edges Count."); result = result + "# of edges: " + graph.EdgesCount + "\n\n"; // // PRINT THE GRAPH result = result + "[*] DIJKSTRA ON DIRECTED WEIGHTED GRAPH:\r\n"; result = result + "Graph representation:"; result = result + graph.ToReadable() + "\r\n\n"; // Init DIJKSTRA dijkstra = new DijkstraShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "s"); result = result + "dijkstra.HasPathTo('r') is " + dijkstra.HasPathTo("r") + "\n"; result = result + "dijkstra.HasPathTo('z') is " + dijkstra.HasPathTo("z") + "\n\n"; // Get shortest path to Z var pathToZ = string.Empty; foreach (var node in dijkstra.ShortestPathTo("z")) { pathToZ = String.Format("{0}({1}) -> ", pathToZ, node); } pathToZ = pathToZ.TrimEnd(new char[] { ' ', '-', '>' }); result = result + "Shortest path to node 'z': " + pathToZ + "\r\n"; var pathToY = string.Empty; foreach (var node in dijkstra.ShortestPathTo("y")) { pathToY = String.Format("{0}({1}) -> ", pathToY, node); } pathToY = pathToY.TrimEnd(new char[] { ' ', '-', '>' }); result = result + "Shortest path to node 'y': " + pathToY + "\r\n\n"; ///***************************************************************************************/ //// Clear the graph and insert new V and E to the instance //graph.Clear(); //V = new string[] { "A", "B", "C", "D", "E" }; //// Insert new values of V //graph.AddVertices(V); //Debug.Assert(graph.VerticesCount == V.Length, "Wrong Vertices Count."); //// Insert new value for edges //status = graph.AddEdge("A", "C", 7); //Debug.Assert(status == true); //status = graph.AddEdge("B", "A", 19); //Debug.Assert(status == true); //status = graph.AddEdge("B", "C", 11); //Debug.Assert(status == true); //status = graph.AddEdge("C", "E", 5); //Debug.Assert(status == true); //status = graph.AddEdge("C", "D", 15); //Debug.Assert(status == true); //status = graph.AddEdge("D", "B", 4); //Debug.Assert(status == true); //status = graph.AddEdge("E", "D", 13); //Debug.Assert(status == true); //Debug.Assert(graph.EdgesCount == 7, "Wrong Edges Count."); //// //// PRINT THE GRAPH //Console.Write("[*] DIJKSTRA ON DIRECTED WEIGHTED GRAPH - TEST 01:\r\n"); //Console.WriteLine("Graph representation:"); //Console.WriteLine(graph.ToReadable() + "\r\n"); //// Init DIJKSTRA //dijkstra = new DijkstraShortestPaths<DirectedWeightedSparseGraph<string>, string>(graph, "A"); //var pathToD = string.Empty; //foreach (var node in dijkstra.ShortestPathTo("D")) // pathToD = String.Format("{0}({1}) -> ", pathToD, node); //pathToD = pathToD.TrimEnd(new char[] { ' ', '-', '>' }); //Console.WriteLine("Shortest path from 'A' to 'D': " + pathToD + "\r\n"); //Console.WriteLine("*********************************************\r\n"); ///***************************************************************************************/ var dijkstraAllPairs = new DijkstraAllPairsShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph); var vertices = graph.Vertices; result = result + "Dijkstra All Pairs Shortest Paths: \r\n"; foreach (var source in vertices) { foreach (var destination in vertices) { var shortestPath = string.Empty; if (dijkstraAllPairs.ShortestPath(source, destination) != null) { foreach (var node in dijkstraAllPairs.ShortestPath(source, destination)) { shortestPath = String.Format("{0}({1}) -> ", shortestPath, node); } shortestPath = shortestPath.TrimEnd(new char[] { ' ', '-', '>' }); result = result + "Shortest path from '" + source + "' to '" + destination + "' is: " + shortestPath + "\r\n"; } } } //Console.ReadLine(); HtmlString html = StringHelper.GetHtmlString(result); return(View(html)); }
public static void DoTest() { string[] V; IEnumerable <WeightedEdge <string> > E; DirectedWeightedSparseGraph <string> graph; BellmanFordShortestPaths <DirectedWeightedSparseGraph <string>, string> BellmanFord; // Init graph object graph = new DirectedWeightedSparseGraph <string>(); // Init V V = new string[6] { "r", "s", "t", "x", "y", "z" }; // Insert V graph.AddVertices(V); Debug.Assert(graph.VerticesCount == V.Length, "Wrong Vertices Count."); // Insert E var status = graph.AddEdge("r", "s", -3); Debug.Assert(status == true); status = graph.AddEdge("s", "t", 4); Debug.Assert(status == true); status = graph.AddEdge("t", "x", -1); Debug.Assert(status == true); status = graph.AddEdge("x", "y", 6); Debug.Assert(status == true); status = graph.AddEdge("y", "z", -1); Debug.Assert(status == true); status = graph.AddEdge("r", "t", 1); Debug.Assert(status == true); status = graph.AddEdge("s", "x", 7); Debug.Assert(status == true); status = graph.AddEdge("t", "y", 4); Debug.Assert(status == true); status = graph.AddEdge("t", "z", 3); Debug.Assert(status == true); status = graph.AddEdge("x", "z", 2); Debug.Assert(status == true); // NEGATIVE CYCLE (BACK-EDGE) status = graph.AddEdge("y", "t", -7); Debug.Assert(status == true); // Get E E = graph.Edges; Debug.Assert(graph.EdgesCount == 11, "Wrong Edges Count."); // // PRINT THE GRAPH Console.Write("[*] BELLMAN-FORD ON DIRECTED WEIGHTED GRAPH - TEST 01:\r\n"); Console.WriteLine("Graph representation:"); Console.WriteLine(graph.ToReadable() + "\r\n"); // WILL THROW EXCEPTION try { BellmanFord = new BellmanFordShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "s"); } catch (Exception ex) { status = graph.RemoveEdge("y", "t"); //Debug.Assert(status == true, "Error! Edge was not deleted."); BellmanFord = new BellmanFordShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "s"); } //Debug.Assert(graph.HasEdge("y", "t") == false, "Wrong, edge y-t must have been deleted."); Debug.Assert(BellmanFord.HasPathTo("r") == false); Debug.Assert(BellmanFord.HasPathTo("z") == true); // Get shortest path to Z var pathToZ = string.Empty; foreach (var node in BellmanFord.ShortestPathTo("z")) { pathToZ = String.Format("{0}({1}) -> ", pathToZ, node); } pathToZ = pathToZ.TrimEnd(new char[] { ' ', '-', '>' }); Console.WriteLine("Shortest path to node 'z': " + pathToZ + "\r\n"); var pathToY = string.Empty; foreach (var node in BellmanFord.ShortestPathTo("y")) { pathToY = String.Format("{0}({1}) -> ", pathToY, node); } pathToY = pathToY.TrimEnd(new char[] { ' ', '-', '>' }); Console.WriteLine("Shortest path to node 'y': " + pathToY + "\r\n"); Console.WriteLine("*********************************************\r\n"); /***************************************************************************************/ // Clear the graph and insert new V and E to the instance graph.Clear(); V = new string[] { "s", "a", "b", "c", "d" }; // Insert new values of V graph.AddVertices(V); Debug.Assert(graph.VerticesCount == V.Length, "Wrong Vertices Count."); // Insert new value for edges status = graph.AddEdge("s", "a", 1); Debug.Assert(status == true); status = graph.AddEdge("a", "b", 1); Debug.Assert(status == true); status = graph.AddEdge("b", "c", 2); Debug.Assert(status == true); status = graph.AddEdge("c", "a", -5); Debug.Assert(status == true); status = graph.AddEdge("c", "d", 2); Debug.Assert(status == true); Debug.Assert(graph.EdgesCount == 5, "Wrong Edges Count."); // PRINT THE GRAPH Console.Write("[*] BELLMAN-FORD ON DIRECTED WEIGHTED GRAPH - TEST 01:\r\n"); Console.WriteLine("Graph representation:"); Console.WriteLine(graph.ToReadable() + "\r\n"); // WILL THROW EXCEPTION try { BellmanFord = new BellmanFordShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "b"); } catch (Exception ex) { status = graph.RemoveEdge("c", "a"); //Debug.Assert(status == true, "Error! Edge was not deleted."); BellmanFord = new BellmanFordShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "b"); } Console.WriteLine("*********************************************\r\n"); /***************************************************************************************/ // Clear the graph and insert new V and E to the instance graph.Clear(); V = new string[] { "A", "B", "C", "D", "E" }; // Insert new values of V graph.AddVertices(V); Debug.Assert(graph.VerticesCount == V.Length, "Wrong Vertices Count."); // Insert new value for edges status = graph.AddEdge("A", "C", 7); Debug.Assert(status == true); status = graph.AddEdge("B", "A", 19); Debug.Assert(status == true); status = graph.AddEdge("B", "C", 11); Debug.Assert(status == true); status = graph.AddEdge("C", "E", 5); Debug.Assert(status == true); status = graph.AddEdge("C", "D", 15); Debug.Assert(status == true); status = graph.AddEdge("D", "B", 4); Debug.Assert(status == true); status = graph.AddEdge("E", "D", 13); Debug.Assert(status == true); Debug.Assert(graph.EdgesCount == 7, "Wrong Edges Count."); // // PRINT THE GRAPH Console.Write("[*] BELLMAN-FORD ON DIRECTED WEIGHTED GRAPH - TEST 01:\r\n"); Console.WriteLine("Graph representation:"); Console.WriteLine(graph.ToReadable() + "\r\n"); // Init BELLMAN-FORD BellmanFord = new BellmanFordShortestPaths <DirectedWeightedSparseGraph <string>, string>(graph, "A"); var pathToD = string.Empty; foreach (var node in BellmanFord.ShortestPathTo("D")) { pathToD = String.Format("{0}({1}) -> ", pathToD, node); } pathToD = pathToD.TrimEnd(new char[] { ' ', '-', '>' }); Console.WriteLine("Shortest path from 'A' to 'D': " + pathToD + "\r\n"); Console.WriteLine("*********************************************\r\n"); /***************************************************************************************/ //var dijkstraAllPairs = new DijkstraAllPairsShortestPaths<DirectedWeightedSparseGraph<string>, string>(graph); //var vertices = graph.Vertices; //Console.WriteLine("Dijkstra All Pairs Shortest Paths: \r\n"); //foreach (var source in vertices) //{ // foreach (var destination in vertices) // { // var shortestPath = string.Empty; // foreach (var node in dijkstraAllPairs.ShortestPath(source, destination)) // shortestPath = String.Format("{0}({1}) -> ", shortestPath, node); // shortestPath = shortestPath.TrimEnd(new char[] { ' ', '-', '>' }); // Console.WriteLine("Shortest path from '" + source + "' to '" + destination + "' is: " + shortestPath + "\r\n"); // } //} Console.ReadLine(); }