Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Print all possible paths from the first row to the last row in a 2D array

  • Difficulty Level : Medium
  • Last Updated : 01 Nov, 2021

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
Javascript



<script>
// javascript implementation of the approach
 
 
    // Function to print all the possible paths
     function printPaths( input , R , C) {
        for (i = 0; i < C; i++) {
            dfs(input, "", 0, i, R, C);
            document.write("<br/>");
        }
    }
 
 
     function dfs( input,  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) {
            document.write(res + " ");
            return;
        }
 
        res = res + input[i][j];
 
        // Iterate over each of the columns
        // in the array
        for (var k = 0; k < C; k++) {
            dfs(input, res, i + 1, k, R, C);
            if (i + 1 == R) {
                break;
            }
        }
    }
 
    // Driver code
     
        var input = [ [ 'a', 'b' ], [ 'd', 'e' ] ];
        var R = input.length;
        var C = input[0].length;
        printPaths(input, R, C);
 
// This code contributed by Rajput-Ji
</script>
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 to escape out of a matrix from a given position using at most K moves
05, Aug 21
Print all possible paths from top left to bottom right of a mXn matrix
22, Dec 13
Print all paths from a source point to all the 4 corners of a Matrix
27, Sep 21
Count of all possible Paths in a Tree such that Node X does not appear before Node Y
05, Aug 20
Count all possible paths from top left to bottom right of a Matrix without crossing the diagonal
07, Sep 20
Check whether the cost of going from any node to any other node via all possible paths is same
13, Mar 20
Count number of times each Edge appears in all possible paths of a given Tree
24, Aug 20
Count all possible paths from top left to bottom right of a mXn matrix
31, Dec 13
Count all possible paths between two vertices
03, Dec 17
Print all palindromic paths from top left to bottom right in a matrix
20, Sep 17
Print all the root-to-leaf paths of a Binary Tree whose XOR is non-zero
30, Apr 20
Print all root-to-leaf paths with maximum count of even nodes
25, Oct 20
Print all root to leaf paths of an N-ary tree
16, Dec 20
Print all paths of the Binary Tree with maximum element in each path greater than or equal to K
28, Feb 20
Print all the paths from root to leaf, with a specified sum in Binary tree
09, Aug 21
Print all paths from top left to bottom right in a matrix with four moves allowed
25, Dec 18
Print all unique paths from given source to destination in a Matrix moving only down or right
10, Dec 21
Print all paths from a given source to a destination
15, Jan 15
Print the indices for every row of a grid from which escaping from the grid is possible
05, May 21
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
Count of possible paths from top left to bottom right of a M x N matrix by moving right, down or diagonally
30, Dec 21
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

Start Your Coding Journey Now!