/// <summary>
/// Find the neighbors from a node.
/// </summary>
/// <param name="node">The node to be processed.</param>
/// <param name="openList">The list to receive the neighbors.</param>
static void GetNeighbors(SPNode node, List<SPNode> openList, List<SPNode> closedList)
{
for (int i = 0; i < node.Neighbors.Count; i++) {
SPNode neighbor = node.Neighbors[i];
if (closedList.Contains(neighbor)) continue;
if (openList.Contains(neighbor)) continue;
neighbor.PreviousNode = node;
neighbor.WeightToReachFromPreviousNode = node.WeightToReachFromPreviousNode + neighbor.Weight;
openList.Add(neighbor);
}
}
/// <summary>
/// Finds the least cost node (remove it from list before returning).
/// </summary>
/// <returns>The least cost node in the list.</returns>
static SPNode GetLeastCostNode(List<SPNode> openList)
{
SPNode leastCostNode = openList[0];
int leastCostNodeWeight = leastCostNode.WeightToReachFromPreviousNode;
for (int i = 1; i < openList.Count; i++) {
SPNode nextNode = openList[i];
int nextNodeWeight = nextNode.WeightToReachFromPreviousNode;
if (nextNodeWeight < leastCostNodeWeight) {
leastCostNode = nextNode;
leastCostNodeWeight = leastCostNode.WeightToReachFromPreviousNode;
}
}
openList.Remove(leastCostNode);
return leastCostNode;
}
/// <summary>
/// Build a list from the shortest path found.
/// </summary>
static SPNode[] BuildShortestPathList(SPNode targetNode, List<SPNode> list)
{
SPNode prevNode = targetNode.PreviousNode;
List<SPNode> spList = new List<SPNode>();
// If the target node wast found, return null.
if (list.Find(x => x.ID == targetNode.ID) == null) return null;
spList.Add(targetNode);
while ((prevNode != null) && (prevNode != prevNode.PreviousNode)) {
spList.Add(prevNode);
prevNode = prevNode.PreviousNode;
}
spList.Reverse();
return spList.ToArray();
}
/// <summary>
/// Test C.
/// Graph (# represents heavy weight paths. heavy nodes are D and H.):
///
/// A----B----C
/// # | \ |
/// # | \ |
/// D ## E----F
/// # # |
/// # # |
/// G ## H ###I
// Expected path: A -> B -> F -> I
// Expected path: 0 -> 1 -> 5 -> 8
/// </summary>
public static void TestC()
{
SPNode nodeA = new SPNode(0, 1);
SPNode nodeB = new SPNode(1, 1);
SPNode nodeC = new SPNode(2, 1);
SPNode nodeD = new SPNode(3, 3);
SPNode nodeE = new SPNode(4, 1);
SPNode nodeF = new SPNode(5, 1);
SPNode nodeG = new SPNode(6, 1);
SPNode nodeH = new SPNode(7, 3);
SPNode nodeI = new SPNode(8, 1);
nodeA.AddNeighbor(nodeB, nodeD);
nodeB.AddNeighbor(nodeA, nodeC, nodeE, nodeF);
nodeC.AddNeighbor(nodeB, nodeF);
nodeD.AddNeighbor(nodeA, nodeE, nodeG);
nodeE.AddNeighbor(nodeB, nodeD, nodeF, nodeH);
nodeF.AddNeighbor(nodeC, nodeE, nodeI);
nodeG.AddNeighbor(nodeD, nodeH);
nodeH.AddNeighbor(nodeE, nodeG, nodeI);
nodeI.AddNeighbor(nodeF, nodeH);
List<SPNode> nodesList = new List<SPNode>()
{
nodeA,
nodeB,
nodeC,
nodeD,
nodeE,
nodeF,
nodeG,
nodeH,
nodeI
};
SPNode[] sp = ShortestPath.FindShortestPath(0, 8, nodesList);
ShortestPath.DumpPath(new List<SPNode>(sp));
}
/// <summary>
/// Checks if the node is present in the list.
/// </summary>
/// <param name="node">The node to look for.</param>
/// <param name="closedList">The list to be searched.</param>
/// <returns>true if the node is in the list; false otherwise</returns>
static bool CheckNodeInList(SPNode node, List<SPNode> closedList)
{
SPNode targetNode = closedList.Find(x => x.ID == node.ID);
return (targetNode != null);
}
