Print all possible paths from top left to bottom right of a mXn matrix

• Difficulty Level : Medium
• Last Updated : 09 Dec, 2021

The problem is to print all the possible paths from top left to bottom right of a mXn matrix with the constraints that from each cell you can either move only to right or down.

Examples :

Input : 1 2 3
4 5 6
Output : 1 4 5 6
1 2 5 6
1 2 3 6

Input : 1 2
3 4
Output : 1 2 4
1 3 4

The algorithm is a simple recursive algorithm, from each cell first print all paths by going down and then print all paths by going right. Do this recursively for each cell encountered.

Following are implementation of the above algorithm.

C++

 // C++ program to Print all possible paths from// top left to bottom right of a mXn matrix#include using namespace std; /* mat:  Pointer to the starting of mXn matrix   i, j: Current position of the robot (For the first call use 0,0)   m, n: Dimensions of given the matrix   pi:   Next index to be filed in path array   *path[0..pi-1]: The path traversed by robot till now (Array to hold the                  path need to have space for at least m+n elements) */void printAllPathsUtil(int *mat, int i, int j, int m, int n, int *path, int pi){    // Reached the bottom of the matrix so we are left with    // only option to move right    if (i == m - 1)    {        for (int k = j; k < n; k++)            path[pi + k - j] = *((mat + i*n) + k);        for (int l = 0; l < pi + n - j; l++)            cout << path[l] << " ";        cout << endl;        return;    }     // Reached the right corner of the matrix we are left with    // only the downward movement.    if (j == n - 1)    {        for (int k = i; k < m; k++)            path[pi + k - i] = *((mat + k*n) + j);        for (int l = 0; l < pi + m - i; l++)            cout << path[l] << " ";        cout << endl;        return;    }     // Add the current cell to the path being generated    path[pi] = *((mat + i*n) + j);     // Print all the paths that are possible after moving down    printAllPathsUtil(mat, i+1, j, m, n, path, pi + 1);     // Print all the paths that are possible after moving right    printAllPathsUtil(mat, i, j+1, m, n, path, pi + 1);     // Print all the paths that are possible after moving diagonal    // printAllPathsUtil(mat, i+1, j+1, m, n, path, pi + 1);} // The main function that prints all paths from top left to bottom right// in a matrix 'mat' of size mXnvoid printAllPaths(int *mat, int m, int n){    int *path = new int[m+n];    printAllPathsUtil(mat, 0, 0, m, n, path, 0);} // Driver program to test above functionsint main(){    int mat = { {1, 2, 3}, {4, 5, 6} };    printAllPaths(*mat, 2, 3);    return 0;}

Java

 import java.util.*;// Java program to Print all possible paths from// top left to bottom right of a mXn matrixpublic class MatrixTraversal{        private static void printMatrix(int mat[][], int m, int n,                                    int i, int j, List list)    {          //return if i or j crosses matrix size        if(i > m || j > n)            return;        list.add(mat[i][j]);        if(i == m && j == n){            System.out.println(list);        }        printMatrix(mat, m, n, i+1, j, list);        printMatrix(mat, m, n, i, j+1, list);        list.remove(list.size()-1);                      }         // Driver code    public static void main(String[] args)    {        int m = 2;        int n = 3;        int mat[][] = { { 1, 2, 3 },                        { 4, 5, 6 } };          List list = new ArrayList<>();        printMatrix(mat, m-1, n-1, 0, 0, list);    }}//This article is contributed by Harneet

