计算从点到起点的路径

您正站在一个点(n，m)上，并且想要通过向左或向下迈出一步来到达原点(0，0) ，即从每个点开始，您都可以在(n-1，m)或( n，m-1) 。查找从点到原点的路径数。

例子：

Input : 3 6
Output : Number of Paths 84

Input : 3 0
Output : Number of Paths 1

由于我们只能上下移动，因此我们将对
可以采取的步骤。

// 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));
} 

以下是上述步骤的执行。

C++

// C++ program to count total number of
// paths from a point to origin
#include
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.

Javascript

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

---

输出

Number of Paths 10

我们可以使用动态编程，因为存在重叠的子问题。我们可以绘制递归树以查看重叠的问题。例如，在countPaths(4，4)的情况下，我们多次计算countPaths(3，3)。

C++

// C++ program to count total number of
// paths from a point to origin
#include
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.

Java脚本

// javascript program to count total number of
// paths from a povar 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

输出

Number of Paths 10

另一种方法：

使用Pascal的Triangle方法，我们还通过计算^{n + m} C _n的值来解决该问题。当您增加m的值并保持n的值不变时，可以将其视为一种模式。
下面是上述方法的实现：

C++

// C++ Program for above approach
#include 
#include 
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)<

Java

// Java Program for above approach
import java.io.*;
import java.util.*;
 
class GFG
{
    static int min(int a,int b)
    {
        return a 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

Java脚本

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

输出

Number of Paths: 10