You are standing on a point (n, m) and you want to go to origin (0, 0) by taking steps either left or down i.e. from each point you are allowed to move either in (n-1, m) or (n, m-1). Find the number of paths from point to origin.
Examples:
Input : 3 6
Output : Number of Paths 84
Input : 3 0
Output : Number of Paths 1


As we are restricted to move down and left only we would run a recursive loop for each of the combinations of the
steps that can be taken.
// Recursive function to count number of paths
countPaths(n, m)
{
// If we reach bottom or top left, we are
// have only one way to reach (0, 0)
if (n==0 || m==0)
return 1;
// Else count sum of both ways
return (countPaths(n-1, m) + countPaths(n, m-1));
}
Below is the implementation of the above steps.
C++
#include<bits/stdc++.h>
using namespace std;
int countPaths( int n, int m)
{
if (n==0 || m==0)
return 1;
return (countPaths(n-1, m) + countPaths(n, m-1));
}
int main()
{
int n = 3, m = 2;
cout << " Number of Paths " << countPaths(n, m);
return 0;
}
|
Java
import java.io.*;
class GFG {
static int countPaths( int n, int m)
{
if (n == 0 || m == 0 )
return 1 ;
return (countPaths(n - 1 , m) + countPaths(n, m - 1 ));
}
public static void main (String[] args)
{
int n = 3 , m = 2 ;
System.out.println ( " Number of Paths "
+ countPaths(n, m));
}
}
|
Python3
def countPaths(n,m):
if (n = = 0 or m = = 0 ):
return 1
return (countPaths(n - 1 , m) + countPaths(n, m - 1 ))
n = 3
m = 2
print ( " Number of Paths " , countPaths(n, m))
|
C#
using System;
public class GFG {
static int countPaths( int n, int m)
{
if (n == 0 || m == 0)
return 1;
return (countPaths(n - 1, m)
+ countPaths(n, m - 1));
}
public static void Main ()
{
int n = 3, m = 2;
Console.WriteLine ( " Number of"
+ " Paths " + countPaths(n, m));
}
}
|
PHP
<?php
function countPaths( $n , $m )
{
if ( $n == 0 || $m == 0)
return 1;
return (countPaths( $n - 1, $m ) +
countPaths( $n , $m - 1));
}
$n = 3;
$m = 2;
echo " Number of Paths "
, countPaths( $n , $m );
?>
|
Output
Number of Paths 10
We can use Dynamic Programming as there are overlapping subproblems. We can draw recursion tree to see overlapping problems. For example, in case of countPaths(4, 4), we compute countPaths(3, 3) multiple times.
C++
#include<bits/stdc++.h>
using namespace std;
int countPaths( int n, int m)
{
int dp[n+1][m+1];
for ( int i=0; i<=n; i++)
dp[i][0] = 1;
for ( int i=0; i<=m; i++)
dp[0][i] = 1;
for ( int i=1; i<=n; i++)
for ( int j=1; j<=m; j++)
dp[i][j] = dp[i-1][j] + dp[i][j-1];
return dp[n][m];
}
int main()
{
int n = 3, m = 2;
cout << " Number of Paths " << countPaths(n, m);
return 0;
}
|
Java
import java.io.*;
class GFG {
static int countPaths( int n, int m)
{
int dp[][] = new int [n + 1 ][m + 1 ];
for ( int i = 0 ; i <= n; i++)
dp[i][ 0 ] = 1 ;
for ( int i = 0 ; i <= m; i++)
dp[ 0 ][i] = 1 ;
for ( int i = 1 ; i <= n; i++)
for ( int j = 1 ; j <= m; j++)
dp[i][j] = dp[i - 1 ][j] + dp[i][j - 1 ];
return dp[n][m];
}
public static void main (String[] args) {
int n = 3 , m = 2 ;
System.out.println( " Number of Paths "
+ countPaths(n, m));
}
}
|
Python3
def countPaths(n, m):
if (n = = 0 or m = = 0 ):
return 1
return (countPaths(n - 1 , m) +
countPaths(n, m - 1 ))
n = 3
m = 2
print ( "Number of Paths" ,
countPaths(n, m))
|
C#
using System;
public class GFG {
static int countPaths( int n, int m)
{
int [,]dp = new int [n + 1,m + 1];
for ( int i = 0; i <= n; i++)
dp[i,0] = 1;
for ( int i = 0; i <= m; i++)
dp[0,i] = 1;
for ( int i = 1; i <= n; i++)
for ( int j = 1; j <= m; j++)
dp[i,j] = dp[i - 1,j]
+ dp[i,j - 1];
return dp[n,m];
}
public static void Main ()
{
int n = 3, m = 2;
Console.WriteLine( " Number of"
+ " Paths " + countPaths(n, m));
}
}
|
PHP
<?php
function countPaths( $n , $m )
{
for ( $i = 0; $i <= $n ; $i ++)
$dp [ $i ][0] = 1;
for ( $i = 0; $i <= $m ; $i ++)
$dp [0][ $i ] = 1;
for ( $i = 1; $i <= $n ; $i ++)
for ( $j = 1; $j <= $m ; $j ++)
$dp [ $i ][ $j ] = $dp [ $i - 1][ $j ] +
$dp [ $i ][ $j - 1];
return $dp [ $n ][ $m ];
}
$n = 3;
$m = 2;
echo " Number of Paths " , countPaths( $n , $m );
?>
|
Output
Number of Paths 10
Another Approach:
Using Pascal’s Triangle Approach, we also solve the problem by calculating the value of n+mCn. It can be observed as a pattern when you increase the value of m keeping the value of n constant.
Below is the implementation of the above approach:
C++
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int binomialCoeff( int n, int k)
{
int C[k+1];
memset (C, 0, sizeof (C));
C[0] = 1;
for ( int i = 1; i <= n; i++)
{
for ( int j = min(i, k); j > 0; j--)
C[j] = C[j] + C[j-1];
}
return C[k];
}
int main()
{
int n=3, m=2;
cout<< "Number of Paths: " <<
binomialCoeff(n+m,n)<<endl;
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG
{
static int min( int a, int b)
{
return a<b?a:b;
}
static int binomialCoeff( int n, int k)
{
int C[] = new int [k + 1 ];
C[ 0 ] = 1 ;
for ( int i = 1 ; i <= n; i++)
{
for ( int j = min(i,k); j > 0 ; j--)
C[j] = C[j] + C[j- 1 ];
}
return C[k];
}
public static void main (String[] args)
{
int n= 3 ,m= 2 ;
System.out.println( "Number of Paths: " +
binomialCoeff(n+m,n));
}
}
|
Python3
def binomialCoeff(n,k):
C = [ 0 ] * (k + 1 )
C[ 0 ] = 1
for i in range ( 1 , n + 1 ):
j = min (i ,k)
while (j > 0 ):
C[j] = C[j] + C[j - 1 ]
j - = 1
return C[k]
n = 3
m = 2
print ( "Number of Paths:" ,binomialCoeff(n + m,n))
|
C#
using System;
class GFG{
static int binomialCoeff( int n, int k)
{
int [] C = new int [k + 1];
C[0] = 1;
for ( int i = 1; i <= n; i++)
{
for ( int j = Math.Min(i, k); j > 0; j--)
C[j] = C[j] + C[j - 1];
}
return C[k];
}
static void Main()
{
int n = 3, m = 2;
Console.WriteLine( "Number of Paths: " +
binomialCoeff(n + m, n));
}
}
|
Output
Number of Paths: 10
This article is contributed by Nikhil Rawat.
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.