Python3

 # Python3 program to Print all possible paths from# top left to bottom right of a mXn matrix '''/* mat: Pointer to the starting of mXn matrixi, j: Current position of the robot     (For the first call use 0, 0)m, n: Dimensions of given the matrixpi: Next index to be filed in path array*path[0..pi-1]: The path traversed by robot till now                (Array to hold the path need to have                 space for at least m+n elements) */'''def printAllPathsUtil(mat, i, j, m, n, path, pi):     # Reached the bottom of the matrix    # so we are left with only option to move right    if (i == m - 1):        for k in range(j, n):            path[pi + k - j] = mat[i][k]         for l in range(pi + n - j):            print(path[l], end = " ")        print()        return     # Reached the right corner of the matrix    # we are left with only the downward movement.    if (j == n - 1):         for k in range(i, m):            path[pi + k - i] = mat[k][j]         for l in range(pi + m - i):            print(path[l], end = " ")        print()        return     # Add the current cell    # to the path being generated    path[pi] = mat[i][j]     # Print all the paths    # that are possible after moving down    printAllPathsUtil(mat, i + 1, j, m, n, path, pi + 1)     # Print all the paths    # that are possible after moving right    printAllPathsUtil(mat, i, j + 1, m, n, path, pi + 1)     # Print all the paths    # that are possible after moving diagonal    # printAllPathsUtil(mat, i+1, j+1, m, n, path, pi + 1); # The main function that prints all paths# from top left to bottom right# in a matrix 'mat' of size mXndef printAllPaths(mat, m, n):     path = [0 for i in range(m + n)]    printAllPathsUtil(mat, 0, 0, m, n, path, 0) # Driver Codemat = [[1, 2, 3],       [4, 5, 6]] printAllPaths(mat, 2, 3) # This code is contributed by Mohit Kumar

C#

 // C# program to Print all possible paths from// top left to bottom right of a mXn matrixusing System;     public class MatrixTraversal{      /* mat: Pointer to the starting of mXn matrixi, j: Current position of the robot (For the first call use 0,0)m, n: Dimensions of given the matrixpi: Next index to be filed in path array*path[0..pi-1]: The path traversed by robot till now (Array to hold the                path need to have space for at least m+n elements) */    private static void printMatrix(int [,]mat, int m, int n,                                    int i, int j, int []path, int idx)    {        path[idx] = mat[i,j];                 // Reached the bottom of the matrix so we are left with        // only option to move right        if (i == m - 1)        {            for (int k = j + 1; k < n; k++)            {                path[idx + k - j] = mat[i,k];            }            for (int l = 0; l < idx + n - j; l++)            {                Console.Write(path[l] + " ");            }            Console.WriteLine();            return;        }                 // Reached the right corner of the matrix we are left with        // only the downward movement.        if (j == n - 1)        {            for (int k = i + 1; k < m; k++)            {                path[idx + k - i] = mat[k,j];            }            for (int l = 0; l < idx + m - i; l++)            {                Console.Write(path[l] + " ");            }            Console.WriteLine();            return;        }                 // Print all the paths that are possible after moving down        printMatrix(mat, m, n, i + 1, j, path, idx + 1);         // Print all the paths that are possible after moving right        printMatrix(mat, m, n, i, j + 1, path, idx + 1);    }         // Driver code    public static void Main(String[] args)    {        int m = 2;        int n = 3;        int [,]mat = { { 1, 2, 3 },                        { 4, 5, 6 } };        int maxLengthOfPath = m + n - 1;        printMatrix(mat, m, n, 0, 0, new int[maxLengthOfPath], 0);    }} // This code contributed by Rajput-Ji

Javascript


Output
1 4 5 6
1 2 5 6
1 2 3 6

Note that in the above code, the last line of printAllPathsUtil() is commented, If we uncomment this line, we get all the paths from the top left to bottom right of a nXm matrix if the diagonal movements are also allowed. And also if moving to some of the cells are not permitted then the same code can be improved by passing the restriction array to the above function and that is left as an exercise.

