DFS++ mods - Linda's feedback

lee-naish · lee-naish · commit 0196ac3ea9e2 · 2024-05-29T16:47:28.000+10:00
diff --git a/src/algorithms/controllers/DFSrec.js b/src/algorithms/controllers/DFSrec.js
@@ -104,7 +104,7 @@ export default {
           // if p !== 0 the n-p has been highlighted in the for loop
           if (c_p !== 0) {
             // set edge to finalised if parent unassigned or it was
-            // previously finalised, otherwise bqack to frontier
+            // previously finalised, otherwise back to frontier
             if (c_nodes_etc[PAR][c_n] === unassigned ||
                 c_nodes_etc[PAR][c_n] === c_p ||
                 c_nodes_etc[PAR][c_p] === c_n) {
@@ -256,6 +256,7 @@ export default {
       parents.push(unassigned); 
     }
 
+    seen[startNode] = true; // moved before init
     chunker.add(
       'init',
       (vis, c_nodes_etc, c_n, c_m, c_stack) => {
@@ -265,15 +266,17 @@ export default {
           startNode, null, stack], 0
     );
 
-    seen[startNode] = true;
-    chunker.add(
-      'frontier_s',
-      (vis, c_nodes_etc, c_n, c_m, c_stack) => {
-        refresh(vis, c_nodes_etc, c_n, null, c_stack);
-      },
-      [[nodes, parents, seen],
-          startNode, null, stack], 0
-    );
+//  Previously a separate line
+//  seen[startNode] = true; // moved before init
+//  chunker.add(
+//    'frontier_s',
+//    (vis, c_nodes_etc, c_n, c_m, c_stack) => {
+//      refresh(vis, c_nodes_etc, c_n, null, c_stack);
+//    },
+//    [[nodes, parents, seen],
+//        startNode, null, stack], 0
+//  );
+
     let result = dfs1(startNode, 0, 0);
     chunker.add(
       'top_call',
diff --git a/src/algorithms/controllers/graphSearchColours.js b/src/algorithms/controllers/graphSearchColours.js
@@ -3,19 +3,22 @@
 //
 // OMG, colors for array and graph require different types and are
 // inconsistent!
+// Arrary: '0'=Blue, '1'=Green
+// Nodes: 1=Green, 4= Blue
+// Edges: 1=Green, 2=Orange, 3=Red, 4=Blue
 // XXX not sure how this interracts with color perception options -
 // doesn't seem to work like this - should figure out how it's done if
 // it's still supported
 export const colors = {
     FRONTIER_A: '0',  // Blue
     FRONTIER_N: 4,  // Blue
     FRONTIER_E: 4,  // Blue
-    N_M_E: 3, // Red - edge between n and m
+    N_M_E: 2, // edge between n and m
     FINALISED_A: '1', // Green
     FINALISED_N: 1, // Green
-    FINALISED_E: 2, // Orange
+    FINALISED_E: 1,
     PQ_MIN_A: '1', // XXX poor color but setting colors is a mystery
     // if we find a path to end node:
     SUCCESS_A: '1', // Green
-    SUCCESS_E: 1, // Green
+    SUCCESS_E: 3,
   }
diff --git a/src/algorithms/controllers/prim.js b/src/algorithms/controllers/prim.js
@@ -260,6 +260,15 @@ export default {
           99,
           (vis, v, c_miniIndex, c_cV, c_m, c_totalCost) => {
             refresh(vis, v, c_miniIndex, c_cV, c_m, c_totalCost);
+            // re-do finalised edges in success colour for extra highlight
+            for (let i = 0; i < numVertices; i++) {
+              for (let j = 0; j < numVertices; j++) {
+                if (v[PAR][i+1] === j+1) {
+                  vis.graph.removeEdgeColor(i, j);
+                  vis.graph.colorEdge(i, j, colors.SUCCESS_E);
+                }
+              }
+            }
           },
           [[nodes, parents, minCosts, finalCosts], null,
               null, null, totalCost]
@@ -314,6 +323,15 @@ export default {
           (vis, v, c_miniIndex, c_cV, c_m, c_totalCost) => {
             vis.graph.removeNodeColor(currentVertex);
             refresh(vis, v, c_miniIndex, c_cV, c_m, c_totalCost);
+            // re-do finalised edges in success colour for extra highlight
+            for (let i = 0; i < numVertices; i++) {
+              for (let j = 0; j < numVertices; j++) {
+                if (v[PAR][i+1] === j+1) {
+                  vis.graph.removeEdgeColor(i, j);
+                  vis.graph.colorEdge(i, j, colors.SUCCESS_E);
+                }
+              }
+            }
           },
           [[nodes, parents, minCosts, finalCosts], miniIndex,
               currentVertex, null, totalCost]
diff --git a/src/algorithms/explanations/BFSExp.md b/src/algorithms/explanations/BFSExp.md
@@ -58,8 +58,8 @@ data structures are needed.
 For consistency with other algorithm animations, the layout of the
 graph is on a two-dimensional grid where each node has (x,y) integer
 coordinates.  You can choose the start and end nodes and change the
-graph choice (see the instructions tab for more details).  Weights of
-edges can be included in the text box input but BFS will ignore weights
+graph choice (see the instructions tab for more details).  While weights of
+edges can be included in the text box input, BFS will ignore weights
 and positions of nodes.  Only a single end node is supported; choosing
 0 results in finding paths to all connected nodes.
 
diff --git a/src/algorithms/explanations/DFSExp.md b/src/algorithms/explanations/DFSExp.md
@@ -45,8 +45,8 @@ data structures are needed.
 For consistency with other algorithm animations, the layout of the
 graph is on a two-dimensional grid where each node has (x,y) integer
 coordinates.  You can choose the start and end nodes and change the
-graph choice (see the instructions tab for more details).  Weights of
-edges can be included in the text box input but DFS will ignore weights
+graph choice (see the instructions tab for more details).  While eights of
+edges can be included in the text box input, DFS will ignore weights
 and positions of nodes.  Only a single end node is supported; choosing
 0 results in finding paths to all connected nodes.
 
diff --git a/src/algorithms/index.js b/src/algorithms/index.js
@@ -107,23 +107,22 @@ const allalgs = {
     },
   },
 
-  'BFS': {
-    
-    name: 'Breadth First Search',
+  'DFSrec': {
+    name: 'Depth First Search',
     category: 'Graph',
-    param: <Param.BFSParam/>,
-    instructions: Instructions.BFSInstruction,
-    explanation: Explanation.BFSExp,
-    extraInfo: ExtraInfo.BFSInfo,
+    param: <Param.DFSrecParam />,
+    instructions: Instructions.DFSrecInstruction,
+    explanation: Explanation.DFSrecExp,
+    extraInfo: ExtraInfo.DFSrecInfo,
     pseudocode: {
-      find: Pseudocode.BFS,
+      find: Pseudocode.DFSrec,
     },
     controller: {
-      find: Controller.BFS,
+      find: Controller.DFSrec,
     },
   },
   'DFS': {
-    name: 'Depth First Search',
+    name: 'DFS (iterative)',
     category: 'Graph',
     param: <Param.DFSParam />,
     instructions: Instructions.DFSInstruction,
@@ -136,6 +135,21 @@ const allalgs = {
       find: Controller.DFS,
     },
   },
+  'BFS': {
+    
+    name: 'Breadth First Search',
+    category: 'Graph',
+    param: <Param.BFSParam/>,
+    instructions: Instructions.BFSInstruction,
+    explanation: Explanation.BFSExp,
+    extraInfo: ExtraInfo.BFSInfo,
+    pseudocode: {
+      find: Pseudocode.BFS,
+    },
+    controller: {
+      find: Controller.BFS,
+    },
+  },
   'dijkstra': {
     name: 'Dijkstra\'s (shortest path)',
     category: 'Graph',
@@ -196,20 +210,6 @@ const allalgs = {
       find: Controller.prim_old,
     },
   },
-  'DFSrec': {
-    name: 'DFS (recursive)',
-    category: 'Graph',
-    param: <Param.DFSrecParam />,
-    instructions: Instructions.DFSrecInstruction,
-    explanation: Explanation.DFSrecExp,
-    extraInfo: ExtraInfo.DFSrecInfo,
-    pseudocode: {
-      find: Pseudocode.DFSrec,
-    },
-    controller: {
-      find: Controller.DFSrec,
-    },
-  },
   'transitiveClosure': {
     name: 'Warshall\'s (transitive closure)',
     category: 'Graph',
diff --git a/src/algorithms/pseudocode/DFSrec.js b/src/algorithms/pseudocode/DFSrec.js
@@ -26,27 +26,25 @@ made explicit
 
 \\Code{
 Main
-DFS(G, n) // Given a graph G find a path from start node n to an \\B start
-        // end node.  It is assumed the end node(s) are defined
-        // separately; if there are no end nodes, paths to all connected
-        // nodes are found. Nodes are numbered 1..nmax. Returns the Parent[i]
-        // array, which gives the previous node in the path from n to i.
-        // Parent[n] = 0 and parents of unvisited nodes are null.
+DFS(G, n) // Given a graph G find a path from start node n to a \\B start
+        // separately defined end node; if there are no end nodes, paths
+        // to all connected nodes are found.
 \\In{
     initialise all parents to null \\B init
     \\Expl{ We initialise to some special value so we can later check if a
         parent has been assigned (we display null as an empty cell).
-    \\Expl}
-    // The start node is the implicit "frontier" initially \\B frontier_s
-    \\Expl{ For recursive DFS it is not necessary to understand the frontier.
-        We mention it just for comparison with the iterative version
-        of DFS and related graph search algorithms.
+        The start node is the implicit "frontier" for the top level DFS1
+        call. It is not
+        necessary to understand the frontier.  We mention it just for
+        comparison with the iterative version of DFS and related graph
+        search algorithms.
     \\Expl}
     result <- DFS1(G, n, 0) // recursive DFS with zero as parent node \\B top_call
     return result \\B finish
     \\Expl{ If there can be several end nodes we may want to
         return which one is found as well as the Parent array for
-        successful searches.  Here we highlight the path found in
+        successful searches (it defines a path from the end node back to
+        the start node).  Here we highlight the path found in
         the Parent array.
     \\Expl}
 \\In}
@@ -68,11 +66,12 @@ DFS1(G, n, p) // Search from node n using parent node p. This visits all \\B dfs
         \\In{
             return FOUND // Success! \\B found
             \\Expl{ If there can be several end nodes we may want to
-                return which one is found as well as the Parent array.
+                return which one is found as well as the Parent array,
+                which defined the path from the end node back to the start.
             \\Expl}
         \\In}
         // The neighbouring nodes are now part of the (implicit) frontier \\B frontier
-        \\Expl{ For recursive DFS it is not necessary to understand the frontier.
+        \\Expl{ It is not necessary to understand the frontier.
             We mention it just for comparison with the iterative version
             of DFS and related graph search algorithms. The neighbouring nodes
             will be checked via a recursive call in the loop below (finalised
