 Open in App
Not now

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

• Difficulty Level : Expert
• Last Updated : 05 Apr, 2022

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<``int``> 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<``int``> 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;``}`

## 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 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 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 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 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

 ``

Output:

```DRRUUURRUUR
DRRUUULLULLU
DRRDRRRD
DLDDL```

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

My Personal Notes arrow_drop_up