C++

 // C++ program to Print all possible paths from // top left to bottom right of a mXn matrix#include using namespace std; vector> allPaths; void findPathsUtil(vector> maze, int m,                                 int n, int i, int j,                          vector path, int index){         // If we reach the bottom of maze,    // we can only move right    if (i == m - 1)    {        for(int k = j; k < n; k++)        {                         //path.append(maze[i][k])            path[index + k - j] = maze[i][k];        }                 // If we hit this block, it means one        // path is completed. Add it to paths        // list and print        cout << "[" << path << ", ";        for(int z = 1; z < path.size() - 1; z++)        {            cout << path[z] << ", ";        }        cout << path[path.size() - 1] << "]" << endl;        allPaths.push_back(path);        return;    }             // If we reach to the right most    // corner, we can only move down    if (j == n - 1)    {        for(int k = i; k < m; k++)        {            path[index + k - i] = maze[k][j];        }                 //path.append(maze[j][k])        // If we hit this block, it means one        // path is completed. Add it to paths        // list and print        cout << "[" << path << ", ";        for(int z = 1; z < path.size() - 1; z++)        {            cout << path[z] << ", ";        }        cout << path[path.size() - 1] << "]" << endl;        allPaths.push_back(path);        return;    }           // Add current element to the path list    //path.append(maze[i][j])    path[index] = maze[i][j];           // Move down in y direction and call    // findPathsUtil recursively    findPathsUtil(maze, m, n, i + 1,                  j, path, index + 1);           // Move down in y direction and    // call findPathsUtil recursively    findPathsUtil(maze, m, n, i, j + 1,                        path, index + 1);}     void findPaths(vector> maze,                       int m, int n){    vector path(m + n - 1, 0);    findPathsUtil(maze, m, n, 0, 0, path, 0);} // Driver Codeint main(){    vector> maze{ { 1, 2, 3 },                              { 4, 5, 6 },                              { 7, 8, 9 } };    findPaths(maze, 3, 3);         //print(allPaths)    return 0;} // This code is contributed by divyeshrabadiya07

Java

 // Java program to Print all possible paths from // top left to bottom right of a mXn matriximport java.io.*;import java.util.*;class GFG{  static ArrayList> allPaths =    new ArrayList>();  static void findPathsUtil(ArrayList> maze,                            int m, int n, int i,int j,                            ArrayList path,int index)  {     // If we reach the bottom of maze,    // we can only move right    if(i == m - 1)    {      for(int k = j; k < n; k++)      {         // path.append(maze[i][k])        path.set(index + k - j, maze.get(i).get(k));       }       // If we hit this block, it means one      // path is completed. Add it to paths      // list and print      System.out.print("[" + path.get(0) + ", ");      for(int z = 1; z < path.size() - 1; z++)      {        System.out.print(path.get(z) + ", ");      }      System.out.println(path.get(path.size() - 1) + "]");      allPaths.add(path);      return;    }     // If we reach to the right most    // corner, we can only move down    if(j == n - 1)    {      for(int k = i; k < m; k++)      {        path.set(index + k - i,maze.get(k).get(j));      }       // path.append(maze[j][k])      // If we hit this block, it means one      // path is completed. Add it to paths      // list and print      System.out.print("[" + path.get(0) + ", ");      for(int z = 1; z < path.size() - 1; z++)      {        System.out.print(path.get(z) + ", ");       }      System.out.println(path.get(path.size() - 1) + "]");      allPaths.add(path);      return;    }     // Add current element to the path list    //path.append(maze[i][j])    path.set(index,maze.get(i).get(j));     // Move down in y direction and call    // findPathsUtil recursively    findPathsUtil(maze, m, n, i + 1, j, path, index + 1);     // Move down in y direction and    // call findPathsUtil recursively    findPathsUtil(maze, m, n, i, j + 1, path, index + 1);   }  static void findPaths(ArrayList> maze,                        int m, int n)  {    ArrayList path = new ArrayList();    for(int i = 0; i < m + n - 1; i++)    {      path.add(0);    }    findPathsUtil(maze, m, n, 0, 0, path, 0);  }   // Driver code  public static void main (String[] args)  {    ArrayList> maze =      new ArrayList>();    maze.add(new ArrayList             (Arrays.asList(1,2,3)));    maze.add(new ArrayList             (Arrays.asList(4,5,6)));    maze.add(new ArrayList             (Arrays.asList(7,8,9)));     findPaths(maze, 3, 3);         }} // This code is contributed by avanitrachhadiya2155

