从mXn矩阵的左上角到右下角显示所有可能的路径

问题是要打印从mXn矩阵的左上角到右下角的所有可能路径，并限制每个单元只能向右或向下移动。

例子 ：

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

该算法是一种简单的递归算法，从每个单元格开始，先向下打印所有路径，然后再向右打印所有路径。对遇到的每个单元递归执行此操作。

以下是上述算法的实现。

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: Dimentions 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 mXn
void 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 abve functions
int main()
{
    int mat[2][3] = { {1, 2, 3}, {4, 5, 6} };
    printAllPaths(*mat, 2, 3);
    return 0;
}

Java

// Java program to Print all possible paths from
// top left to bottom right of a mXn matrix
public class MatrixTraversal
{
 
 
    /* mat:  Pointer to the starting of mXn matrix
   i, j: Current position of the robot (For the first call use 0,0)
   m, n: Dimentions 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) */
    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++)
            {
                System.out.print(path[l] + " ");
            }
            System.out.println();
            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++)
            {
                System.out.print(path[l] + " ");
            }
            System.out.println();
            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);
    }
}

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 matrix
i, j: Current position of the robot
     (For the first call use 0, 0)
m, n: Dimentions 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) */
'''
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 mXn
def printAllPaths(mat, m, n):
 
    path = [0 for i in range(m + n)]
    printAllPathsUtil(mat, 0, 0, m, n, path, 0)
 
# Driver Code
mat = [[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 matrix
using System;
     
public class MatrixTraversal
{
 
 
    /* mat: Pointer to the starting of mXn matrix
i, j: Current position of the robot (For the first call use 0,0)
m, n: Dimentions 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) */
    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

---

输出

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

输出：

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

请注意，在上面的代码中，对printAllPathsUtil()的最后一行进行了注释。如果我们取消注释此行，则如果还允许对角线移动，则将获得从nXm矩阵的左上角到右下角的所有路径。而且，如果不允许移动到某些单元格，则可以通过将限制数组传递给上述函数来改进相同的代码，并将其作为练习。

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 indx)
{
     
    // 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[indx + 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[0] << ", ";
        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[indx + 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[0] << ", ";
        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[indx] = maze[i][j];
       
    // Move down in y direction and call
    // findPathsUtil recursively
    findPathsUtil(maze, m, n, i + 1,
                  j, path, indx + 1);
       
    // Move down in y direction and
    // call findPathsUtil recursively
    findPathsUtil(maze, m, n, i, j + 1,
                        path, indx + 1);
}
     
void findPaths(vector> maze,
                       int m, int n)
{
    vector path(m + n - 1, 0);
    findPathsUtil(maze, m, n, 0, 0, path, 0);
}
 
// Driver Code
int 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 matrix
import 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 indx)
  {
 
    // 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(indx + 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(indx + 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(indx,maze.get(i).get(j));
 
    // Move down in y direction and call
    // findPathsUtil recursively
    findPathsUtil(maze, m, n, i + 1, j, path, indx + 1);
 
    // Move down in y direction and
    // call findPathsUtil recursively
    findPathsUtil(maze, m, n, i, j + 1, path, indx + 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 matrix
allPaths = []
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,indx):
    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[indx+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[indx+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[indx] = maze[i][j]
     
    # move down in y direction and call findPathsUtil recursively
    findPathsUtil(maze, m, n, i+1, j, path, indx+1)
     
    # move down in y direction and call findPathsUtil recursively
    findPathsUtil(maze, m, n, i, j+1, path, indx+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 matrix
using 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 indx)
    {
          
        // 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[indx + 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[0] + ", ");
            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[indx + 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[0] + ", ");
            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[indx] = maze[i][j];
            
        // Move down in y direction and call
        // findPathsUtil recursively
        findPathsUtil(maze, m, n, i + 1,
                      j, path, indx + 1);
            
        // Move down in y direction and
        // call findPathsUtil recursively
        findPathsUtil(maze, m, n, i, j + 1,
                            path, indx + 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

输出

[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]

输出：

[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]

注意，以上所有方法都需要花费一些额外的时间和空间来解决问题，我们可以简单地使用回溯算法以优化的方式解决问题

C++

#include
using namespace std;
 
// function to display the path
void 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 direclty 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;
}

输出

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 

因此，通过这些方法，您可以优化代码。

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