Possible Paths from Top Left to Bottom Right of a Matrix in Java

In this section, we will learn about finding the possible paths from top left to bottom right of a matrix in Java. It is one of the prominent problems asked in the interview. The constraint to go from top left to bottom right is that from any cell, one can move in the rightward (→) or in the downward direction (↓). Let's see a few examples for better understanding.

Note: Readers are advised to learn the arrays and recursion first, then go through this topic.

Examples

Example 1:

4 2
8 0 
3 5

In the above 3 * 3 matrix, one has to go from cell marked as 1 to the cell marked as 5. From cell 1, one can either go cell 4 or the cell 7. Similarly, from cell 4, one can go the cell 8 or cell 2, and from cell 7, one can go cell 6 or cell 8. Thus, continuing in the same manner, one will get the following.

Thus, we see that there are 6 ways to reach the cell marked as 5 from the cell marked as 1.

Example 2:

2 1 0 4
8 7 6 9

In the above 2 * 4 matrix, one will get the following.

Thus, we see that there are 4 ways to reach the cell marked as 9 from the cell marked as 2.

Using Recursion

Simple recursion will be enough to solve the problem. First of all, we display all the paths while going in the downward direction, and after that, we display all the paths while going in the rightward direction. We will be doing it recursively for each cell that is encountered in the path.

Implementation

The following is the implementation for printing the possible paths from the top left to the bottom right of a matrix.

FileName: TopLeftBottomRightPath.java

// important import statement
import java.util.*;

public class TopLeftBottomRightPath
{
private void displayMatrix(int matrix[][], int r, int c, int x, int y, ArrayList<Integer> al)
{
// return if r or c goes out of  the range
if(x > r || y > c)
{
return;
}

al.add(matrix[x][y]);
// the bottom right cell has been reached
if(x == r && y == c)
{
System.out.println(al);
}

// recursively moving in the downward direction
displayMatrix(matrix, r, c, x + 1, y, al);

// recursively moving in the rightward direction
displayMatrix(matrix, r, c, x, y + 1, al);

al.remove(al.size() - 1);

}
	
// main method
public static void main(String[] argvs)
{
// number of rows
int r = 3;

// number of colums
int c = 3;

int m[][] = { { 1, 4, 2 },
	      { 7, 8, 0 },
	      { 6, 3, 5 }
                   };

// creating an object of the class ArrayList            
ArrayList<Integer> al = new ArrayList<Integer>();

// creating an object of the class TopLeftBottomRightPath
TopLeftBottomRightPath obj = new TopLeftBottomRightPath();

System.out.println("For the matrix: ");

for(int i = 0; i < r; i++)
{
    for(int j = 0; j < c; j++)
    {
        System.out.print(m[i][j] + " ");
    }
    
    System.out.println();
}

System.out.println();
System.out.println("The possible paths from the top left to the bottom right is: ");
obj.displayMatrix(m, r - 1, c - 1, 0, 0, al);
}
}

Output:

For the matrix: 
1 4 2 
7 8 0 
6 3 5 

The possible paths from the top left to the bottom right is: 
[1, 7, 6, 3, 5]
[1, 7, 8, 3, 5]
[1, 7, 8, 0, 5]
[1, 4, 8, 3, 5]
[1, 4, 8, 0, 5]
[1, 4, 2, 0, 5]

Using Iteration

We can also solve this problem using iteration. In this approach, we will be using Breadth-First Search (BFS). A queue will be used that will contain the cell coordinates and paths up to the certain cell. From the top-left cell, we will start pushing the coordinates and the value of the cell into the queue (the value of the cell is stored in a vector). We will continue to explore the down and right cells unless the queue is not empty and will also continue to push the undiscovered cells in the queue. When we reach the bottom-right cell of the matrix, then the vector containing the values of the cells explored is our answer.

// important import statements
import java.util.*;

