Count of possible paths from top left to bottom right of a M x N matrix by moving right, down or diagonally
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> |
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> |
13
Time Complexity: O(M*N)
Auxiliary Space: O(M*N)