Merge branch 'algorithms-in-action:dev' into dev

Author: dwangng

package-lock.json

@@ -96,4 +96,3 @@
     "run-script-os": "^1.1.6"
   }
 }
-

package.json

@@ -13,9 +13,34 @@ a:hover{
 
 ## Extra Info
 
------
 
 Geeks for Geeks Link: [**Astar Algorithm**][G4GLink]
 
+[G4GLink]: https://www.geeksforgeeks.org/a-search-algorithm/
+
+
+## Exercises/Exploration
+
+For Graph 1 (or any other graph) what is the longest path (choice of
+start and end nodes) for which the algorithm makes no "mistakes", that
+is, every node removed from the priority queue is on the shortest path?
+What are the characteristics of such paths?
+
+The background says if Euclidean distance is used for weights and
+Manhattan distance is used for the heuristic, it is not admissible
+(so the shortest path may not be the one returned) whereas for other
+combinations of Manhattan/Euclidean the heuristic is admissible (so the
+shortest will be returned).  Use the default settings (Graph1, start node
+5, end node 12) to explore this.  Can you come up with other examples
+to illustrate this?
+
+AIA uses integer approximations to Euclidean distances for convenience.
+There was a choice of rounding to the closest integer, rounding up
+(ceiling) or rounding down (floor).  By picking different node positions,
+try to determine which of these alternatives is used. Why was that
+alternative used?  Can you think of an example that would not work so
+well if a different alternative was used.  Hint: consider a graph in the
+shape of a right-angled triangle with edge lengths 10, 10 and 10 root 2
+(around 14.142137) with nodes at the corners and several nodes along
+the hypotenuse.
 
-[G4GLink]: https://www.geeksforgeeks.org/a-search-algorithm/

src/algorithms/extra-info/ASTInfo.md

@@ -12,9 +12,24 @@ a:hover{
 
 ## Extra Info
 
------
 
 Geeks for Geeks Link: [**Iterative Depth First Search**][G4GLink]
 
 
 [G4GLink]: https://www.geeksforgeeks.org/iterative-depth-first-traversal/
+
+## Exercises/Exploration
+
+For Graph2 can you find a combination of start and end nodes so the path
+found includes all nodes in the graph?
+
+Both the iterative and recursive codings of DFS have the line "for each
+node m neighbouring n". For iterative DFS, the neighbours are considered
+in increasing node number order whereas for recursive DFS the order is
+reversed. Why is this done?
+
+The "frontier" nodes for iterative DFS are fairly easy to determine
+from the animation - they are the nodes in the stack that have not
+yet been finalised.  How does this compare with the animation of the
+recursive version?
+

src/algorithms/extra-info/DFSInfo.md

@@ -12,9 +12,22 @@ a:hover{
 
 ## Extra Info
 
------
-
 Geeks for Geeks Link: [**Depth First Search**][G4GLink]
 
-
 [G4GLink]: https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/
+
+## Exercises/Exploration
+
+For Graph2 can you find a combination of start and end nodes so the path
+found includes all nodes in the graph?
+
+Both the iterative and recursive codings of DFS have the line "for each
+node m neighbouring n". For iterative DFS, the neighbours are considered 
+in increasing node number order whereas for recursive DFS the order is
+reversed. Why is this done?
+
+The "frontier" nodes for iterative DFS are fairly easy to determine
+from the animation - they are the nodes in the stack that have not
+yet been finalised.  How does this compare with the animation of the
+recursive version?
+

src/algorithms/extra-info/DFSrecInfo.md

@@ -20,4 +20,21 @@ Geeks for Geeks Link: [**Kruskal's Algorithm**][G4GLink]
 
 [G4GLink]: https://www.geeksforgeeks.org/kruskals-algorithm-simple-implementation-for-adjacency-matrix/
 
+## Exercises/Exploration
+
+Choose Graph 2 and manually delete the edge between nodes 11 and 13,
+so the graph has two components.  Find minimum spanning forest of the
+resulting graph.
+
+Compare and contrast how Prim's algorithm and Kruskal's algorithm operate
+to compute minimum spanning trees.
+
+Consider Graph 1 with weights "As input". There are two different minimal
+spanning trees and the current coding finds one of them.  How could the
+coding be changed so the other second one is found instead?  Can you 
+use the existing code to find the second one by re-numbering the graph nodes?
+
+For Graph1 with the other weight options, can you convince yourself that
+there is a single minimum spanning tree?
+
 

src/algorithms/extra-info/KRUSKALInfo.md

@@ -13,11 +13,27 @@ a:hover{
 
 ## Extra Info
 
------
-
 Geeks for Geeks Link: [**Prim's Algorithm**][G4GLink]
 
-
 [G4GLink]: https://www.geeksforgeeks.org/prims-minimum-spanning-tree-mst-greedy-algo-5/
 
+## Exercises/Exploration
+
+Consider Graph 1 with weights "As input". Can you find two different
+minimal spanning trees using Prim's algorithm, by selecting different
+start nodes?
+
+For Graph1 with the other weight options, can you convince yourself that
+there is a single minimum spanning tree without running the algorithm
+multiple times with different start nodes?
+
+Choose Graph 2 and manually delete the edge between nodes 11 and 13,
+so the graph has two components.  Find minimum spanning trees for each
+component.  Prim's algorithm can be adapted to find a minimal spanning
+forest for the whole graph.  One coding sometimes used is to add an outer
+loop that calls Prims() for each node in the graph, ignoring nodes that
+have already been visited.  Can you think of a different way of coding it?
+
+Compare and contrast how Prim's algorithm and Kruskal's algorithm operate
+to compute minimum spanning trees.