Add RecursiveBacktracker algorithm

Author: Kartones

README.md

@@ -11,6 +11,7 @@ A small remark: Code is not a 1:1 copy of the book's. For example I built render
 - `AldousBroder`
 - `BinaryTree`
 - `HuntAndKill`
+- `RecursiveBacktracker`
 - `Sidewinder`
 - `Wilson`
 
@@ -96,7 +97,6 @@ Stats demo runs all available algorithms a certain number of times and gathers s
 Sample output:
 ```
 PYTHONPATH=. python3 demos/stats_demo.py 25 25 --pathfinding
-
 Rows: 25
 columns: 25
 Total cells: 625
@@ -105,29 +105,34 @@ Pathfinding: True
 > running AldousBroder
 > running BinaryTree
 > running HuntAndKill
+> running RecursiveBacktracker
 > running Sidewinder
 > running Wilson
 
-Average dead-ends (desc):
-     AldousBroder: 181/625 (29.01%)
-           Wilson: 181/625 (28.97%)
-       Sidewinder: 170/625 (27.12%)
-       BinaryTree: 156/625 (24.93%)
-      HuntAndKill: 062/625 (9.86%)
+Average dead-ends (deadends/total-cells, sorted by % desc):
+           AldousBroder: 182/625 (29.12%)
+                 Wilson: 181/625 (28.93%)
+             Sidewinder: 171/625 (27.29%)
+             BinaryTree: 156/625 (24.97%)
+   RecursiveBacktracker: 065/625 (10.47%)
+            HuntAndKill: 061/625 (9.73%)
 
 Generation speed benchmark (seconds, sorted by average desc):
-           Wilson: avg: 0.65727073 min: 0.22471986 max: 2.18292433
-      HuntAndKill: avg: 0.08903943 min: 0.07111554 max: 0.12254786
-     AldousBroder: avg: 0.03225283 min: 0.01685291 max: 0.08700121
-       Sidewinder: avg: 0.00232661 min: 0.00208164 max: 0.00273097
-       BinaryTree: avg: 0.00217227 min: 0.00209896 max: 0.00251945
+                 Wilson: avg: 0.641611 min: 0.235594 max: 2.173624
+            HuntAndKill: avg: 0.078919 min: 0.059095 max: 0.101278
+           AldousBroder: avg: 0.038898 min: 0.015946 max: 0.180922
+   RecursiveBacktracker: avg: 0.005492 min: 0.005383 max: 0.006105
+             BinaryTree: avg: 0.002130 min: 0.002074 max: 0.002359
+             Sidewinder: avg: 0.002105 min: 0.002039 max: 0.002320
 
 Pathfinding speed benchmark (seconds, sorted by average desc):
-      HuntAndKill: avg: 0.01336081 min: 0.01190879 max: 0.02201122
-       Sidewinder: avg: 0.01306345 min: 0.01151913 max: 0.02009250
-           Wilson: avg: 0.01259966 min: 0.01147151 max: 0.01936247
-     AldousBroder: avg: 0.01224201 min: 0.01164555 max: 0.01713539
-       BinaryTree: avg: 0.01185717 min: 0.01154452 max: 0.01265934
+           AldousBroder: avg: 0.014295 min: 0.011494 max: 0.035487
+   RecursiveBacktracker: avg: 0.012775 min: 0.012238 max: 0.014378
+            HuntAndKill: avg: 0.012100 min: 0.011589 max: 0.013740
+                 Wilson: avg: 0.011712 min: 0.011262 max: 0.013362
+             Sidewinder: avg: 0.011641 min: 0.011314 max: 0.013308
+             BinaryTree: avg: 0.011561 min: 0.011267 max: 0.013016
+
 ```
 
 ## Testing
@@ -137,3 +142,9 @@ Note: Runs also some linter tests, to conform with both `mypy` and `flake8`.
 ```
 pytest
 ```
+
+## Roadmap & TODOs
+
+- Of course finish the book and implement all main code and algorithms
+- Dockerize the project -> Will allow to upgrade to Python 3.6 and perform additional mypy cleanups & improvements
+- Implement more pathfinders -> (e.g. recursive backtracking as a maze solve algorithm)

algorithms/recursive_backtracker.py

