# Find paths from corner cell to middle cell in maze

Last Updated : 13 Apr, 2023

Given a square maze containing positive numbers, find all paths from a corner cell (any of the extreme four corners) to the middle cell. We can move exactly n steps from a cell in 4 directions i.e. North, East, West and South where n is value of the cell

We can move to mat[i+n][j], mat[i-n][j], mat[i][j+n], and mat[i][j-n] from a cell mat[i][j] where n is value of mat[i][j].

Example

Input:  9 x 9 maze
[ 3, 5, 4, 4, 7, 3, 4, 6, 3 ]
[ 6, 7, 5, 6, 6, 2, 6, 6, 2 ]
[ 3, 3, 4, 3, 2, 5, 4, 7, 2 ]
[ 6, 5, 5, 1, 2, 3, 6, 5, 6 ]
[ 3, 3, 4, 3, 0, 1, 4, 3, 4 ]
[ 3, 5, 4, 3, 2, 2, 3, 3, 5 ]
[ 3, 5, 4, 3, 2, 6, 4, 4, 3 ]
[ 3, 5, 1, 3, 7, 5, 3, 6, 4 ]
[ 6, 2, 4, 3, 4, 5, 4, 5, 1 ]

Output:
(0, 0) -> (0, 3) -> (0, 7) ->
(6, 7) -> (6, 3) -> (3, 3) ->
(3, 4) -> (5, 4) -> (5, 2) ->
(1, 2) -> (1, 7) -> (7, 7) ->
(7, 1) -> (2, 1) -> (2, 4) ->
(4, 4) -> MID

The idea is to use backtracking. We start with each corner cell of the maze and recursively checks if it leads to the solution or not. Following is the Backtracking algorithm â€“
If destination is reached

1. print the path

Else

1. Mark current cell as visited and add it to path array.
2. Move forward in all 4 allowed directions and recursively check if any of them leads to a solution.
3. If none of the above solutions work then mark this cell as not visited and remove it from path array.

Below is the implementation of the above approach:

## C++

 // C++ program to find a path from corner cell to // middle cell in maze containing positive numbers #include using namespace std;   // Rows and columns in given maze #define N 9   // check whether given cell is a valid cell or not. bool isValid(set > visited,              pair pt) {     // check if cell is not visited yet to     // avoid cycles (infinite loop) and its     // row and column number is in range     return (pt.first >= 0) && (pt.first  < N) &&            (pt.second >= 0) && (pt.second < N) &&            (visited.find(pt) == visited.end()); }   // Function to print path from source to middle coordinate void printPath(list > path) {     for (auto it = path.begin(); it != path.end(); it++)         cout << "(" << it->first << ", "              << it->second << ") -> ";       cout << "MID" << endl << endl; }   // For searching in all 4 direction int row[] = {-1, 1, 0, 0}; int col[] = { 0, 0, -1, 1};   // Coordinates of 4 corners of matrix int _row[] = { 0, 0, N-1, N-1}; int _col[] = { 0, N-1, 0, N-1};   void findPathInMazeUtil(int maze[N][N],                 list > &path,                 set > &visited,                 pair &curr) {     // If we have reached the destination cell.     // print the complete path     if (curr.first == N / 2 && curr.second == N / 2)     {         printPath(path);         return;     }       // consider each direction     for (int i = 0; i < 4; ++i)     {         // get value of current cell         int n = maze[curr.first][curr.second];           // We can move N cells in either of 4 directions         int x = curr.first + row[i]*n;         int y = curr.second + col[i]*n;           // Constructs a pair object with its first element         // set to x and its second element set to y         pair next = make_pair(x, y);           // if valid pair         if (isValid(visited, next))         {             // mark cell as visited             visited.insert(next);               // add cell to current path             path.push_back(next);               // recurse for next cell             findPathInMazeUtil(maze, path, visited, next);               // backtrack             path.pop_back();                           // remove cell from current path             visited.erase(next);         }     } }   // Function to find a path from corner cell to // middle cell in maze containing positive numbers void findPathInMaze(int maze[N][N]) {     // list to store complete path     // from source to destination     list > path;       // to store cells already visited in current path     set > visited;       // Consider each corners as the starting     // point and search in maze     for (int i = 0; i < 4; ++i)     {         int x = _row[i];         int y = _col[i];           // Constructs a pair object         pair pt = make_pair(x, y);           // mark cell as visited         visited.insert(pt);           // add cell to current path         path.push_back(pt);           findPathInMazeUtil(maze, path, visited, pt);           // backtrack         path.pop_back();           // remove cell from current path         visited.erase(pt);     } }   int main() {     int maze[N][N] =     {         { 3, 5, 4, 4, 7, 3, 4, 6, 3 },         { 6, 7, 5, 6, 6, 2, 6, 6, 2 },         { 3, 3, 4, 3, 2, 5, 4, 7, 2 },         { 6, 5, 5, 1, 2, 3, 6, 5, 6 },         { 3, 3, 4, 3, 0, 1, 4, 3, 4 },         { 3, 5, 4, 3, 2, 2, 3, 3, 5 },         { 3, 5, 4, 3, 2, 6, 4, 4, 3 },         { 3, 5, 1, 3, 7, 5, 3, 6, 4 },         { 6, 2, 4, 3, 4, 5, 4, 5, 1 }     };       findPathInMaze(maze);       return 0; }

