Exercises, mostly

Author: lee-naish

src/algorithms/controllers/msort_arr_bup.js

@@ -121,7 +121,7 @@ export function run_msort() {
     }, [A, B, runlength]);
 
     chunker.add('runlength', (vis, c_rlength) => {
-      assignVarToA(vis, "runlength", c_rlength - 1, size);
+      // assignVarToA(vis, "runlength", c_rlength - 1, size);
       set_simple_stack(vis.array, [`runlength = ${c_rlength}`]);
       highlightAllRunlengths(vis, c_rlength, runAColor, runBColor, size);
     }, [runlength]);
@@ -131,7 +131,7 @@ export function run_msort() {
       let left = 0;
 
       chunker.add('MainWhile', (vis) => {
-        assignVarToA(vis, "size", size, size);
+        // assignVarToA(vis, "size", size, size);
       }, []);
 
       chunker.add('left', (vis, a, c_left, c_rlength) => {
@@ -357,9 +357,9 @@ export function run_msort() {
         assignVarToA(vis, 'left', undefined, size);
         set_simple_stack(vis.array, [`runlength = ${c_rlength}`]);
 
-        if (c_rlength < size) {
-          assignVarToA(vis, "runlength", c_rlength - 1, size);
-        }
+        // if (c_rlength < size) {
+          // assignVarToA(vis, "runlength", c_rlength - 1, size);
+        // }
 
 
       }, [runlength]);

src/algorithms/extra-info/ASTInfo.md

@@ -21,6 +21,9 @@ Geeks for Geeks Link: [**Astar Algorithm**][G4GLink]
 
 ## Exercises/Exploration
 
+Compare heuristic search with Dijkstra's algorithm: can you observe how
+the heuristic helps direct the search towards the end node?
+
 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?
@@ -44,3 +47,10 @@ 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.
 
+In AIA, the coding of various graph algorithms is designed to show
+their similarity. Iterative DFS, breadth first search, Dijkstra's
+shortest path algorithm, heuristic search and Prim's minimal spanning
+tree algorithm all have *identical* top-level pseudocode - check it out!
+Can you re-write the code for this and/or for other algorithms to make
+it as simple as possible, rather than emphasising similarity?
+

src/algorithms/extra-info/BFSInfo.md

@@ -17,4 +17,17 @@ a:hover{
 Geeks for Geeks Link: [**Breadth First Search**][G4GLink]
 
 
-[G4GLink]: https://www.geeksforgeeks.org/breadth-first-search-or-bfs-for-a-graph/
+[G4GLink]: https://www.geeksforgeeks.org/breadth-first-search-or-bfs-for-a-graph/
+
+## Exercises/Exploration
+
+Compare and contrast the use of the queue of nodes in BFS with the stack
+in iterative DFS.
+
+In AIA, the coding of various graph algorithms is designed to show
+their similarity. Iterative DFS, breadth first search, Dijkstra's
+shortest path algorithm, heuristic search and Prim's minimal spanning
+tree algorithm all have *identical* top-level pseudocode - check it out!
+Can you re-write the code for this and/or for other algorithms to make
+it as simple as possible, rather than emphasising similarity?
+

src/algorithms/extra-info/DFSInfo.md

@@ -20,14 +20,7 @@ Geeks for Geeks Link: [**Iterative Depth First Search**][G4GLink]
 
 ## Exercises/Exploration
 
-In AIA, the coding of various graph algorithms is designed to show
-their similarity. Iterative DFS, breadth first search, Dijkstra's
-shortest path algorithm, heuristic search and Prim's minimal spanning
-tree algorithm all have *identical* top-level pseudocode - check it out!
-Can you re-write the code for this and/or for other algorithms to make
-it as simple as possible, rather than emphasising similarity?
-
-For Graph2 can you find a combination of start and end nodes so the path
+For Graph 2 can you find a combination of start and end nodes so the path
 found includes all nodes in the graph?
 
 Experiment with the iterative and recursive versions of DFS. Can you
@@ -52,4 +45,10 @@ How can you code iterative DFS so it uses less stack space in the worst
 case?  Hint: consider what information is on the (implicit) stack for
 recursive DFS and how that is coded.
 
+In AIA, the coding of various graph algorithms is designed to show
+their similarity. Iterative DFS, breadth first search, Dijkstra's
+shortest path algorithm, heuristic search and Prim's minimal spanning
+tree algorithm all have *identical* top-level pseudocode - check it out!
+Can you re-write the code for this and/or for other algorithms to make
+it as simple as possible, rather than emphasising similarity?
 

src/algorithms/extra-info/DFSrecInfo.md

@@ -18,23 +18,16 @@ Geeks for Geeks Link: [**Depth First Search**][G4GLink]
 
 ## Exercises/Exploration
 
-For Graph2 can you find a combination of start and end nodes so the path
+For Graph 2 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 data structures - they are the nodes in the stack that have not
-yet been finalised.  How does this compare with the animation of the
-recursive version?
-
 The (implicit) stack shown only includes values for **n** and **p**.
 In an actual implemenetation the other argument, **G**, would also
 generally be on the stack.  What additional value(s) would also be on
 the stack?
 
 Given a graph with **N** nodes, what is the maximum height of the stack?
 
+Compare and contrast this DFS coding with the AIA iterative version of
+DFS (which has more exercises/exploration).
+

src/algorithms/extra-info/DIJKInfo.md

@@ -18,4 +18,19 @@ a:hover{
 Geeks for Geeks Link: [**Dijkstra's Algorithm**][G4GLink]
 
 
-[G4GLink]: https://www.geeksforgeeks.org/introduction-to-dijkstras-shortest-path-algorithm/
+[G4GLink]: https://www.geeksforgeeks.org/introduction-to-dijkstras-shortest-path-algorithm/
+
+## Exercises/Exploration
+
+Compare and contrast Dijkstra's algorithm with BFS in the case that all
+edges are the same length (edit the "SET EDGES/WEIGHTS" box to change
+weights and ensure "Weights" is set to "As input"; run BFS with the
+same graph).
+
+In AIA, the coding of various graph algorithms is designed to show
+their similarity. Iterative DFS, breadth first search, Dijkstra's
+shortest path algorithm, heuristic search and Prim's minimal spanning
+tree algorithm all have *identical* top-level pseudocode - check it out!
+Can you re-write the code for this and/or for other algorithms to make
+it as simple as possible, rather than emphasising similarity?
+

src/algorithms/extra-info/PRIMInfo.md

@@ -34,6 +34,13 @@ 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?
 
+In AIA, the coding of various graph algorithms is designed to show
+their similarity. Iterative DFS, breadth first search, Dijkstra's
+shortest path algorithm, heuristic search and Prim's minimal spanning
+tree algorithm all have *identical* top-level pseudocode - check it out!
+Can you re-write the code for this and/or for other algorithms to make
+it as simple as possible, rather than emphasising similarity?
+
 Compare and contrast how Prim's algorithm and Kruskal's algorithm operate
 to compute minimum spanning trees.