@@ -0,0 +1,37 @@
+from random import choice
+
+from typing import Optional
+
+from base.grid import Grid
+from base.cell import Cell
+
+"""
+Recursive Backtracker algorithm picks a random starting cell and randomly walks. It cannot walk on an already visited
+cell, and if finds at a dead-end (no more unvisited cells around current one), goes back in its steps until has a cell
+at least one visited neighbor; then starts walking again.
+"""
+
+
+class RecursiveBacktracker:
+
+    @staticmethod
+    def on(grid: Grid, starting_cell: Optional[Cell] = None) -> Grid:
+        if starting_cell is None:
+            starting_cell = grid.random_cell()
+
+        # We'll use the list as a stack to do very easily any backtracking
+        walked_path = []
+        walked_path.append(starting_cell)
+
+        while len(walked_path) > 0:
+            current_cell = walked_path[-1]
+            unvisited_neighbors = [neighbor for neighbor in current_cell.neighbors if len(neighbor.links) == 0]
+
+            if len(unvisited_neighbors) == 0:
+                walked_path.pop()
+            else:
+                neighbor = choice(unvisited_neighbors)
+                current_cell.link(neighbor)
+                walked_path.append(neighbor)
+
+        return grid

algorithms/wilson.py

@@ -31,7 +31,7 @@ def on(grid: Grid) -> Grid:
                 cell = choice(cell.neighbors)
                 try:
                     position = path.index(cell)
-                    # already walked, perform loop-erase
+                    # already walked, perform loop-erase. e.g. A -> B -> C -> D -> B   becomes A -> B
                     path = path[:position + 1]
                 except ValueError:
                     path.append(cell)

demos/demo_utils.py

@@ -6,12 +6,13 @@
 from algorithms.aldous_broder import AldousBroder
 from algorithms.wilson import Wilson
 from algorithms.hunt_and_kill import HuntAndKill
+from algorithms.recursive_backtracker import RecursiveBacktracker
 
 import renderers.ascii_renderer as ASCIIRenderer
 import renderers.unicode_renderer as UNICODERenderer
 import renderers.png_renderer as PNGRenderer
 
-ALGORITHMS = [AldousBroder, BinaryTree, HuntAndKill, Sidewinder, Wilson]
+ALGORITHMS = [AldousBroder, BinaryTree, HuntAndKill, RecursiveBacktracker, Sidewinder, Wilson]
 ALL_RENDERERS = [UNICODERenderer, ASCIIRenderer, PNGRenderer]
 
 

demos/stats_demo.py

@@ -88,20 +88,20 @@ def get_tries() -> int:
         }
 
     sorted_averages = sorted(algorithm_averages.items(), key=lambda x: -x[1])
-    print("\nAverage dead-ends (desc):")
+    print("\nAverage dead-ends (deadends/total-cells, sorted by % desc):")
     for algorithm, average in sorted_averages:
         percentage = average * 100.0 / size
-        print(" {:>16}: {:03.0f}/{:03d} ({:.2f}%)".format(algorithm.__name__, average, size, percentage))
+        print(" {:>22}: {:03.0f}/{:03d} ({:.2f}%)".format(algorithm.__name__, average, size, percentage))
 
     sorted_benchmarks = sorted(algorithm_benchmarks.items(), key=lambda x: -x[1]["average"])
     print("\nGeneration speed benchmark (seconds, sorted by average desc):")
     for algorithm, benchmark in sorted_benchmarks:
-        print(" {:>16}: avg: {:03.8f} min: {:03.8f} max: {:03.8f}".format(algorithm.__name__, benchmark["average"],
+        print(" {:>22}: avg: {:03.6f} min: {:03.6f} max: {:03.6f}".format(algorithm.__name__, benchmark["average"],
               benchmark["min"], benchmark["max"]))
 
     if pathfinding:
         sorted_pathfinding_benchmarks = sorted(pathfinding_benchmarks.items(), key=lambda x: -x[1]["average"])
         print("\nPathfinding speed benchmark (seconds, sorted by average desc):")
         for algorithm, benchmark in sorted_pathfinding_benchmarks:
-            print(" {:>16}: avg: {:03.8f} min: {:03.8f} max: {:03.8f}".format(algorithm.__name__, benchmark["average"],
+            print(" {:>22}: avg: {:03.6f} min: {:03.6f} max: {:03.6f}".format(algorithm.__name__, benchmark["average"],
                   benchmark["min"], benchmark["max"]))

renderers/unicode_renderer.py

@@ -7,7 +7,6 @@
 #    N        1
 #  W   E    2   4
 #    S        8
-
 JUNCTIONS = [" ", " ", " ", "\u251b", " ", "\u2517", "\u2501", "\u253b", " ", "\u2503", "\u2513", "\u252b", "\u250f",
              "\u2523", "\u2533", "\u254b"]
 
@@ -77,7 +76,7 @@ def get_topmost_junction(cell: Cell) -> str:
 
 
 def get_south_east_junction(cell: Cell) -> str:
-    # Taking advantage that we always go forward     east and south, just need to calculate available posibilities
+    # Taking advantage that we always go forward east and south, just need to calculate available posibilities
     #
     #    [ X ]      [X-east]
     #