## Python3

 # Python program to find a path from corner cell to # middle cell in maze containing positive numbers   # Rows and columns in given maze N = 9   # check whether given cell is a valid cell or not. def isValid(visited, pt):     # check if cell is not visited yet to     # avoid cycles (infinite loop) and its     # row and column number is in range     return (pt[0] >= 0) and (pt[0] < N) and (pt[1] >= 0) and (pt[1] < N) and (pt not in visited)   # Function to print path from source to middle coordinate def printPath(path):     for i in path:         print("({}, {}) -> ".format(i[0], i[1]), end="")     print("MID")     print()   # For searching in all 4 direction row = [-1, 1, 0, 0] col = [0, 0, -1, 1]   # Coordinates of 4 corners of matrix _row = [0, 0, N-1, N-1] _col = [0, N-1, 0, N-1]   def findPathInMazeUtil(maze, path, visited, curr):     # If we have reached the destination cell.     # print the complete path     if curr[0] == N // 2 and curr[1] == N // 2:         printPath(path)         return     # consider each direction     for i in range(4):         # get value of current cell         n = maze[curr[0]][curr[1]]         # We can move N cells in either of 4 directions         x = curr[0] + row[i]*n         y = curr[1] + col[i]*n         next = (x, y)         # if valid pair         if isValid(visited, next):             # mark cell as visited             visited.append(next)             # add cell to current path             path.append(next)             # recurse for next cell             findPathInMazeUtil(maze, path, visited, next)             # backtrack             # remove cell from current path             path.pop()             visited.remove(next)   # Function to find a path from corner cell to # middle cell in maze containing positive numbers def findPathInMaze(maze):     # list to store complete path     # from source to destination     path = []     # to store cells already visited in current path     visited = []       # Consider each corners as the starting     # point and search in maze     for i in range(4):         x = _row[i]         y = _col[i]         pt = (x, y)         # mark cell as visited         visited.append(pt)         # add cell to current path         path.append(pt)         findPathInMazeUtil(maze, path, visited, pt)         # backtrack         # remove cell from current path         path.pop()         visited.remove(pt)   if __name__ == "__main__":     maze = [         [3, 5, 4, 4, 7, 3, 4, 6, 3],         [6, 7, 5, 6, 6, 2, 6, 6, 2],         [3, 3, 4, 3, 2, 5, 4, 7, 2],         [6, 5, 5, 1, 2, 3, 6, 5, 6],         [3, 3, 4, 3, 0, 1, 4, 3, 4],         [3, 5, 4, 3, 2, 2, 3, 3, 5],         [3, 5, 4, 3, 2, 6, 4, 4, 3],         [3, 5, 1, 3, 7, 5, 3, 6, 4],         [6, 2, 4, 3, 4, 5, 4, 5, 1]     ]       findPathInMaze(maze)   # This code is contributed by Vikram_Shirsat

