Skip to content
Related Articles

Related Articles

Print all possible paths from the first row to the last row in a 2D array
  • Difficulty Level : Medium
  • Last Updated : 25 Mar, 2020

Given a 2D array of characters with M rows and N columns. The task is to print all the possible paths from top (first row) to bottom (last row).

Examples:

Input: arr[][] = {
{‘a’, ‘b’, ‘c’},
{‘d’, ‘e’, ‘f’},
{‘g’, ‘h’, ‘i’}}
Output:
adg adh adi aeg aeh aei afg afh afi
bdg bdh bdi beg beh bei bfg bfh bfi
cdg cdh cdi ceg ceh cei cfg cfh cfi

Input: arr[][] = {
{‘a’, ‘b’},
{‘d’, ‘e’}, }
Output:
ad ae
bd be

Approach:



  1. This problem can be solved using Depth First Traversal of an array with a slight modification.
  2. The modification here is to only iterate through the columns in the array until the target row is reached.

Below is the implementation of the above approach:

C++




// C++ implementation of the approach 
#include<bits/stdc++.h>
using namespace std;
  
void dfs(char inputchar[][2], string res, 
                int i, int j, int R, int C) 
{
      
    // If the current row index equals to R, it 
    // indicates we have reached the bottom of 
    // the array and hence we print the result 
    if (i == R) 
    {
        cout << res << " ";
        return; 
    }
  
    res = res + (inputchar[i][j]); 
  
    // Iterate over each of the columns 
    // in the array 
    for (int k = 0; k < C ; k++)
    {
        dfs(inputchar, res, i + 1, k, R, C);
        if (i + 1 == R) 
            break; 
    }
}
  
// Function to print all the possible paths 
void printPaths(char inputchar[][2], int R, int C)
{
    for (int i = 0; i < C; i++)
    {
        dfs(inputchar, "", 0, i, R, C);
        cout<<endl;
    }
          
    /*
    * Depth first traversal of the array 
    * 
    * @param input array of characters 
    * @param res to be printed in console 
    * @param i current row index 
    * @param j current column index 
    * @param R number of rows in the input array 
    * @param C number of rows in the output array 
    * 
*/
}
  
  
// Driver code 
int main()
{
      
    char inputchar[][2] = {
            { 'a', 'b' }, 
            { 'd', 'e' }
            };
              
    int R = sizeof(inputchar)/sizeof(inputchar[0]);
    int C = sizeof(inputchar[0])/sizeof(char);
  
    printPaths(inputchar, R, C); 
}
  
// This code is contributed by chitranayal
Java



// Java implementation of the approach
public class GFG {
  
    // Function to print all the possible paths
    private static void printPaths(char[][] input,
                                   int R, int C)
    {
        for (int i = 0; i < C; i++) {
            dfs(input, "", 0, i, R, C);
            System.out.println();
        }
    }
  
    /**
    * Depth first traversal of the array
    *
    * @param input array of characters
    * @param res to be printed in console
    * @param i     current row index
    * @param j     current column index
    * @param R     number of rows in the input array
    * @param C     number of rows in the output array
    */
    private static void dfs(char[][] input, String res,
                            int i, int j, int R, int C)
    {
        // If the current row index equals to R, it
        // indicates we have reached the bottom of
        // the array and hence we print the result
        if (i == R) {
            System.out.print(res + " ");
            return;
        }
  
        res = res + input[i][j];
  
        // Iterate over each of the columns
        // in the array
        for (int k = 0; k < C; k++) {
            dfs(input, res, i + 1, k, R, C);
            if (i + 1 == R) {
                break;
            }
        }
    }
  
    // Driver code
    public static void main(String[] args)
    {
        char[][] input = {
            { 'a', 'b' },
            { 'd', 'e' }
        };
        int R = input.length;
        int C = input[0].length;
        printPaths(input, R, C);
    }
}
Python3



# Python3 implementation of the approach 
  
# Function to print all the possible paths 
def printPaths(inputchar, R, C) :
    for i in range(C) :
        dfs(inputchar, "", 0, i, R, C);
        print()
          
    """
    * Depth first traversal of the array 
    * 
    * @param input array of characters 
    * @param res to be printed in console 
    * @param i current row index 
    * @param j current column index 
    * @param R number of rows in the input array 
    * @param C number of rows in the output array 
    * """
