Counts paths from a point to reach Origin
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 );
?>
|
Javascript
<script>
function countPaths( n , m) {
if (n == 0 || m == 0)
return 1;
return (countPaths(n - 1, m) + countPaths(n, m - 1));
}
let n = 3, m = 2;
document.write( " Number of Paths " + countPaths(n, m));
</script>
|
Output
Number of Paths 10
Time Complexity: O(min(m,n))
Auxiliary Space: O(min(m,n))
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 );
?>
|
Javascript
<script>
function countPaths(n , m)
{
var dp = Array(n+1).fill(0).map(x => Array(m+1).fill(0));
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];
}
var n = 3, m = 2;
document.write( " Number of Paths "
+ countPaths(n, m));
</script>
|
Output
Number of Paths 10
Time Complexity: O(n*m)
Auxiliary Space: O(n*m)
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:
Implementation:
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));
}
}
|
Javascript
<script>
function min(a , b)
{
return a < b ? a : b;
}
function binomialCoeff(n , k)
{
var C = Array(k + 1).fill(0);
C[0] = 1;
for (i = 1; i <= n; i++)
{
for (j = min(i, k); j > 0; j--)
C[j] = C[j] + C[j - 1];
}
return C[k];
}
var n = 3, m = 2;
document.write( "Number of Paths: " + binomialCoeff(n + m, n));
</script>
|
Output
Number of Paths: 10
Time Complexity : O((m+n)*n)
Auxiliary Space : O(n)
Last Updated :
14 Feb, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...