private IEnumerable <ICell> ShortestPathCells(ICell source, ICell destination)
{
IEnumerable <DirectedEdge> path;
int sourceIndex = IndexFor(source);
if (_sourceIndex.HasValue && _sourceIndex == sourceIndex && _dijkstraShortestPath != null)
{
path = _dijkstraShortestPath.PathTo(IndexFor(destination));
}
else
{
_sourceIndex = sourceIndex;
_dijkstraShortestPath = new DijkstraShortestPath(_graph, sourceIndex);
path = _dijkstraShortestPath.PathTo(IndexFor(destination));
}
if (path == null)
{
yield return(null);
}
else
{
yield return(source);
foreach (DirectedEdge edge in path)
{
yield return(CellFor(edge.To));
}
}
}
public void AssertCanNotSearch()
{
IGraph graph = new GraphAdjMatrix(new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 });
graph.AddEdge(0, 1);
graph.AddEdge(1, 2);
graph.AddEdge(2, 3);
graph.AddEdge(3, 4);
graph.AddEdge(4, 5);
graph.AddEdge(5, 6);
graph.AddEdge(5, 8);
graph.AddEdge(6, 7);
graph.AddEdge(7, 8);
graph.AddEdge(8, 5);
graph.AddEdge(0, 9);
graph.AddEdge(9, 10);
graph.AddEdge(10, 11);
var bfs = new DijkstraShortestPath(graph);
var result = bfs.CanFind(0, 12);
Assert.IsFalse(result);
}
public void AssertCanSearchShortestPathWithMultipleParents()
{
IGraph graph = new GraphAdjMatrix(new[] { 0, 1, 2, 3, 4, 5, 6 });
graph.AddEdge(0, 1, 1);
graph.AddEdge(0, 3, 3);
graph.AddEdge(1, 2, 1);
graph.AddEdge(2, 4, 1);
graph.AddEdge(4, 6, 4);
graph.AddEdge(3, 5, 3);
graph.AddEdge(5, 6, 1);
graph.AddEdge(3, 6, 5);
var bfs = new DijkstraShortestPath(graph);
var result = bfs.CanFind(0, 6);
Assert.IsTrue(result);
var direction = bfs.PathToGoal();
Assert.AreEqual(0, direction[0]);
Assert.AreEqual(3, direction[1]);
Assert.AreEqual(5, direction[2]);
Assert.AreEqual(6, direction[3]);
}
public void FindShortestPath_FromSampleGraphNodeG_SampleGraphShortestPathResultG()
{
var actualShortestPathResult = DijkstraShortestPath.FindShortestPath(_SampleData.NodeG, _SampleData.Graph);
var expectedShortestPathResult = _SampleData.ShortestPathResultG;
foreach (var n in actualShortestPathResult.DistanceToNodes.Keys)
{
var actual = actualShortestPathResult.DistanceToNodes[n];
var expectedKey = expectedShortestPathResult.DistanceToNodes.Keys.FirstOrDefault(p => p.CompareTo(n) == 0);
var expected = expectedShortestPathResult.DistanceToNodes[expectedKey];
Assert.AreEqual(expected, actual);
}
foreach (var n in actualShortestPathResult.PreviousNode.Keys)
{
var actual = actualShortestPathResult.PreviousNode[n];
var expectedKey = expectedShortestPathResult.PreviousNode.Keys.FirstOrDefault(p => p.CompareTo(n) == 0);
var expected = expectedShortestPathResult.PreviousNode[expectedKey];
if (actual == null)
{
Assert.IsNull(expected);
}
else
{
Assert.IsTrue(expected.CompareTo(actual) == 0);
}
}
}
public int SolveFourthLink()
{
var g = ParseWeightedGraphFromWeb(Link4);
var reweightedGraph = new JohnsonReweighting().ReweightEdges(g);
var res = new DijkstraShortestPath().GetMinAllPairsShortestPaths(reweightedGraph);
return(res);
}
public void Execute(Graph graph)
{
System.Console.WriteLine("Je haalt het kompas uit je zak. Het trilt in je hand en projecteert in lichtgevende letters op de muur:");
DijkstraShortestPath d = new DijkstraShortestPath();
var path = d.Execute(graph);
PrintLight(path, graph.EndPoint);
System.Console.WriteLine("\n");
PrintEnemies(path, graph.EndPoint);
}
public void DistanceTo_WhenPathExistsBetween0And4_WillBeSumOfWeightsInPath()
{
EdgeWeightedDigraph digraph = new EdgeWeightedDigraph(5);
digraph.AddEdge(new DirectedEdge(0, 1, 2.5));
digraph.AddEdge(new DirectedEdge(1, 2, 3.25));
digraph.AddEdge(new DirectedEdge(2, 3, 1.25));
digraph.AddEdge(new DirectedEdge(3, 4, 2));
DijkstraShortestPath dijkstra = new DijkstraShortestPath(digraph, 0);
Assert.AreEqual(9, dijkstra.DistanceTo(4));
}
public void HasPathTo_WhenPathDoesNotExistBetween4And0_WillBeFalse()
{
EdgeWeightedDigraph digraph = new EdgeWeightedDigraph(5);
digraph.AddEdge(new DirectedEdge(0, 1, 2.5));
digraph.AddEdge(new DirectedEdge(1, 2, 3.25));
digraph.AddEdge(new DirectedEdge(2, 3, 1.25));
digraph.AddEdge(new DirectedEdge(3, 4, 2));
DijkstraShortestPath dijkstra = new DijkstraShortestPath(digraph, 4);
Assert.IsFalse(dijkstra.HasPathTo(0));
}
public void HasPathTo_WhenPathExistsBetween0And4_WillBeTrue()
{
EdgeWeightedDigraph digraph = new EdgeWeightedDigraph(5);
digraph.AddEdge(new DirectedEdge(0, 1, 2.5));
digraph.AddEdge(new DirectedEdge(1, 2, 3.25));
digraph.AddEdge(new DirectedEdge(2, 3, 1.25));
digraph.AddEdge(new DirectedEdge(3, 4, 2));
DijkstraShortestPath dijkstra = new DijkstraShortestPath(digraph, 0);
Assert.IsTrue(dijkstra.HasPathTo(4));
}
public void Check_WhenGivenValidGraph_WillBeTrue()
{
EdgeWeightedDigraph digraph = new EdgeWeightedDigraph(5);
digraph.AddEdge(new DirectedEdge(0, 1, 2.5));
digraph.AddEdge(new DirectedEdge(1, 2, 3.25));
digraph.AddEdge(new DirectedEdge(1, 4, 4.75));
digraph.AddEdge(new DirectedEdge(2, 3, 1.25));
digraph.AddEdge(new DirectedEdge(3, 4, 2));
DijkstraShortestPath dijkstra = new DijkstraShortestPath(digraph, 0);
Assert.IsTrue(dijkstra.Check(digraph, 0));
}
public void DistanceTo_WhenNoPathExists_WillBePositiveInfinity()
{
EdgeWeightedDigraph digraph = new EdgeWeightedDigraph(5);
digraph.AddEdge(new DirectedEdge(0, 1, 2.5));
digraph.AddEdge(new DirectedEdge(1, 2, 3.25));
digraph.AddEdge(new DirectedEdge(1, 4, 4.75));
digraph.AddEdge(new DirectedEdge(2, 3, 1.25));
digraph.AddEdge(new DirectedEdge(3, 4, 2));
DijkstraShortestPath dijkstra = new DijkstraShortestPath(digraph, 4);
Assert.AreEqual(double.PositiveInfinity, dijkstra.DistanceTo(0));
}
public void CanCalcShortestPath5()
{
var graph = new[]
{
"1 2,8 3,17",
"2 1,7 3,10 4,5",
"3 1,12",
"4 3,3"
};
var paths = new DijkstraShortestPath().CalcShortestPaths(graph, 1);
AssertHelper.Seq(new long[] { 0, 8, 16, 13 }, paths.Skip(1));
}
public void CanCalcShortestPath3()
{
var graph = new[]
{
"1 2,3 3,5",
"2 3,1 4,2",
"3 4,50 ",
"4 ",
};
var paths = new DijkstraShortestPath().CalcShortestPaths(graph, 1);
AssertHelper.Seq(new long[] { 0, 3, 4, 5 }, paths.Skip(1));
}
public void FindShortestPath_FirstShortestNotTheBest_2levels_MatchExpectations()
{
#region setup
var start = new DijkstraShortestPath.Vertex(1);
var l11 = new DijkstraShortestPath.Vertex(2);
var l12 = new DijkstraShortestPath.Vertex(3);
var l21 = new DijkstraShortestPath.Vertex(4);
var l22 = new DijkstraShortestPath.Vertex(5);
var end = new DijkstraShortestPath.Vertex(6);
start.Edges.AddRange(new []
{
new DijkstraShortestPath.Edge(30)
{
End = l11
},
new DijkstraShortestPath.Edge(20)
{
End = l12
},
});
l11.Edges.Add(new DijkstraShortestPath.Edge(60)
{
End = l21
});
l12.Edges.Add(new DijkstraShortestPath.Edge(50)
{
End = l22
});
l21.Edges.Add(new DijkstraShortestPath.Edge(10)
{
End = end
});
l22.Edges.Add(new DijkstraShortestPath.Edge(40)
{
End = end
});
#endregion setup
var path = DijkstraShortestPath.FindShortestPath(start, end);
using var scope = new AssertionScope();
path.Select(p => p.Item2).Sum().Should().Be(100);
path[0].Item1.Data.Should().Be(1);
path[1].Item1.Data.Should().Be(2);
path[2].Item1.Data.Should().Be(4);
path[3].Item1.Data.Should().Be(6);
}
public void ShortestPath_LargeDataSet_RunsInExpectedTime()
{
// arrange
RoadNetworkParser parser = new RoadNetworkParser(Resources.WashingtonRoadNetwork);
DijkstraShortestPath d = new DijkstraShortestPath(parser.Vertices, parser.Edges);
Stopwatch s = Stopwatch.StartNew();
// act
double distance = d.ShortestPath(456458, 456399);
// assert
Assert.IsTrue(s.Elapsed < TimeSpan.FromSeconds(10));
Assert.IsTrue(distance < double.MaxValue);
}
public void FindPath_WhenNoPathExists_WillBeNull()
{
EdgeWeightedDigraph digraph = new EdgeWeightedDigraph(5);
digraph.AddEdge(new DirectedEdge(0, 1, 2.5));
digraph.AddEdge(new DirectedEdge(1, 2, 3.25));
digraph.AddEdge(new DirectedEdge(1, 4, 4.75));
digraph.AddEdge(new DirectedEdge(2, 3, 1.25));
digraph.AddEdge(new DirectedEdge(3, 4, 2));
IEnumerable <DirectedEdge> path = DijkstraShortestPath.FindPath(digraph, 4, 0);
Assert.IsNull(path);
}
public void CanCalcShortestPath1()
{
var graph = new[]
{
"1 2,7 6,14 3,9",
"2 1,7 3,10 4,15",
"3 1,9 2,10 6,2 4,11",
"4 2,15 3,11 5,6",
"5 4,6 6,9",
"6 1,14 3,2 5,9"
};
var paths = new DijkstraShortestPath().CalcShortestPaths(graph, 1);
AssertHelper.Seq(new long[] { 0, 7, 9, 20, 20, 11 }, paths.Skip(1));
}
public void FindPath_WhenMultiplePathsExistBetween0And4_WillBeShortestPath()
{
EdgeWeightedDigraph digraph = new EdgeWeightedDigraph(5);
digraph.AddEdge(new DirectedEdge(0, 1, 2.5));
digraph.AddEdge(new DirectedEdge(1, 2, 3.25));
digraph.AddEdge(new DirectedEdge(1, 4, 4.75));
digraph.AddEdge(new DirectedEdge(2, 3, 1.25));
digraph.AddEdge(new DirectedEdge(3, 4, 2));
DirectedEdge[] path = DijkstraShortestPath.FindPath(digraph, 0, 4).ToArray();
Assert.AreEqual("From: 0, To: 1, Weight: 2.5", path[0].ToString());
Assert.AreEqual("From: 1, To: 4, Weight: 4.75", path[1].ToString());
Assert.AreEqual(2, path.Length);
}
public void ShortestPath_AdjacentNodes_FindsPath()
{
// arrange
HashSet<int> v = new HashSet<int>();
Dictionary<int, Dictionary<int, double>> e = new Dictionary<int, Dictionary<int, double>>();
v.Add(1);
v.Add(2);
e[1] = new Dictionary<int, double>();
e[2] = new Dictionary<int, double>();
e[1][2] = e[2][1] = 1;
DijkstraShortestPath d = new DijkstraShortestPath(v, e);
// act
// assert
Assert.AreEqual(1, d.ShortestPath(1, 2));
}
private IEnumerable <Cell> ShortestPathCells(Cell source, Cell destination)
{
IEnumerable <DirectedEdge> path = DijkstraShortestPath
.FindPath(_graph, IndexFor(source.Point), IndexFor(destination.Point));
if (path == null)
{
yield break;
}
yield return(source);
foreach (DirectedEdge edge in path)
{
yield return(CellFor(edge.To));
}
}
/// <summary>
/// Returns an ordered IEnumerable of Cells representing the shortest path from a specified source Cell to a destination Cell
/// </summary>
/// <param name="source">The Cell which is at the start of the path</param>
/// <param name="destination">The Cell which is at the end of the path</param>
/// <returns>Returns an ordered IEnumerable of Cells representing the shortest path from a specified source Cell to a destination Cell</returns>
public IEnumerable <Cell> ShortestPath(Cell source, Cell destination)
{
var dsp = new DijkstraShortestPath(_graph, IndexFor(source));
IEnumerable <DirectedEdge> path = dsp.PathTo(IndexFor(destination));
if (path == null)
{
yield return(null);
}
else
{
foreach (DirectedEdge edge in path)
{
yield return(CellFor(edge.To));
}
}
}
public void Test()
{
// orientovaný ohodnocený.
var graph1 = new DirectedWeightedGraph(false);
for (int i = 'a'; i < 'h'; i++)
{
graph1.AddVertex(Convert.ToString(Convert.ToChar(i)));
}
graph1.AddEdge("a", "b", 10);
graph1.AddEdge("b", "c", 20);
graph1.AddEdge("c", "d", 3);
graph1.AddEdge("d", "e", 4);
graph1.AddEdge("f", "c", 2);
graph1.AddEdge("b", "f", 3);
graph1.AddEdge("e", "b", 1);
DijkstraShortestPath <DirectedWeightedGraph> .Search(graph1, "a");
Assert.AreEqual(0, graph1.GetVertex("a").distance);
Assert.AreEqual(10, graph1.GetVertex("b").distance);
Assert.AreEqual(15, graph1.GetVertex("c").distance);
Assert.AreEqual(18, graph1.GetVertex("d").distance);
Assert.AreEqual(22, graph1.GetVertex("e").distance);
Assert.AreEqual(13, graph1.GetVertex("f").distance);
Assert.AreEqual(long.MaxValue, graph1.GetVertex("g").distance);
Stack <Vertex> stack = new Stack <Vertex>();
stack.Push(graph1.GetVertex("e"));
stack.Push(graph1.GetVertex("d"));
stack.Push(graph1.GetVertex("c"));
stack.Push(graph1.GetVertex("f"));
stack.Push(graph1.GetVertex("b"));
stack.Push(graph1.GetVertex("a"));
var stackTest = DijkstraShortestPath <DirectedWeightedGraph> .GetShortestPath(graph1, "e");
while (stack.Count > 0)
{
Assert.AreEqual(stack.Pop(), stackTest.Pop());
}
}
public List <Point> ShortestPathList(Point source, Point destination)
{
var list = new List <Point>();
IEnumerable <DirectedEdge> path = DijkstraShortestPath
.FindPath(_graph, IndexFor(source), IndexFor(destination));
if (path == null)
{
return(list);
}
foreach (DirectedEdge edge in path)
{
list.Add(CoordFor(edge.To));
}
return(list);
}
private IEnumerable <ICell> ShortestPathCells(ICell source, ICell destination)
{
var path = DijkstraShortestPath.FindPath(_graph, IndexFor(source), IndexFor(destination));
if (path == null)
{
yield return(null);
}
else
{
yield return(source);
foreach (var edge in path)
{
yield return(CellFor(edge.To));
}
}
}
public void ShortestPath_ConsecutiveNodesSinglePathSameWeight_FindsPath()
{
// arrange
HashSet<int> v = new HashSet<int>();
Dictionary<int, Dictionary<int, double>> e = new Dictionary<int, Dictionary<int, double>>();
v.Add(1);
v.Add(2);
v.Add(3);
e[1] = new Dictionary<int, double>();
e[2] = new Dictionary<int, double>();
e[3] = new Dictionary<int, double>();
e[1][2] = e[2][1] = e[3][2] = e[2][3] = 1;
DijkstraShortestPath d = new DijkstraShortestPath(v, e);
// act
// assert
Assert.AreEqual(2, d.ShortestPath(1, 3));
}
public void testConstructor()
{
GraphPath <String, DefaultWeightedEdge> path;
Graph <String, DefaultWeightedEdge> g = create();
path = new DijkstraShortestPath <string, DefaultWeightedEdge>(g, Double.PositiveInfinity).getPath(V1, V5);
Assert.AreEqual(new List <DefaultWeightedEdge>()
{
e13, e12, e24
}, path.getEdgeList());
//assertEquals(Arrays.asList(e13, e12, e24), path.getEdgeList());
Assert.AreEqual(10.0, path.getWeight(), 0);
// assertEquals(10.0, path.getWeight(), 0);
path = new DijkstraShortestPath <string, DefaultWeightedEdge>(g, 7.0).getPath(V3, V4);
Assert.AreEqual(null, path);
// assertNull(path);
}
public void ShortestPath_KeysNotInGraph_ThrowsException()
{
// arrange
HashSet<int> v = new HashSet<int>();
Dictionary<int, Dictionary<int, double>> e = new Dictionary<int, Dictionary<int, double>>();
v.Add(1);
v.Add(2);
v.Add(3);
e[1] = new Dictionary<int, double>();
e[2] = new Dictionary<int, double>();
e[3] = new Dictionary<int, double>();
e[1][2] = e[2][1] = e[3][2] = e[2][3] = 1;
DijkstraShortestPath d = new DijkstraShortestPath(v, e);
// act
// assert
Assert.AreEqual(double.MaxValue, d.ShortestPath(1, 4));
}
private IEnumerable <ITile> ShortestPathCells(ITile source, ITile destination)
{
IEnumerable <DirectedEdge> path = DijkstraShortestPath.FindPath(_graph, IndexFor(source), IndexFor(destination));
if (path == null)
{
yield return(null);
}
else
{
yield return(source);
foreach (DirectedEdge edge in path)
{
yield return(CellFor(edge.To));
}
}
}
public void DijkstraShortestPathTest()
{
var dg = EdgeWeightedDigraphSample();
var sp = new DijkstraShortestPath(dg, 0);
var es = new DirectedEdge[] {
new DirectedEdge(0, 2, 0.26),
new DirectedEdge(2, 7, 0.34),
new DirectedEdge(7, 3, 0.39),
new DirectedEdge(3, 6, 0.52),
};
int i = 0;
foreach (var e in sp.PathTo(6))
{
Assert.Equal(e, es[i]);
i++;
}
Assert.Equal(1.51, sp.DistTo(6), 2);
}
public void TestGraphOne()
{
var graph = new Dictionary <int, List <WeightedEdge> >();
graph.Add(0, new List <WeightedEdge>()
{
new WeightedEdge()
{
Destination = 1, Weight = 2
},
new WeightedEdge()
{
Destination = 2, Weight = 4
}
});
graph.Add(1, new List <WeightedEdge>()
{
new WeightedEdge()
{
Destination = 2, Weight = 1
},
new WeightedEdge()
{
Destination = 3, Weight = 3
}
});
graph.Add(2, new List <WeightedEdge>()
{
new WeightedEdge()
{
Destination = 3, Weight = 1
}
});
var path = new DijkstraShortestPath(graph, 4, 0).Compute();
Assert.That(path[0], Is.EqualTo(0));
Assert.That(path[1], Is.EqualTo(2));
Assert.That(path[2], Is.EqualTo(3));
Assert.That(path[3], Is.EqualTo(4));
}
public void PathTo_WhenCalledOnMediumSizedGraphForEachNode_WillFindExpectedPaths()
{
string path = @"Algorithms\TestSetup\mediumEWD.txt";
EdgeWeightedDigraph graph = TestSetup.TestHelpers.CreateEdgeWeightedDigraphFromFile(path);
int longestPathLength = 0;
int longestPathStartNode = 0;
int longestPathEndNode = 0;
for (int i = 0; i < graph.NumberOfVertices; i++)
{
DijkstraShortestPath dsp = new DijkstraShortestPath(graph, i);
for (int j = 0; j < graph.NumberOfVertices; j++)
{
var dspPath = dsp.PathTo(j);
int length = dspPath.Count();
if (length > longestPathLength)
{
longestPathLength = length;
longestPathStartNode = i;
longestPathEndNode = j;
Console.WriteLine($"Path from {i} -> {j} = {length}");
/////// Console Output /////////
// Path from 0-> 1 = 9
// Path from 0-> 6 = 10
// Path from 0-> 22 = 11
// Path from 0-> 29 = 12
// Path from 0-> 38 = 13
// Path from 8-> 237 = 14
// Path from 10-> 63 = 15
// Path from 10-> 237 = 16
///////////////////////////////
}
}
}
Assert.AreEqual(16, longestPathLength);
Assert.AreEqual(10, longestPathStartNode);
Assert.AreEqual(237, longestPathEndNode);
Assert.AreEqual(250, graph.NumberOfVertices);
Assert.AreEqual(2546, graph.NumberOfEdges);
}
private void btnCreate_Click(object sender, EventArgs e)
{
noOfNodes = Convert.ToInt32(txtNoOfNodes.Text);
if (noOfNodes <= 0 || noOfNodes > DijkstraShortestPath.MAXNODE)
{
MessageBox.Show("Wrong Input! Please, Read in correct digit from 1 to 100:", "MobileAgentBasedIDS", MessageBoxButtons.OK, MessageBoxIcon.Error);
//txtNoOfNodes.
}
else
{
for (int i = 1; i <= noOfNodes; i++)
{
lstNodes.Items.Add("Node " + i);
}
dijkstraShortestPath = new DijkstraShortestPath(noOfNodes);
//int[,] Weight = dijkstraShortestPath.GenerateWeight();
dijkstraShortestPath.GenerateWeight();
Console.WriteLine("Nodes and Distance(Weight) Table");
displayListOfNodesAndWeights(dijkstraShortestPath.Weight, 1);
}
}
public void FindShortestPath_Straightforward_MatchExpectations()
{
#region setup
var start = new DijkstraShortestPath.Vertex(1);
var l11 = new DijkstraShortestPath.Vertex(2);
var l12 = new DijkstraShortestPath.Vertex(3);
var end = new DijkstraShortestPath.Vertex(4);
start.Edges.AddRange(new []
{
new DijkstraShortestPath.Edge(10)
{
End = l11
},
new DijkstraShortestPath.Edge(20)
{
End = l12
},
});
l11.Edges.Add(new DijkstraShortestPath.Edge(30)
{
End = end
});
l12.Edges.Add(new DijkstraShortestPath.Edge(40)
{
End = end
});
#endregion setup
var path = DijkstraShortestPath.FindShortestPath(start, end);
using var scope = new AssertionScope();
path.Select(p => p.Item2).Sum().Should().Be(40);
path[0].Item1.Data.Should().Be(1);
path[1].Item1.Data.Should().Be(2);
path[2].Item1.Data.Should().Be(4);
}
public void FindPathes_FromTestData_FindAllPathesCorrect(string input, string output)
{
FindShortPathTestData testData = FindShortPathesTestDataBuilder.CreateTestData(
input,
output);
DijkstraShortestPath dijkstra = new DijkstraShortestPath(testData.Graph);
foreach (int vertex in testData.Graph.Vertexes)
{
Dictionary <int, Result> pathes = dijkstra.FindShortestPath(vertex);
int[] distances = pathes
.OrderBy(p => p.Key)
.Select(p => p.Value.Distance)
.ToArray();
Assert.That(
distances,
Is.EqualTo(testData.Distances[vertex]),
string.Format("Vertex = {0}", vertex));
}
}
public void ShortestPath_NodesNotConnected_ReturnsNotFound()
{
// arrange
HashSet<int> v = new HashSet<int>();
Dictionary<int, Dictionary<int, double>> e = new Dictionary<int, Dictionary<int, double>>();
v.Add(1);
v.Add(2);
v.Add(3);
v.Add(4);
e[1] = new Dictionary<int, double>();
e[2] = new Dictionary<int, double>();
e[3] = new Dictionary<int, double>();
e[4] = new Dictionary<int, double>();
e[1][2] = e[2][1] = 1;
e[3][4] = e[4][3] = 1;
DijkstraShortestPath d = new DijkstraShortestPath(v, e);
// act
// assert
Assert.AreEqual(double.MaxValue, d.ShortestPath(1, 4));
}
public void ShortestPath_ShorterPathIsMoreNodes_ReturnsNotFound()
{
// arrange
HashSet<int> v = new HashSet<int>();
v.Add(1);
v.Add(2);
v.Add(3);
v.Add(4);
Dictionary<int, Dictionary<int, double>> e = new Dictionary<int, Dictionary<int, double>>();
e[1] = new Dictionary<int, double>();
e[2] = new Dictionary<int, double>();
e[3] = new Dictionary<int, double>();
e[4] = new Dictionary<int, double>();
e[1][2] = e[2][1] = 1;
e[1][4] = e[4][1] = 7;
e[2][3] = e[3][2] = 2;
e[3][4] = e[4][3] = 3;
DijkstraShortestPath d = new DijkstraShortestPath(v, e);
// act
// assert
Assert.AreEqual(6, d.ShortestPath(1, 4));
}