Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Counts paths from a point to reach Origin

  • Difficulty Level : Easy
  • Last Updated : 13 Oct, 2021

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: 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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++




// C++ program to count total number of
// paths from a point to origin
#include<bits/stdc++.h>
using namespace std;
  
// Recursive function to count number of paths
int countPaths(int n, int 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));
}
  
// Driver Code
int main()
{
    int n = 3, m = 2;
    cout << " Number of Paths " << countPaths(n, m);
    return 0;
}
Java



// Java program to count total number of
// paths from a point to origin
import java.io.*;
  
class GFG {
      
    // Recursive function to count number of paths
    static int countPaths(int n, int 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));
    }
      
    // Driver Code
    public static void main (String[] args)
    {
        int n = 3, m = 2;
        System.out.println (" Number of Paths "
                            + countPaths(n, m));
          
    }
}
  
// This code is contributed by vt_m
Python3



# Python3 program to count
# total number of
# paths from a point to origin
# Recursive function to 
# count number of paths
def countPaths(n,m):
  
    # If we reach bottom
    # or top left, we are
    # have only one way to reach (0, 0)
    if (n==0 or m==0):
        return 1
   
    # Else count sum of both ways
    return (countPaths(n-1, m) + countPaths(n, m-1))
  
# Driver Code
n = 3
m = 2
print(" Number of Paths ", countPaths(n, m))
  
# This code is contributed
# by Azkia Anam.
C#



// C# program to count total number of
// paths from a point to origin
using System;
          
public class GFG {
      
    // Recursive function to count number
    // of paths
    static int countPaths(int n, int 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));
    }
      
    // Driver Code
    public static void Main ()
    {
        int n = 3, m = 2;
          
        Console.WriteLine (" Number of"
         + " Paths " + countPaths(n, m));
          
    }
}
  
// This code is contributed by Sam007.
PHP



<?php
// PHP program to count total number
// of paths from a point to origin
  
// Recursive function to 
// count number of paths
function 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));
}
  
    // Driver Code
    $n = 3; 
    $m = 2;
    echo " Number of Paths " 
      , countPaths($n, $m);
  
// This code is contributed by aj_36
?>
Javascript



<script>
  
// Javascript program to count total number of
// paths from a point to origin
  
    // Recursive function to count number of paths
    function 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));
    }
  
    // Driver Code
       
        let n = 3, m = 2;
        document.write(" Number of Paths " + countPaths(n, m));
  
// This code is contributed by shikhasingrajput
  
</script>
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++



// C++ program to count total number of
// paths from a point to origin
#include<bits/stdc++.h>
using namespace std;
  
// DP based function to count number of paths
int countPaths(int n, int m)
{
    int dp[n+1][m+1];
  
    // Fill entries in bottommost row and leftmost
    // columns
    for (int i=0; i<=n; i++)
      dp[i][0] = 1;
    for (int i=0; i<=m; i++)
      dp[0][i] = 1;
  
    // Fill DP in bottom up manner
    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];
}
  
// Driver Code
int main()
{
    int n = 3, m = 2;
    cout << " Number of Paths " << countPaths(n, m);
    return 0;
}
Java



// Java program to count total number of
// paths from a point to origin
import java.io.*;
  
class GFG {
      
    // DP based function to count number of paths
    static int countPaths(int n, int m)
    {
        int dp[][] = new int[n + 1][m + 1];
      
        // Fill entries in bottommost row and leftmost
        // columns
        for (int i = 0; i <= n; i++)
            dp[i][0] = 1;
        for (int i = 0; i <= m; i++)
            dp[0][i] = 1;
      
        // Fill DP in bottom up manner
        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];
    }
      
    // Driver Code
    public static void main (String[] args) {
        int n = 3, m = 2;
        System.out.println(" Number of Paths "
                           + countPaths(n, m));
          
    }
}
  
// This code is contributed by vt_m
Python3



# Python3 program to count total 
# number of paths from a po to origin
  
# Recursive function to count
# number of paths
def countPaths(n, m):
  
    # If we reach bottom or top 
    # left, we are have only one 
    # way to reach (0, 0)
    if (n == 0 or m == 0):
        return 1
  
    # Else count sum of both ways
    return (countPaths(n - 1, m) + 
            countPaths(n, m - 1))
  
# Driver Code
n = 3
m = 2
print("Number of Paths",
       countPaths(n, m))
  
# This code is contributed by ash264
C#



// C# program to count total number of
// paths from a point to origin
using System;
          
public class GFG {
      
    // DP based function to count number
    // of paths
    static int countPaths(int n, int m)
    {
        int [,]dp = new int[n + 1,m + 1];
      
        // Fill entries in bottommost row
        // and leftmost columns
        for (int i = 0; i <= n; i++)
            dp[i,0] = 1;
        for (int i = 0; i <= m; i++)
            dp[0,i] = 1;
      
        // Fill DP in bottom up manner
        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];
    }
      
    // Driver Code
    public static void Main ()
    {
        int n = 3, m = 2;
          
        Console.WriteLine(" Number of"
        + " Paths " + countPaths(n, m));
          
    }
}
  
// This code is contributed by Sam007.
PHP



<?php
// PHP program to count total number of
// paths from a point to origin
  
// DP based function to 
// count number of paths
function countPaths($n, $m)
{
      
    //$dp[$n+1][$m+1];
    // Fill entries in bottommost
    // row and leftmost columns
    for ($i = 0; $i <= $n; $i++)
        $dp[$i][0] = 1;
          
    for ($i = 0; $i <= $m; $i++)
        $dp[0][$i] = 1;
  
    // Fill DP in bottom up manner
    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];
}
  
    // Driver Code
    $n = 3;
    $m = 2;
    echo " Number of Paths " , countPaths($n, $m);
  
