Print all paths from a source point to all the 4 corners of a Matrix

• Last Updated : 05 Oct, 2021

Given a 2D array arr[][] of size M*N containing 1s and 0s where 1 represents that the cell can be visited and 0s represent that the cell is blocked. There is a source point (x, y) and the task is to print all the paths from the given source to any of the four corners of the array (0, 0), (0, N – 1), (M – 1, 0) and (M – 1, N – 1).

Examples:

Input: arr[][] = {{1, 0, 0, 1, 0, 0, 1, 1}, {1, 1, 1, 0, 0, 0, 1, 0}, {1, 0, 1, 1, 1, 1, 1, 0}, {0, 0, 0, 0, 1, 0, 0, 0}, {1, 0, 1, 0, 1, 0, 0, 1}, {0, 1, 1, 1, 1, 0, 0, 1}, {0, 1, 0, 0, 1, 1, 1, 1}, {1, 1, 0, 0, 0, 0, 0, 1} }. source = {4, 2}
Output :  {“DRRUUURRUUR”, “DRRUUULLULLU”, “DRRDRRRD”, “DLDDL”}
Explanation :  All the possible paths from the source to the 4 corners are Input: arr[][] = {{0, 1, 0}, {0, 0, 0}, {0, 0, 0}}, source = {0, 1}
Output: No possible path

Approach: The idea is to use recursion and backtracking to find all possible paths by considering each possible path from a source to a destination and store it if it is a valid path. Follow the steps below to solve the problem:

• Initialize a vector of strings ans[] to store the answer.
• Recursively call the function to check in each of the 4 directions while pushing the current direction and making the cell visited.
• If either the pointer crosses the boundary or the cell to visit is not a valid cell i.e, its value is 0 then return.
• Otherwise, store the current cell and on reaching to any of the ends, then make it as one of the results.
• After performing the above steps, print the array ans[].

Below is the implementation of the above approach.

C++

 // C++ program for the above approach #include using namespace std;   struct direction {     int x, y;     char c; };   // Function to check if we reached on // of the entry/exit (corner) point. bool isCorner(int i, int j, int M, int N) {     if ((i == 0 && j == 0)         || (i == 0 && j == N - 1)         || (i == M - 1 && j == N - 1)         || (i == M - 1 && j == 0))         return true;       return false; }   // Function to check if the index is // within the matrix boundary. bool isValid(int i, int j, int M, int N) {     if (i < 0 || i >= M || j < 0 || j >= N)         return false;     return true; }   // Recursive helper function void solve(int i, int j, int M, int N,            direction dir[],            vector >& maze,            string& t, vector& ans) {       // If any corner is reached push the     // string t into ans and return     if (isCorner(i, j, M, N)) {         ans.push_back(t);         return;     }       // For all the four directions     for (int k = 0; k < 4; k++) {           // The new ith index         int x = i + dir[k].x;           // The new jth index         int y = j + dir[k].y;           // The direction R/L/U/D         char c = dir[k].c;           // If the new cell is within the         // matrix boundary and it is not         // previously visited in same path         if (isValid(x, y, M, N)             && maze[x][y] == 1) {               // Mark the new cell as visited             maze[x][y] = 0;               // Store the direction             t.push_back(c);               // Recur             solve(x, y, M, N, dir,                   maze, t, ans);               // Backtrack to explore             // other paths             t.pop_back();             maze[x][y] = 1;         }     }     return; }   // Function to find all possible paths vector possiblePaths(     vector src, vector >& maze) {     // Create a direction  array for all     // the four directions     direction dir = { { -1, 0, 'U' },                          { 0, 1, 'R' },                          { 1, 0, 'D' },                          { 0, -1, 'L' } };       // Stores the result     string temp;     vector ans;       solve(src, src, maze.size(),           maze.size(), dir,           maze, temp, ans);       return ans; }   // Driver Code int main() {       // Initializing the variables     vector > maze = {         { 1, 0, 0, 1, 0, 0, 1, 1 },         { 1, 1, 1, 0, 0, 0, 1, 0 },         { 1, 0, 1, 1, 1, 1, 1, 0 },         { 0, 0, 0, 0, 1, 0, 0, 0 },         { 1, 0, 1, 0, 1, 0, 0, 1 },         { 0, 1, 1, 1, 1, 0, 0, 1 },         { 0, 1, 0, 0, 1, 1, 1, 1 },         { 1, 1, 0, 0, 0, 0, 0, 1 },     };     vector src = { 4, 2 };       // Function Call     vector paths         = possiblePaths(src, maze);       // Print the result     if (paths.size() == 0) {         cout << "No Possible Paths";         return 0;     }       for (int i = 0; i < paths.size(); i++)         cout << paths[i] << endl;       return 0; }

Python3

 # Python program for the above approach   # Function to check if we reached on # of the entry/exit (corner) point. def isCorner(i, j, M, N):     if((i == 0 and j == 0) or (i == 0 and j == N-1) or (i == M-1 and j == N-1) or (i == M-1 and j == 0)):         return True     return False   # Function to check if the index is # within the matrix boundary. def isValid(i, j, M, N):     if(i < 0 or i >= M or j < 0 or j >= N):         return False     return True   # Recursive helper function def solve(i, j, M, N, Dir, maze, t, ans):         # If any corner is reached push the     # string t into ans and return     if(isCorner(i, j, M, N)):         ans.append(t)         return             # For all the four directions     for k in range(4):               # The new ith index         x = i + Dir[k]                   # The new jth index         y = j + Dir[k]                   # The direction R/L/U/D         c = Dir[k]                    # If the new cell is within the         # matrix boundary and it is not         # previously visited in same path         if(isValid(x, y, M, N) and maze[x][y] == 1):                       # mark the new cell visited             maze[x][y] = 0                           # Store the direction             t += c             solve(x, y, M, N, Dir, maze, t, ans)                            # Backtrack to explore             # other paths             t = t[: len(t)-1]             maze[x][y] = 1     return   # Function to find all possible paths def possiblePaths(src, maze):          # Create a direction  array for all     # the four directions     Dir = [[-1, 0, 'U'], [0, 1, 'R'], [1, 0, 'D'], [0, -1, 'L']]           # stores the result      temp = ""     ans = []     solve(src, src, len(maze), len(maze), Dir, maze, temp, ans)     return ans   # Driver code   # Initialise variable maze = [[1, 0, 0, 1, 0, 0, 1, 1],         [1, 1, 1, 0, 0, 0, 1, 0],         [1, 0, 1, 1, 1, 1, 1, 0],         [0, 0, 0, 0, 1, 0, 0, 0],         [1, 0, 1, 0, 1, 0, 0, 1],         [0, 1, 1, 1, 1, 0, 0, 1],         [0, 1, 0, 0, 1, 1, 1, 1],         [1, 1, 0, 0, 0, 0, 0, 1]] src = [4, 2]   # function call paths = possiblePaths(src, maze)   # Print the result if(len(paths) == 0):     print("No Possible Paths") else:     for i in paths:         print(i)   # This code is contributed by parthmanchanda81

Javascript



Output:

DRRUUURRUUR
DRRUUULLULLU
DRRDRRRD
DLDDL

Time Complexity: O(3(M*N))
Auxiliary Space: O(3(M*N))

My Personal Notes arrow_drop_up
Recommended Articles
Page :