[UPDATE] TheAlgorithms#9066 Rate_in_Maze.py

Author: Muhammadummerr

backtracking/rat_in_maze.py

@@ -4,13 +4,15 @@
 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 (0s) and open paths (1s).
+        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 +26,9 @@ 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],
@@ -59,18 +64,22 @@ def solve_maze(maze: list[list[int]]) -> bool:
     No solution exists!
     False
     """
-    size = len(maze)
     # We need to create solution object to save path.
+    size = len(maze)
+    source_row=0
+    source_column=0
+    destination_row=size-1
+    destination_column=size-1
     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 +93,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 +109,10 @@ 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
 
@@ -112,6 +121,7 @@ def run_maze(maze: list[list[int]], i: int, j: int, solutions: list[list[int]])
     return False
 
 
+
 if __name__ == "__main__":
     import doctest