[UPDATED]rat_in_maze.py

backtracking/rat_in_maze.py

@@ -4,13 +4,17 @@
 def solve_maze(maze: list[list[int]]) -> bool:
     """
     This method solves the "rat in maze" problem.
-    In this problem we have some n by n matrix, a start point and an end point.
-    We want to go from the start to the end. In this matrix zeroes represent walls
-    and ones paths we can use.
     Parameters :
         maze(2D matrix) : maze
     Returns:
         Return: True if the maze has a solution or False if it does not.
+    Description:
+        This method navigates through a maze represented as an n by n matrix,
+        starting from a specified source cell (default: top-left corner) and
+        aiming to reach a destination cell (default: bottom-right corner).
+        The maze consists of walls (1s) and open paths (0s).
+        By providing custom row and column values, the source and destination
+        cells can be adjusted.
     >>> maze = [[0, 1, 0, 1, 1],
     ...         [0, 0, 0, 0, 0],
     ...         [1, 0, 1, 0, 1],
@@ -24,6 +28,10 @@ def solve_maze(maze: list[list[int]]) -> bool:
     [0, 0, 0, 0, 1]
     True
 
+    Note:
+        In the output maze, the ones (1s) represent one of the possible
+        paths from the source to the destination.
+
     >>> maze = [[0, 1, 0, 1, 1],
     ...         [0, 0, 0, 0, 0],
     ...         [0, 0, 0, 0, 1],
@@ -60,17 +68,30 @@ def solve_maze(maze: list[list[int]]) -> bool:
     False
     """
     size = len(maze)
+    source_row = 0
+    source_column = 0
+    destination_row = size - 1
+    destination_column = size - 1
     # We need to create solution object to save path.
     solutions = [[0 for _ in range(size)] for _ in range(size)]
-    solved = run_maze(maze, 0, 0, solutions)
+    solved = run_maze(
+        maze, source_row, source_column, destination_row, destination_column, solutions
+    )
     if solved:
         print("\n".join(str(row) for row in solutions))
     else:
         print("No solution exists!")
     return solved
 
 
-def run_maze(maze: list[list[int]], i: int, j: int, solutions: list[list[int]]) -> bool:
+def run_maze(
+    maze: list[list[int]],
+    i: int,
+    j: int,
+    destination_row: int,
+    destination_column: int,
+    solutions: list[list[int]],
+) -> bool:
     """
     This method is recursive starting from (i, j) and going in one of four directions:
     up, down, left, right.
@@ -84,7 +105,7 @@ def run_maze(maze: list[list[int]], i: int, j: int, solutions: list[list[int]])
     """
     size = len(maze)
     # Final check point.
-    if i == j == (size - 1):
+    if i == destination_row and j == destination_column:
         solutions[i][j] = 1
         return True
 
@@ -100,10 +121,16 @@ def run_maze(maze: list[list[int]], i: int, j: int, solutions: list[list[int]])
 
             # check for directions
             if (
-                run_maze(maze, i + 1, j, solutions)
-                or run_maze(maze, i, j + 1, solutions)
-                or run_maze(maze, i - 1, j, solutions)
-                or run_maze(maze, i, j - 1, solutions)
+                run_maze(maze, i + 1, j, destination_row, destination_column, solutions)
+                or run_maze(
+                    maze, i, j + 1, destination_row, destination_column, solutions
+                )
+                or run_maze(
+                    maze, i - 1, j, destination_row, destination_column, solutions
+                )
+                or run_maze(
+                    maze, i, j - 1, destination_row, destination_column, solutions
+                )
             ):
                 return True