Print all paths from a source point to all the 4 corners of a Matrix
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 <bits/stdc++.h> 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<vector< int > >& maze, string& t, vector<string>& 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<string> possiblePaths( vector< int > src, vector<vector< int > >& maze) { // Create a direction array for all // the four directions direction dir[4] = { { -1, 0, 'U' }, { 0, 1, 'R' }, { 1, 0, 'D' }, { 0, -1, 'L' } }; // Stores the result string temp; vector<string> ans; solve(src[0], src[1], maze.size(), maze[0].size(), dir, maze, temp, ans); return ans; } // Driver Code int main() { // Initializing the variables vector<vector< int > > 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< int > src = { 4, 2 }; // Function Call vector<string> 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; } |
Java
// Java program for the above approach import java.util.*; public class GFG { static class direction { int x, y; char c; direction( int x, int y, char c) { this .c = c; this .x = x; this .y = y; } }; // Function to check if we reached on // of the entry/exit (corner) point. static boolean 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. static boolean 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 static void solve( int i, int j, int M, int N, direction dir[], int [][] maze, String t, ArrayList<String> ans) { // If any corner is reached push the // string t into ans and return if (isCorner(i, j, M, N)) { ans.add(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 += c; // Recur solve(x, y, M, N, dir, maze, t, ans); // Backtrack to explore // other paths t = t.substring( 0 , t.length() - 1 ); maze[x][y] = 1 ; } } return ; } // Function to find all possible paths static ArrayList<String> possiblePaths( int [] src, int [][] maze) { // Create a direction array for all // the four directions direction[] dir = { new direction(- 1 , 0 , 'U' ), new direction( 0 , 1 , 'R' ), new direction( 1 , 0 , 'D' ), new direction( 0 , - 1 , 'L' ) }; // Stores the result String temp = "" ; ArrayList<String> ans = new ArrayList<>(); solve(src[ 0 ], src[ 1 ], maze.length, maze[ 0 ].length, dir, maze, temp, ans); return ans; } // Driver Code public static void main(String[] args) { // Initializing the variables int [][] 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 }, }; int [] src = { 4 , 2 }; // Function Call ArrayList<String> paths = possiblePaths(src, maze); // Print the result if (paths.size() == 0 ) { System.out.println( "No Possible Paths" ); return ; } for ( int i = 0 ; i < paths.size(); i++) { System.out.println(paths.get(i)); } } } // This code is contributed by Karandeep1234 |
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][ 0 ] # The new jth index y = j + Dir [k][ 1 ] # The direction R/L/U/D c = Dir [k][ 2 ] # 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[ 0 ], src[ 1 ], len (maze), len (maze[ 0 ]), 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
<script> // Javascript program for the above approach // Function to check if we reached on // of the entry/exit (corner) point. function isCorner(i, j, M, 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. function isValid(i, j, M, N) { if (i < 0 || i >= M || j < 0 || j >= N) return false ; return true ; } // Recursive helper function function 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.push(t); return ; } // For all the four directions for (let k = 0; k < 4; k++) { // The new ith index let x = i + Dir[k][0]; // The new jth index let y = j + Dir[k][1]; // The direction R/L/U/D let c = Dir[k][2]; // 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 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.substr(0, t.length - 1); maze[x][y] = 1; } } return ; } // Function to find all possible paths function possiblePaths(src, maze) { // Create a direction array for all // the four directions let Dir = [ [-1, 0, "U" ], [0, 1, "R" ], [1, 0, "D" ], [0, -1, "L" ], ]; // stores the result let temp = "" ; let ans = []; solve(src[0], src[1], maze.length, maze[0].length, Dir, maze, temp, ans); return ans; } // Driver code // Initialise variable let 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], ]; let src = [4, 2]; // function call let paths = possiblePaths(src, maze); // Print the result if (paths.length == 0) { document.write( "No Possible Paths" ); } else { for (let i = 0; i < paths.length; i++) { if (paths[i]) document.write(paths[i] + "<Br>" ); } } // This code is contributed by _saurabh_jaiswal </script> |
DRRUUURRUUR DRRUUULLULLU DRRDRRRD DLDDL
Time Complexity: O(3(M*N))
Auxiliary Space: O(3(M*N))
Please Login to comment...