// a class for storing the 
//cells of the matrix and its coordinates
class Store 
{
    
ArrayList<Integer> al;
int x;
int y;

Store()
{
this.al = new ArrayList<Integer>();   
}

// paramterized constructor of the class
Store(ArrayList<Integer> a, int x, int y)
{
// initializing the fields
this.al = new ArrayList<Integer>(a);
this.x = x;
this.y = y;
}

}

public class TopLeftExample
{
void displayllPaths(ArrayList<ArrayList<Integer>> m, int r, int c, Store obj)
{

Queue<Store> q = new LinkedList<Store>();

// get the value of the top left cell
int j = m.get(0).get(0);
obj.al.add(j);
obj.x = 0; obj.y = 0;

// adding the top-left cell into the queue
q.add(obj);

// run the loop until the queue is not empty
while (q.isEmpty() == false) 
{
obj = q.peek();
q.poll();

// the destination cell has been reached
// hence print the path
if (obj.x == r - 1 && obj.y == c - 1) 
{
for (int i = 0; i < obj.al.size(); i++)
{
System.out.print(obj.al.get(i) + " ");
}

System.out.println();
}

// we have reached the last row
// Hence, movement in the downward direction is not possible
// Only we can move in the right direction
else if (obj.x == r - 1) 
{
ArrayList<Integer> temp = new ArrayList<Integer>();
for (int i = 0; i < obj.al.size(); i++)
{
temp.add(obj.al.get(i));
}

// updating the current path
temp.add(m.get(obj.x).get(obj.y + 1));

q.add(new Store(temp, obj.x, obj.y + 1));
}

// we have reached the last column
// Hence, movement in the rightward direction is not possible
// Only we can move in the downward direction
else if (obj.y == c - 1) 
{
ArrayList<Integer> temp = new ArrayList<Integer>();
for (int i = 0; i < obj.al.size(); i++)
{
temp.add(obj.al.get(i));
}

// updating the current path
temp.add(m.get(obj.x + 1).get(obj.y));

q.add(new Store(temp, obj.x + 1, obj.y));
}

// movement in the right as well as movement in the 
// downward direction is possible
else 
{ 

ArrayList<Integer> temp = new ArrayList<Integer>();

for (int i = 0; i < obj.al.size(); i++)
{
temp.add(obj.al.get(i));
}

// updating the current path
temp.add(m.get(obj.x).get(obj.y + 1));

q.add(new Store(temp, obj.x, obj.y + 1));

// down movement
temp.remove(temp.size() - 1);

// updating the current path
temp.add(m.get(obj.x + 1).get(obj.y));

q.add(new Store(temp, obj.x + 1, obj.y));
}
}
}


// main method
public static void main (String argvs[])
{
// number of rows in the maze
int r = 3;

// number of columns in the maze
int c = 3;

// creating a 2-dimensional list
ArrayList<ArrayList<Integer>> maze = new ArrayList<ArrayList<Integer>>();
maze.add(new ArrayList<Integer>(Arrays.asList(1, 4, 2)));
maze.add(new ArrayList<Integer>(Arrays.asList(7, 8, 0)));
maze.add(new ArrayList<Integer>(Arrays.asList(6, 3, 5)));

System.out.println("For the following maze: ");
System.out.println(maze.get(0));
System.out.println(maze.get(1));
System.out.println(maze.get(2) + "\n");

// creating an object of the class TopLeftExample
TopLeftExample obj = new TopLeftExample();

// creating an object of the class Store
Store o = new Store();

System.out.println("The possible paths from the top left to the bottom right is: ");
obj.displayllPaths(maze, r, c, o);       
}
}

Output:

For the following matrix: 
[1, 4, 2]
[7, 8, 0]
[6, 3, 5]

The possible paths from the top left to the bottom right is: 
1 4 2 0 5 
1 4 8 0 5 
1 4 8 3 5 
1 7 8 0 5 
1 7 8 3 5 
1 7 6 3 5

Next TopicPalindrome Partitioning Problem in Java

← prev next →