Python3

 # Python3 program to Print all possible paths from# top left to bottom right of a mXn matrixallPaths = []def findPaths(maze,m,n):    path = [0 for d in range(m+n-1)]    findPathsUtil(maze,m,n,0,0,path,0)     def findPathsUtil(maze,m,n,i,j,path,index):    global allPaths    # if we reach the bottom of maze, we can only move right    if i==m-1:        for k in range(j,n):            #path.append(maze[i][k])            path[index+k-j] = maze[i][k]        # if we hit this block, it means one path is completed.        # Add it to paths list and print        print(path)        allPaths.append(path)        return    # if we reach to the right most corner, we can only move down    if j == n-1:        for k in range(i,m):            path[index+k-i] = maze[k][j]          #path.append(maze[j][k])        # if we hit this block, it means one path is completed.        # Add it to paths list and print        print(path)        allPaths.append(path)        return         # add current element to the path list    #path.append(maze[i][j])    path[index] = maze[i][j]         # move down in y direction and call findPathsUtil recursively    findPathsUtil(maze, m, n, i+1, j, path, index+1)         # move down in y direction and call findPathsUtil recursively    findPathsUtil(maze, m, n, i, j+1, path, index+1) if __name__ == '__main__':    maze = [[1,2,3],            [4,5,6],            [7,8,9]]    findPaths(maze,3,3)    #print(allPaths)

C#

 // C# program to Print all possible paths from // top left to bottom right of a mXn matrixusing System;using System.Collections.Generic;class GFG{       static List> allPaths = new List>();      static void findPathsUtil(List> maze,                              int m, int n, int i,                              int j, List path,                              int index)    {                  // If we reach the bottom of maze,        // we can only move right        if (i == m - 1)        {            for(int k = j; k < n; k++)            {                                  // path.append(maze[i][k])                path[index + k - j] = maze[i][k];            }                          // If we hit this block, it means one            // path is completed. Add it to paths            // list and print            Console.Write( "[" + path + ", ");            for(int z = 1; z < path.Count - 1; z++)            {                Console.Write(path[z] + ", ");            }            Console.WriteLine(path[path.Count - 1] + "]");            allPaths.Add(path);            return;        }                      // If we reach to the right most        // corner, we can only move down        if (j == n - 1)        {            for(int k = i; k < m; k++)            {                path[index + k - i] = maze[k][j];            }                          // path.append(maze[j][k])            // If we hit this block, it means one            // path is completed. Add it to paths            // list and print            Console.Write( "[" + path + ", ");            for(int z = 1; z < path.Count - 1; z++)            {                Console.Write(path[z] + ", ");            }            Console.WriteLine(path[path.Count - 1] + "]");            allPaths.Add(path);             return;        }                    // Add current element to the path list        //path.append(maze[i][j])        path[index] = maze[i][j];                    // Move down in y direction and call        // findPathsUtil recursively        findPathsUtil(maze, m, n, i + 1,                      j, path, index + 1);                    // Move down in y direction and        // call findPathsUtil recursively        findPathsUtil(maze, m, n, i, j + 1,                            path, index + 1);    }              static void findPaths(List> maze, int m, int n)    {        List path = new List();        for(int i = 0; i < m + n - 1; i++)        {            path.Add(0);        }        findPathsUtil(maze, m, n, 0, 0, path, 0);    }   // Driver code  static void Main()  {    List> maze = new List>();    maze.Add(new List { 1, 2, 3 });    maze.Add(new List { 4, 5, 6 });    maze.Add(new List { 7, 8, 9 });     findPaths(maze, 3, 3);  }} // This code is contributed by divyesh072019
Output
[1, 4, 7, 8, 9]
[1, 4, 5, 8, 9]
[1, 4, 5, 6, 9]
[1, 2, 5, 8, 9]
[1, 2, 5, 6, 9]
[1, 2, 3, 6, 9]

Note all the above approach take some extra time and space for solving the problem ,we can simply use backtracking algorithm to solve problem in optimized manner

