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();
}