// This code is contributed by m_kit
?>
Javascript



<script>
// javascript program to count total number of
// paths from a point to origin
     
// DP based function to count number of paths
function countPaths(n , m)
{
    var dp = Array(n+1).fill(0).map(x => Array(m+1).fill(0));
  
    // Fill entries in bottommost row and leftmost
    // columns
    for (i = 0; i <= n; i++)
        dp[i][0] = 1;
    for (i = 0; i <= m; i++)
        dp[0][i] = 1;
  
    // Fill DP in bottom up manner
    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];
}
      
// Driver Code
var n = 3, m = 2;
document.write(" Number of Paths "
                   + countPaths(n, m));  
                     
// This code is contributed by Amit Katiyar 
</script>
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++



// C++ Program for above approach
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
  
// Function to find 
// binomial Coefficient
int binomialCoeff(int n, int k) 
{ 
    int C[k+1]; 
    memset(C, 0, sizeof(C)); 
    C[0] = 1;
    
    // Constructing Pascal's Triangle
    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]; 
} 
  
//Driver Code
int main() 
{
    int n=3, m=2;
    cout<<"Number of Paths: "<< 
                binomialCoeff(n+m,n)<<endl;
    return 0;
}
  
//Contributed by Vismay_7
Java



// Java Program for above approach
import java.io.*;
import java.util.*;
  
class GFG 
{
    static int min(int a,int b)
    {
        return a<b?a:b;
    }
    
    // Function for binomial 
    // Coefficient
    static int binomialCoeff(int n, int k) 
    { 
        int C[] = new int[k + 1]; 
        C[0] = 1;  
          
        //Constructing Pascal's Triangle
        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]; 
    }
    
    // Driver Code
    public static void main (String[] args) 
    {
        int n=3,m=2;
        System.out.println("Number of Paths: " + 
                           binomialCoeff(n+m,n));
    }
}
//Contributed by Vismay_7
Python3



# Python3 program for above approach
def binomialCoeff(n,k):
      
    C = [0]*(k+1)
    C[0] = 1
      
    # Computing Pascal's Triangle
    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] 
    
# Driver Code
n=3
m=2
print("Number of Paths:",binomialCoeff(n+m,n))
  
# Contributed by Vismay_7
C#



// C# program for above approach
using System;
  
class GFG{
      
// Function to find 
// binomial Coefficient
static int binomialCoeff(int n, int k) 
{ 
    int[] C = new int[k + 1];
    C[0] = 1;
     
    // Constructing Pascal's Triangle
    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]; 
} 
  
// Driver code
static void Main() 
{
    int n = 3, m = 2;
      
    Console.WriteLine("Number of Paths: " + 
                      binomialCoeff(n + m, n));
}
}
  
// This code is contributed by divyesh072019
Javascript



<script>
// javascript Program for above approach
    function min(a , b) 
    {
        return a < b ? a : b;
    }
  
    // Function for binomial
    // Coefficient
    function binomialCoeff(n , k) 
    {
        var C = Array(k + 1).fill(0);
        C[0] = 1;
  
        // Constructing Pascal's Triangle
        for (i = 1; i <= n; i++)
        {
            for (j = min(i, k); j > 0; j--)
                C[j] = C[j] + C[j - 1];
        }
        return C[k];
    }
  
    // Driver Code
    var n = 3, m = 2;
    document.write("Number of Paths: " + binomialCoeff(n + m, n));
  
// This code is contributed by Amit Katiyar  
</script>
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 write.geeksforgeeks.org or mail your article to review-team@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.



My Personal Notes
arrow_drop_up
Previous
Counting pairs when a person can form pair with at most one
Next

Count number of ways to cover a distance
Recommended Articles
Page :
Counts paths from a point to reach Origin : Memory Optimized
08, Apr 20
Number of ways to reach (X, Y) in a matrix starting from the origin
18, Nov 19
Number of ways to reach (M, N) in a matrix starting from the origin without visiting (X, Y)
25, Jun 20
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
Number of shortest paths to reach every cell from bottom-left cell in the grid
14, Aug 19
Sum of cost of all paths to reach a given cell in a Matrix
28, May 20
Paths requiring minimum number of jumps to reach end of array
22, Sep 20
Check if it is possible to reach M from 0 by given paths
27, Jun 21
Queries for counts of array elements with values in given range
12, Jul 17
Counts Path in an Array
30, Aug 19
Queries for counts of multiples in an array
05, Oct 17
Generate original array from an array that store the counts of greater elements on right
24, Nov 17
Minimum operations to make counts of remainders same in an array
13, Feb 19
Count integers in an Array which are multiples their bits counts
26, Apr 20
Counts 1s that can be obtained in an Array by performing given operations
03, Jan 21
Print all paths from a source point to all the 4 corners of a Matrix
27, Sep 21
Minimum cost to reach a point N from 0 with two different operations allowed
14, Nov 18
Maximize jump size to reach all given points from given starting point
26, Oct 21
Count of ways to traverse a Matrix and return to origin in K steps
18, Jun 20
Displacement from origin after N moves of given distances in specified directions
25, Mar 21
Minimum distance to visit given K points on X-axis after starting from the origin
05, Nov 20
Print all possible paths from top left to bottom right of a mXn matrix
22, Dec 13
Count all possible paths from top left to bottom right of a mXn matrix
31, Dec 13
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





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!