C++

 #includeusing namespace std; // function to display the pathvoid display(vector &ans) {  for(auto i :ans ) {    cout<>& visited,int n,int m) {  return (r < n and c > &grid,int r,int c, int n,int m,vector &ans) {  // when we hit the last cell we reach to destination then directly push the path  if(r == n-1 and c == m-1) {    ans.push_back(grid[r]);    display(ans);  // function to display the path stored in ans vector    ans.pop_back(); // pop back because we need to backtrack to explore more path    return ;  }      // we will store the current value in ch and mark the visited place as -1  int ch = grid[r];    ans.push_back(ch); // push the path in ans array  grid[r] = -1;  // mark the visited place with -1     // if is it safe to take next downward step then take it  if(issafe(r+1,c,grid,n,m)) {    FindPaths(grid,r+1,c,n,m,ans);  }     // if is it safe to take next rightward step then take it  if(issafe(r,c+1,grid,n,m)) {    FindPaths(grid,r,c+1,n,m,ans);  }     // backtracking step we need to make values original so to we can visit it by some another path  grid[r] = ch;     // remove the current path element we explore  ans.pop_back();  return ;} int main() {      int n = 3 ,m =3;      vector >grid{ {1,2,3},{4,5,6},{7,8,9}};      vectorans ; // it will store the path which we have covered             FindPaths(grid,0,0,n,m,ans); // here 0,0 are initial position to start with    return 0;}
Output
1 4 7 8 9
1 4 5 8 9
1 4 5 6 9
1 2 5 8 9
1 2 5 6 9
1 2 3 6 9

So by these method you can optimized your code.

TC- O(2^n*m)   , SC – O(n)

Another Approach (Iterative) :

1. In this approach we will use BFS (breadth first search) to find all possible paths.

2. We will make a queue which contains the following information :

a)  Vector that stores the path up to a certain cell.

b)  coordinates of the cell.

3. We will start from the top-left cell and push cell value and coordinates in the queue.

4. We will keep on exploring right and down cell (if possible) until queue is not empty

and push them in the queue by updating the current cell vector.

5. If we reach the last cell then we have got one answer and we will print the answer vector.

C++

 // c++ implementation for the above approach#include using namespace std; // this structure stores information// about a particular cell i.e// path upto that cell and cell's// coordinatesstruct info {    vector path;    int i;    int j;}; void printAllPaths(vector >& maze){    int n = maze.size();    int m = maze.size();     queue q;    // pushing top-left cell into the queue    q.push({ { maze }, 0, 0 });     while (!q.empty()) {        info p = q.front();        q.pop();         // if we reached the bottom-right cell        // i.e the destination then print the path        if (p.i == n - 1 && p.j == m - 1) {            for (auto x : p.path)                cout << x << " ";             cout << "\n";        }         // if we are in the last row        // then only right movement is possible        else if (p.i == n - 1) {            vector temp = p.path;            // updating the current path            temp.push_back(maze[p.i][p.j + 1]);             q.push({ temp, p.i, p.j + 1 });        }         // if we are in the last column        // then only down movement is possible        else if (p.j == m - 1) {            vector temp = p.path;            // updating the current path            temp.push_back(maze[p.i + 1][p.j]);             q.push({ temp, p.i + 1, p.j });        }         // else both right and down movement        // are possible        else { // right movement            vector temp = p.path;            // updating the current path            temp.push_back(maze[p.i][p.j + 1]);             q.push({ temp, p.i, p.j + 1 });             // down movement            temp.pop_back();            // updating the current path            temp.push_back(maze[p.i + 1][p.j]);             q.push({ temp, p.i + 1, p.j });        }    }} // Driver Codeint main(){    vector > maze{ { 1, 2, 3 },                               { 4, 5, 6 },                               { 7, 8, 9 } };     printAllPaths(maze);     return 0;}
Output
1 2 3 6 9
1 2 5 6 9
1 2 5 8 9
1 4 5 6 9
1 4 5 8 9
1 4 7 8 9

My Personal Notes arrow_drop_up