## C#

 using System; using System.Collections.Generic;   namespace MazePathFinder {     class Program     {         // Rows and columns in given maze         const int N = 9;           // check whether given cell is a valid cell or not.         static bool IsValid(List<(int, int)> visited, (int, int) pt)         {             // check if cell is not visited yet to             // avoid cycles (infinite loop) and its             // row and column number is in range             return (pt.Item1 >= 0) && (pt.Item1 < N) && (pt.Item2 >= 0) && (pt.Item2 < N) && (!visited.Contains(pt));         }           // Function to print path from source to middle coordinate         static void PrintPath(List<(int, int)> path)         {             foreach (var i in path)             {                 Console.Write(\$"({i.Item1}, {i.Item2}) -> ");             }             Console.WriteLine("MID");             Console.WriteLine();         }           // For searching in all 4 direction         static int[] row = { -1, 1, 0, 0 };         static int[] col = { 0, 0, -1, 1 };           // Coordinates of 4 corners of matrix         static int[] _row = { 0, 0, N - 1, N - 1 };         static int[] _col = { 0, N - 1, 0, N - 1 };           static void FindPathInMazeUtil(int[][] maze, List<(int, int)> path, List<(int, int)> visited, (int, int) curr)         {             // If we have reached the destination cell.             // print the complete path             if (curr.Item1 == N / 2 && curr.Item2 == N / 2)             {                 PrintPath(path);                 return;             }             // consider each direction             for (int i = 0; i < 4; i++)             {                 // get value of current cell                 int n = maze[curr.Item1][curr.Item2];                 // We can move N cells in either of 4 directions                 int x = curr.Item1 + row[i] * n;                 int y = curr.Item2 + col[i] * n;                 var next = (x, y);                 // if valid pair                 if (IsValid(visited, next))                 {                     // mark cell as visited                     visited.Add(next);                     // add cell to current path                     path.Add(next);                     // recurse for next cell                     FindPathInMazeUtil(maze, path, visited, next);                     // backtrack                     // remove cell from current path                     path.RemoveAt(path.Count - 1);                     visited.Remove(next);                 }             }         }           // Function to find a path from corner cell to         // middle cell in maze containing positive numbers         static void FindPathInMaze(int[][] maze)         {             // list to store complete path             // from source to destination             var path = new List<(int, int)>();             // to store cells already visited in current path             var visited = new List<(int, int)>();               // Consider each corners as the starting             // point and search in maze             for (int i = 0; i < 4; i++)             {                 int x = _row[i];                 int y = _col[i];                 var pt = (x, y);                              // mark cell as visited             visited.Add(pt);             // add cell to current path             path.Add(pt);             FindPathInMazeUtil(maze, path, visited, pt);             // backtrack             // remove cell from current path             path.RemoveAt(path.Count - 1);             visited.Remove(pt);         }     }       static void Main(string[] args)     {         int[][] maze = new int[][] {             new int[] {3, 5, 4, 4, 7, 3, 4, 6, 3},             new int[] {6, 7, 5, 6, 6, 2, 6, 6, 2},             new int[] {3, 3, 4, 3, 2, 5, 4, 7, 2},             new int[] {6, 5, 5, 1, 2, 3, 6, 5, 6},             new int[] {3, 3, 4, 3, 0, 1, 4, 3, 4},             new int[] {3, 5, 4, 3, 2, 2, 3, 3, 5},             new int[] {3, 5, 4, 3, 2, 6, 4, 4, 3},             new int[] {3, 5, 1, 3, 7, 5, 3, 6, 4},             new int[] {6, 2, 4, 3, 4, 5, 4, 5, 1}         };           FindPathInMaze(maze);     }   } }

## Javascript

 // JavaScript program to find a path from corner cell to // middle cell in maze containing positive numbers   // Rows and columns in given maze let N = 9;   // check whether given cell is a valid cell or not. function isValid(visited, pt) {           // check if cell is not visited yet to     // avoid cycles (infinite loop) and its     // row and column number is in range     return (pt[0] >= 0) && (pt[0] < N) && (pt[1] >= 0) && (pt[1] < N) &&     (!visited.some(item => item[0] === pt[0] && item[1] === pt[1])); }   // Function to print path from source to middle coordinate function printPath(path) {     let pathStr = "";     for (let i of path) {         pathStr += "(" + i[0] + ", " + i[1] + ") -> ";     }     pathStr += "MID";     console.log(pathStr);     console.log(); }   // For searching in all 4 direction const row = [-1, 1, 0, 0]; const col = [0, 0, -1, 1];   // Coordinates of 4 corners of matrix const _row = [0, 0, N-1, N-1]; const _col = [0, N-1, 0, N-1];   function findPathInMazeUtil(maze, path, visited, curr) {           // If we have reached the destination cell.     // print the complete path     if (curr[0] === Math.floor(N / 2) && curr[1] === Math.floor(N / 2)) {         printPath(path);         return;     }           // consider each direction     for (let i = 0; i < 4; i++) {                   // get value of current cell         let n = maze[curr[0]][curr[1]];                   // We can move N cells in either of 4 directions         let x = curr[0] + row[i]*n;         let y = curr[1] + col[i]*n;                   // Constructs a pair object with its first element         // set to x and its second element set to y         let next = [x, y];                   // if valid pair         if (isValid(visited, next)) {                           // mark cell as visited             visited.push(next);                           // add cell to current path             path.push(next);                           // recurse for next cell             findPathInMazeUtil(maze, path, visited, next);                           // backtrack             path.pop();                           // remove cell from current path             visited = visited.filter(item => item[0] !== next[0] || item[1] !== next[1]);         }     } }   // Function to find a path from corner cell to // middle cell in maze containing positive numbers function findPathInMaze(maze) {           // list to store complete path     // from source to destination     let path = [];           // to store cells already visited in current path     let visited = [];           // Consider each corners as the starting     // point and search in maze     for (let i = 0; i < 4; i++) {         let x = _row[i];         let y = _col[i];                   // Constructs a pair object         let pt = [x, y];                   // mark cell as visited         visited.push(pt);                   // add cell to current path         path.push(pt);                   findPathInMazeUtil(maze, path, visited, pt);                   // backtrack         path.pop();                   // remove cell from current path         visited = visited.filter(item => item[0] !== pt[0] || item[1] !== pt[1]);     } }   let maze = [         [3, 5, 4, 4, 7, 3, 4, 6, 3],         [6, 7, 5, 6, 6, 2, 6, 6, 2],         [3, 3, 4, 3, 2, 5, 4, 7, 2],         [6, 5, 5, 1, 2, 3, 6, 5, 6],         [3, 3, 4, 3, 0, 1, 4, 3, 4],         [3, 5, 4, 3, 2, 2, 3, 3, 5],         [3, 5, 4, 3, 2, 6, 4, 4, 3],         [3, 5, 1, 3, 7, 5, 3, 6, 4],         [6, 2, 4, 3, 4, 5, 4, 5, 1]     ] findPathInMaze(maze) // This code is contributed by prasad264

## Java

 import java.util.*;   public class MazePathFinder {       // Rows and columns in given maze     private static int N = 9;     // For searching in all 4 direction     private static int[] row = { -1, 1, 0, 0 };     private static int[] col = { 0, 0, -1, 1 };     // Coordinates of 4 corners of matrix     private static int[] _row = { 0, 0, N - 1, N - 1 };     private static int[] _col = { 0, N - 1, 0, N - 1 };       // check whether given cell is a valid cell or not.     private static boolean isValid(ArrayList visited,                                    int[] pt)     {         // check if cell is not visited yet to         // avoid cycles (infinite loop) and its         // row and column number is in range         return (pt[0] >= 0) && (pt[0] < N) && (pt[1] >= 0)             && (pt[1] < N)             && (!visited.stream().anyMatch(                 item                 -> item[0] == pt[0] && item[1] == pt[1]));     }     // Function to print path from source to middle     // coordinate     private static void printPath(ArrayList path)     {         String pathStr = "";         for (int[] i : path) {             pathStr += "(" + i[0] + ", " + i[1] + ") -> ";         }         pathStr += "MID";         System.out.println(pathStr);         System.out.println();     }       private static void     findPathInMazeUtil(int[][] maze, ArrayList path,                        ArrayList visited, int[] curr)     {         // If we have reached the destination cell.         // print the complete path         if (curr[0] == (N / 2) && curr[1] == (N / 2)) {             printPath(path);             return;         }         // consider each direction         for (int i = 0; i < 4; i++) {             // get value of current cell             int n = maze[curr[0]][curr[1]];             // We can move N cells in either of 4 directions             int x = curr[0] + row[i] * n;             int y = curr[1] + col[i] * n;             int[] next = { x, y };             // if valid pair             if (isValid(visited, next)) {                 // mark cell as visited                 visited.add(next);                 // add cell to current path                 path.add(next);                 // recurse for next cell                 findPathInMazeUtil(maze, path, visited,                                    next);                 // backtrack                 // remove cell from current path                 path.remove(path.size() - 1);                 visited.removeIf(item                                  -> item[0] == next[0]                                         && item[1]                                                == next[1]);             }         }     }     // Function to find a path from corner cell to     // middle cell in maze containing positive numbers     public static void findPathInMaze(int[][] maze)     {         // list to store complete path         // from source to destination         ArrayList path = new ArrayList<>();         // to store cells already visited in current path         ArrayList visited = new ArrayList<>();         // Consider each corners as the starting         // point and search in maze         for (int i = 0; i < 4; i++) {             int x = _row[i];             int y = _col[i];             int[] pt = { x, y };             // mark cell as visited             visited.add(pt);             // add cell to current path             path.add(pt);             findPathInMazeUtil(maze, path, visited, pt);             // backtrack             // remove cell from current path             path.remove(path.size() - 1);             visited.removeIf(item                              -> item[0] == pt[0]                                     && item[1] == pt[1]);         }     }     public static void main(String[] args)     {         // input maze         int[][] maze = { { 3, 5, 4, 4, 7, 3, 4, 6, 3 },                          { 6, 7, 5, 6, 6, 2, 6, 6, 2 },                          { 3, 3, 4, 3, 2, 5, 4, 7, 2 },                          { 6, 5, 5, 1, 2, 3, 6, 5, 6 },                          { 3, 3, 4, 3, 0, 1, 4, 3, 4 },                          { 3, 5, 4, 3, 2, 2, 3, 3, 5 },                          { 3, 5, 4, 3, 2, 6, 4, 4, 3 },                          { 3, 5, 1, 3, 7, 5, 3, 6, 4 },                          { 6, 2, 4, 3, 4, 5, 4, 5, 1 } };           // find path from corner cell to middle cell in the         // maze         findPathInMaze(maze);     } }

Output

(0, 0) -> (0, 3) -> (0, 7) -> (6, 7) -> (6, 3) -> (3, 3) -> (3, 4) -> (5, 4) -> (5, 2) -> (1, 2) -> (1, 7) -> (7, 7) -> (7, 1) -> (2, 1) -> (2, 4) -> (4, 4) -> MID

Output :

(0, 0) -> (0, 3) -> (0, 7) ->
(6, 7) -> (6, 3) -> (3, 3) ->
(3, 4) -> (5, 4) -> (5, 2) ->
(1, 2) -> (1, 7) -> (7, 7) ->
(7, 1) -> (2, 1) -> (2, 4) ->
(4, 4) -> MID

Time Complexity: O(4^N2), where N is the size of the maze and the program may need to explore all possible paths in the maze before finding the path from the corner to the middle cell.

Space Complexity: O(N2), where N*N is the size of the maze.

A better approach:

## C++

 // C++ program for the above approach #include using namespace std;   void printPath(vector>&maze, int i, int j, string ans){          // If we reach the center cell     if (i == maze.size()/2 && j==maze.size()/2){            // Make the final answer, Print the         // final answer and Return         ans += "(";         ans += to_string(i);         ans += ", ";         ans += to_string(j);         ans += ") -> MID";         cout<0){         printPath(maze, i, j-k, ans);     }        // up call     if (i-k>0){         printPath(maze, i-k, j, ans);     }            // Unmark the visited cell by substituting     // its original value from 'k'     maze[i][j] = k;   }   int main () {        // Creating the maze     vector>maze = {         { 3, 5, 4, 4, 7, 3, 4, 6, 3 },         { 6, 7, 5, 6, 6, 2, 6, 6, 2 },         { 3, 3, 4, 3, 2, 5, 4, 7, 2 },         { 6, 5, 5, 1, 2, 3, 6, 5, 6 },         { 3, 3, 4, 3, 0, 1, 4, 3, 4 },         { 3, 5, 4, 3, 2, 2, 3, 3, 5 },         { 3, 5, 4, 3, 2, 6, 4, 4, 3 },         { 3, 5, 1, 3, 7, 5, 3, 6, 4 },         { 6, 2, 4, 3, 4, 5, 4, 5, 1 }     };            // Calling the printPath function     printPath(maze,0,0,""); }   // This code is contributed by shinjanpatra

## Java

 // Java program to find a path from corner cell to // middle cell in maze containing positive numbers import java.io.*;   class GFG {     public static void main (String[] args) {           // Creating the maze         int[][] maze = {             { 3, 5, 4, 4, 7, 3, 4, 6, 3 },             { 6, 7, 5, 6, 6, 2, 6, 6, 2 },             { 3, 3, 4, 3, 2, 5, 4, 7, 2 },             { 6, 5, 5, 1, 2, 3, 6, 5, 6 },             { 3, 3, 4, 3, 0, 1, 4, 3, 4 },             { 3, 5, 4, 3, 2, 2, 3, 3, 5 },             { 3, 5, 4, 3, 2, 6, 4, 4, 3 },             { 3, 5, 1, 3, 7, 5, 3, 6, 4 },             { 6, 2, 4, 3, 4, 5, 4, 5, 1 }         };                   // Calling the printPath function         printPath(maze,0,0,"");     }           public static void printPath(int[][] maze, int i, int j, String ans){           // If we reach the center cell         if (i == maze.length/2 && j==maze.length/2){               // Make the final answer, Print the                 // final answer and Return             ans += "("+i+", "+j+") -> MID";             System.out.println(ans);             return;         }                   // If the element at the current position             // in maze is 0, simply Return as it has             // been visited before.         if (maze[i][j]==0){             return;         }                   // If element is non-zero, then note             // the element in variable 'k'         int k = maze[i][j];                   // Mark the cell visited by making the             // element 0. Don't worry, the element             // is safe in 'k'         maze[i][j]=0;                   // Make recursive calls in all 4             // directions pro-actively i.e. if the next             // cell lies in maze or not. Right call         if (j+k ");         }           // down call         if (i+k ");         }           // left call         if (j-k>0){             printPath(maze, i, j-k, ans+"("+i+", "+j+") -> ");         }           // up call         if (i-k>0){             printPath(maze, i-k, j, ans+"("+i+", "+j+") -> ");         }                   // Unmark the visited cell by substituting             // its original value from 'k'         maze[i][j] = k;     }                           }

## Python3

 # Python program to find a path from corner cell to # middle cell in maze containing positive numbers def printPath(maze, i, j, ans):       # If we reach the center cell     if (i == len(maze) // 2 and j == len(maze) // 2):           # Make the final answer, Print         # final answer and Return         ans += "(" + str(i) + ", " + str(j) + ") -> MID";         print(ans);         return;           # If the element at the current position     # in maze is 0, simply Return as it has     # been visited before.     if (maze[i][j] == 0):         return;           # If element is non-zero, then note     # the element in variable 'k'     k = maze[i][j];       # Mark the cell visited by making the     # element 0. Don't worry, the element     # is safe in 'k'     maze[i][j] = 0;       # Make recursive calls in all 4     # directions pro-actively i.e. if the next     # cell lies in maze or not. Right call     if (j + k < len(maze)):         printPath(maze, i, j + k, ans + "(" + str(i) + ", " + str(j) + ") -> ");           # down call     if (i + k < len(maze)):         printPath(maze, i + k, j, ans + "(" + str(i) + ", " + str(j) + ") -> ");           # left call     if (j - k > 0):         printPath(maze, i, j - k, ans + "(" + str(i) + ", " + str(j) + ") -> ");           # up call     if (i - k > 0):         printPath(maze, i - k, j, ans + "(" + str(i) + ", " + str(j) + ") -> ");           # Unmark the visited cell by substituting     # its original value from 'k'     maze[i][j] = k;       # Driver code if __name__ == '__main__':       # Creating the maze     maze = [[ 3, 5, 4, 4, 7, 3, 4, 6, 3 ],[ 6, 7, 5, 6, 6, 2, 6, 6, 2 ],[ 3, 3, 4, 3, 2, 5, 4, 7, 2 ],             [ 6, 5, 5, 1, 2, 3, 6, 5, 6 ],[ 3, 3, 4, 3, 0, 1, 4, 3, 4 ],[ 3, 5, 4, 3, 2, 2, 3, 3, 5 ],             [ 3, 5, 4, 3, 2, 6, 4, 4, 3 ],[ 3, 5, 1, 3, 7, 5, 3, 6, 4 ],[ 6, 2, 4, 3, 4, 5, 4, 5, 1 ]] ;       # Calling the printPath function     printPath(maze, 0, 0, "");   # This code contributed by gauravrajput1

## C#

 // C# program to find a path from corner // cell to middle cell in maze containing // positive numbers using System;   class GFG{   // Driver Code    public static void Main(String[] args) {           // Creating the maze     int[,] maze = {         { 3, 5, 4, 4, 7, 3, 4, 6, 3 },         { 6, 7, 5, 6, 6, 2, 6, 6, 2 },         { 3, 3, 4, 3, 2, 5, 4, 7, 2 },         { 6, 5, 5, 1, 2, 3, 6, 5, 6 },         { 3, 3, 4, 3, 0, 1, 4, 3, 4 },         { 3, 5, 4, 3, 2, 2, 3, 3, 5 },         { 3, 5, 4, 3, 2, 6, 4, 4, 3 },         { 3, 5, 1, 3, 7, 5, 3, 6, 4 },         { 6, 2, 4, 3, 4, 5, 4, 5, 1 }     };           // Calling the printPath function     printPath(maze, 0, 0, ""); }   public static void printPath(int[,] maze, int i,                              int j, String ans) {           // If we reach the center cell     if (i == maze.GetLength(0) / 2 &&         j == maze.GetLength(1) / 2)     {                   // Make the readonly answer, Print the         // readonly answer and Return         ans += "(" + i + ", " + j + ") -> MID";         Console.WriteLine(ans);         return;     }           // If the element at the current position     // in maze is 0, simply Return as it has     // been visited before.     if (maze[i, j] == 0)     {         return;     }           // If element is non-zero, then note     // the element in variable 'k'     int k = maze[i, j];           // Mark the cell visited by making the     // element 0. Don't worry, the element     // is safe in 'k'     maze[i, j] = 0;           // Make recursive calls in all 4     // directions pro-actively i.e. if the next     // cell lies in maze or not. Right call     if (j + k < maze.GetLength(1))     {         printPath(maze, i, j + k,                   ans + "(" + i +                   ", " + j + ") -> ");     }       // Down call     if (i + k < maze.GetLength(0))     {         printPath(maze, i + k, j,                   ans + "(" + i +                   ", " + j + ") -> ");     }       // Left call     if (j - k > 0)     {         printPath(maze, i, j - k,                   ans + "(" + i +                   ", " + j + ") -> ");     }       // Up call     if (i - k > 0)     {         printPath(maze, i - k, j,                   ans + "(" + i +                   ", " + j + ") -> ");     }           // Unmark the visited cell by substituting     // its original value from 'k'     maze[i, j] = k; } }   // This code is contributed by gauravrajput1

## Javascript



Output

(0, 0) -> (0, 3) -> (0, 7) ->
(6, 7) -> (6, 3) -> (3, 3) ->
(3, 4) -> (5, 4) -> (5, 2) ->
(1, 2) -> (1, 7) -> (7, 7) ->
(7, 1) -> (2, 1) -> (2, 4) ->
(4, 4) -> MID

Time Complexity: O(4^N2), where N is the size of the maze and the function makes recursive calls in all four directions, resulting in a branching factor of 4.

Space Complexity: O(N2), where N is the size of the maze. This is because the function uses a 2D vector to represent the maze, which has N^2 elements.

Previous Article
Next Article
Article Tags :
Practice Tags :