def dfs(inputchar, res, i, j, R, C) :
      
    # If the current row index equals to R, it 
    # indicates we have reached the bottom of 
    # the array and hence we print the result 
    if (i == R) :
        print(res, end = " ");
        return; 
  
    res = res + inputchar[i][j]; 
  
    # Iterate over each of the columns 
    # in the array 
    for k in range(C) :
        dfs(inputchar, res, i + 1, k, R, C);
        if (i + 1 == R) :
            break; 
  
# Driver code 
if __name__ == "__main__" :
      
    inputchar = [
            [ 'a', 'b' ], 
            [ 'd', 'e' ] 
            ];
              
    R = len(inputchar);
    C = len(inputchar[0]);
      
    printPaths(inputchar, R, C); 
  
# This code is contributed by AnkitRai01
C#



// C# implementation of the approach 
using System;
  
class GFG 
{ 
  
    // Function to print all the possible paths 
    private static void printPaths(char[,] input, 
                                int R, int C) 
    { 
        for (int i = 0; i < C; i++)
        { 
            dfs(input, "", 0, i, R, C); 
            Console.WriteLine(); 
        } 
    } 
  
    /** 
    * Depth first traversal of the array 
    * 
    * @param input array of characters 
    * @param res to be printed in console 
    * @param i current row index 
    * @param j current column index 
    * @param R number of rows in the input array 
    * @param C number of rows in the output array 
    */
    private static void dfs(char[,] input, string res, 
                            int i, int j, int R, int C) 
    { 
        // If the current row index equals to R, it 
        // indicates we have reached the bottom of 
        // the array and hence we print the result 
        if (i == R) 
        { 
            Console.Write(res + " "); 
            return; 
        } 
  
        res = res + input[i,j]; 
  
        // Iterate over each of the columns 
        // in the array 
        for (int k = 0; k < C; k++) 
        { 
            dfs(input, res, i + 1, k, R, C); 
            if (i + 1 == R) 
            { 
                break; 
            } 
        } 
    } 
  
    // Driver code 
    public static void Main() 
    { 
        char[,] input = { 
            { 'a', 'b' }, 
            { 'd', 'e' } 
        }; 
        int R = input.GetLength(0); 
        int C = input.GetLength(1); 
        printPaths(input, R, C); 
    } 
} 
  
// This code is contributed by AnkitRai01
Output:
ad ae 
bd be

Time Complexity: O(R * C)
Space Complexity: O(1)
My Personal Notes
arrow_drop_up
Previous
Add and Remove vertex in Adjacency Matrix representation of Graph
Next

Zoho Interview Experience | Off Campus for Software Developer Role
Recommended Articles
Page :
Minimum steps to convert all paths in matrix from top left to bottom right as palindromic paths
20, Jun 20
Minimum steps to convert all paths in matrix from top left to bottom right as palindromic paths | Set 2
29, Jul 20
Print all possible paths in a DAG from vertex whose indegree is 0
07, Jul 20
Print all possible paths from top left to bottom right of a mXn matrix
22, Dec 13
Check whether the cost of going from any node to any other node via all possible paths is same
13, Mar 20
Count of all possible Paths in a Tree such that Node X does not appear before Node Y
05, Aug 20
Count number of times each Edge appears in all possible paths of a given Tree
24, Aug 20
Count all possible paths between two vertices
03, Dec 17
Count all possible paths from top left to bottom right of a mXn matrix
31, Dec 13
Count all possible paths from top left to bottom right of a Matrix without crossing the diagonal
07, Sep 20
Print all paths from a given source to a destination
15, Jan 15
Print all paths from top left to bottom right in a matrix with four moves allowed
25, Dec 18
Print all paths of the Binary Tree with maximum element in each path greater than or equal to K
28, Feb 20
Print all root-to-leaf paths with maximum count of even nodes
25, Oct 20
Print all the Paths of a Binary Tree whose XOR is non-zero
30, Apr 20
Print all root to leaf paths of an N-ary tree
16, Dec 20
Print all palindromic paths from top left to bottom right in a matrix
20, Sep 17
Print the indices for every row of a grid from which escaping from the grid is possible
05, May 21
Print Palindromic Paths of Binary tree
08, Apr 20
Check if sum of array can be made equal to X by removing either the first or last digits of every array element
23, Mar 21
Maximum weight path ending at any element of last row in a matrix
13, Nov 16
Minimum steps to convert all top left to bottom right paths in Matrix as palindrome | Set 2
15, Jul 20
Minimize flips required to make all shortest paths from top-left to bottom-right of a binary matrix equal to S
04, Sep 20
Sum of all pair shortest paths in a Tree
30, Sep 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Roshan Halwai
@Roshan Halwai
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox