Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count of possible paths from top left to bottom right of a M x N matrix by moving right, down or diagonally

  • Last Updated : 07 Apr, 2022

Given 2 integers M and N, the task is to find the count of all the possible paths from top left to the bottom right of an M x N matrix with the constraints that from each cell you can either move only to right or down or diagonally

Examples:

Input:  M = 3, N = 3
Output: 13
Explanation: There are 13 paths as follows: VVHH, VHVH, HVVH, DVH, VDH, VHHV, HVHV, DHV, HHVV, HDV, VHD, HVD, and DD where V represents vertical, H represents horizontal, and D represents diagonal paths.

Input:  M = 2, N = 2
Output: 3

 

Approach: The idea is to use recursion to find the total number of paths. This approach is very similar to the one discussed in this article. Follow the steps below to solve the problem:

  • If M or N equals 1, then return 1.
  • Else create a recursive function numberOfPaths() call the same function for values {M-1, N}, {M, N-1} and {M-1, N-1} representing vertical, horizontal and diagonal movement respectively.

Below is the implementation of the above approach:

C++




// C++  program for the above approach
#include <iostream>
using namespace std;
 
// Returns count of possible paths to
// reach cell at row number M and column
// number N from the topmost leftmost
// cell (cell at 1, 1)
int numberOfPaths(int M, int N)
{
 
    // If either given row number or
    // given column number is first
    if (M == 1 || N == 1)
        return 1;
 
    // Horizontal Paths +
    // Vertical Paths +
    // Diagonal Paths
    return numberOfPaths(M - 1, N)
          + numberOfPaths(M, N - 1)
           + numberOfPaths(M - 1, N - 1);
}
 
// Driver Code
int main()
{
    cout << numberOfPaths(3, 3);
    return 0;
}
Java



// Java  program for the above approach
import java.util.*;
public class GFG
{
   
// Returns count of possible paths to
// reach cell at row number M and column
// number N from the topmost leftmost
// cell (cell at 1, 1)
static int numberOfPaths(int M, int N)
{
 
    // If either given row number or
    // given column number is first
    if (M == 1 || N == 1)
        return 1;
 
    // Horizontal Paths +
    // Vertical Paths +
    // Diagonal Paths
    return numberOfPaths(M - 1, N)
          + numberOfPaths(M, N - 1)
           + numberOfPaths(M - 1, N - 1);
}
 
// Driver Code
public static void main(String args[])
{
    System.out.print(numberOfPaths(3, 3));
 
}
}
 
// This code is contributed by Samim Hossain Mondal.
Python



# Python  program for the above approach
 
# Returns count of possible paths to
# reach cell at row number M and column
# number N from the topmost leftmost
# cell (cell at 1, 1)
def numberOfPaths(M, N):
 
    # If either given row number or
    # given column number is first
    if (M == 1 or N == 1):
        return 1
 
    # Horizontal Paths +
    # Vertical Paths +
    # Diagonal Paths
    return numberOfPaths(M - 1, N) \
        + numberOfPaths(M, N - 1) \
        + numberOfPaths(M - 1, N - 1)
 
# Driver Code
print(numberOfPaths(3, 3))
 
# This code is contributed by Samim Hossain Mondal.
C#



// C#  program for the above approach
using System;
 
public class GFG
{
   
// Returns count of possible paths to
// reach cell at row number M and column
// number N from the topmost leftmost
// cell (cell at 1, 1)
static int numberOfPaths(int M, int N)
{
 
    // If either given row number or
    // given column number is first
    if (M == 1 || N == 1)
        return 1;
 
    // Horizontal Paths +
    // Vertical Paths +
    // Diagonal Paths
    return numberOfPaths(M - 1, N)
          + numberOfPaths(M, N - 1)
           + numberOfPaths(M - 1, N - 1);
}
 
// Driver Code
public static void Main(String []args)
{
    Console.Write(numberOfPaths(3, 3));
 
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
       // JavaScript code for the above approach
 
       // Returns count of possible paths to
       // reach cell at row number M and column
       // number N from the topmost leftmost
       // cell (cell at 1, 1)
       function numberOfPaths(M, N) {
 
           // If either given row number or
           // given column number is first
           if (M == 1 || N == 1)
               return 1;
 
           // Horizontal Paths +
           // Vertical Paths +
           // Diagonal Paths
           return numberOfPaths(M - 1, N)
               + numberOfPaths(M, N - 1)
               + numberOfPaths(M - 1, N - 1);
       }
 
       // Driver Code
       document.write(numberOfPaths(3, 3));
 
 // This code is contributed by Potta Lokesh
   </script>
 
 
Output
13
 
Time Complexity: O(3M*N)
Auxiliary Space: O(1)
Efficient Approach: Dp (using Memoization)
C++



// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
static int dp[1001][1001];
 
// Returns count of possible paths to
// reach cell at row number M and column
// number N from the topmost leftmost
// cell (cell at 1, 1)
int numberOfPaths(int M, int N)
{
 
    // If either given row number or
    // given column number is first
    if (M == 1 || N == 1)
        return 1;
     
    // If a value already present
    // in t[][], return it
    if(dp[M][N] != -1) {
        return dp[M][N];
    }
     
    // Horizontal Paths +
    // Vertical Paths +
    // Diagonal Paths
    return dp[M][N] = numberOfPaths(M - 1, N)
                    + numberOfPaths(M, N - 1)
                    + numberOfPaths(M - 1, N - 1);
}
 
// Driver Code
int main()
{
    memset(dp,-1,sizeof(dp));
    cout << numberOfPaths(3, 3);
    return 0;
}
Java



// Java program for the above approach
import java.util.*;
public class GFG {
  static int[][] dp = new int[1001][1001];
 
  // Returns count of possible paths to
  // reach cell at row number M and column
  // number N from the topmost leftmost
  // cell (cell at 1, 1)
  static int numberOfPaths(int M, int N)
  {
 
    // If either given row number or
    // given column number is first
    if (M == 1 || N == 1)
      return 1;
 
    // If a value already present
    // in t[][], return it
    if (dp[M][N] != -1) {
      return dp[M][N];
    }
 
    // Horizontal Paths +
    // Vertical Paths +
    // Diagonal Paths
    dp[M][N] = numberOfPaths(M - 1, N)
      + numberOfPaths(M, N - 1)
      + numberOfPaths(M - 1, N - 1);
    return dp[M][N];
  }
 
  // Driver Code
  public static void main(String args[])
  {
    for (int i = 0; i < 1001; i++)
      for (int j = 0; j < 1001; j++)
        dp[i][j] = -1;
    System.out.println(numberOfPaths(3, 3));
  }
}
 
// This code is contributed by Samim Hossain Mondal.
Python



# Python program for the above approach
 
# Taking the matrix as globally
dp = [[-1 for i in range(1001)] for j in range(1001)]
 
# Returns count of possible paths to
# reach cell at row number M and column
# number N from the topmost leftmost
# cell (cell at 1, 1)
def numberOfPaths(M, N):
 
    # If either given row number or
    # given column number is first
    if (M == 1 or N == 1):
        return 1
 
    # If a value already present
    # in t[][], return it
    if(dp[M][N] != -1):
        return dp[M][N]
 
    # Horizontal Paths +
    # Vertical Paths +
    # Diagonal Paths
    dp[M][N] = numberOfPaths(M - 1, N) + numberOfPaths(M,
                     N - 1) + numberOfPaths(M - 1, N - 1)
    return dp[M][N]
 
# Driver Code
print(numberOfPaths(3, 3))
 
# This code is contributed by Samim Hossain Mondal.
C#



// C# program for the above approach
using System;
class GFG {
    static int[, ] dp = new int[1001, 1001];
 
    // Returns count of possible paths to
    // reach cell at row number M and column
    // number N from the topmost leftmost
    // cell (cell at 1, 1)
    static int numberOfPaths(int M, int N)
    {
 
        // If either given row number or
        // given column number is first
        if (M == 1 || N == 1)
            return 1;
 
        // If a value already present
        // in t[][], return it
        if (dp[M, N] != -1) {
            return dp[M, N];
        }
 
        // Horizontal Paths +
        // Vertical Paths +
        // Diagonal Paths
        dp[M, N] = numberOfPaths(M - 1, N)
                   + numberOfPaths(M, N - 1)
                   + numberOfPaths(M - 1, N - 1);
        return dp[M, N];
    }
 
    // Driver Code
    public static void Main()
    {
        for (int i = 0; i < 1001; i++)
            for (int j = 0; j < 1001; j++)
                dp[i, j] = -1;
        Console.Write(numberOfPaths(3, 3));
    }
}
 
// This code is contributed by ukasp.
Javascript



<script>
        // JavaScript Program of the above approach
 
  var dp = new Array(1001);
  // Loop to create 2D array using 1D array
    for (var i = 0; i < dp.length; i++) {
        dp[i] = new Array(1001);
    }
 
  // Returns count of possible paths to
  // reach cell at row number M and column
  // number N from the topmost leftmost
  // cell (cell at 1, 1)
  function numberOfPaths(M, N)
  {
 
    // If either given row number or
    // given column number is first
    if (M == 1 || N == 1)
      return 1;
 
    // If a value already present
    // in t[][], return it
    if (dp[M][N] != -1) {
      return dp[M][N];
    }
 
    // Horizontal Paths +
    // Vertical Paths +
    // Diagonal Paths
    dp[M][N] = numberOfPaths(M - 1, N)
      + numberOfPaths(M, N - 1)
      + numberOfPaths(M - 1, N - 1);
    return dp[M][N];
  }
 
        // Driver Code
         
      for (let i = 0; i < 1001; i++){
      for (let j = 0; j < 1001; j++){
        dp[i][j] = -1;
      }}
      document.write(numberOfPaths(3, 3));
 
// This code is contributed by avijitmondal1998
    </script>
Output
13
Time Complexity: O(M*N)
Auxiliary Space: O(M*N)

My Personal Notes
arrow_drop_up
Previous
Find the row up to which there are at least K stars in the Diamond Pattern
Next

Minimum operations required to make N even by reversing prefix of any length
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 matrix elements from top-left to bottom right in diagonally upward manner
23, Nov 20
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 possible paths from top left to bottom right of a mXn matrix
22, Dec 13
Minimize count of unique paths from top left to bottom right of a Matrix by placing K 1s
02, Sep 20
Print all unique paths from given source to destination in a Matrix moving only down or right
10, Dec 21
Print all palindromic paths from top left to bottom right in a matrix
20, Sep 17
Print all paths from top left to bottom right in a matrix with four moves allowed
25, Dec 18
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
Maximize cost to reach the bottom-most row from top-left and top-right corner of given matrix
27, Jan 22
Lexicographically largest prime path from top-left to bottom-right in a matrix
16, Oct 18
Shortest path in a Matrix from top-left to bottom right-corner with neighbors exceeding at most K
24, Nov 21
Minimum cost to reach from the top-left to the bottom-right corner of a matrix
06, Jan 20
Maximum sum path in a matrix from top-left to bottom-right
10, Sep 20
Maximum XOR of a path from top-left to bottom-right cell of given Matrix
25, Oct 20
Maximize trailing zeros in product from top left to bottom right of given Matrix
27, Oct 20
Maximum non-negative product of a path from top left to bottom right of given Matrix
23, Nov 20
Maximum path sum from top left to bottom right of a matrix passing through one of the given cells
15, Jun 21
Minimum number of flips required such that a Binary Matrix doesn't contain any path from the top left to the bottom right consisting only of 0s
29, Jun 21
Maximum points by traversing from top left of Matrix to bottom right by two persons
09, Aug 21
Minimize cost to reach bottom right from top left corner of Matrix with given separate cost for each move
11, Jan 22
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
prasanna1995
@prasanna1995
Vote for difficulty





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!