计算权重正好为X且权重至少为M的路径的数量

给定一棵无穷树和三个数字N，M和X，每个节点恰好有N个子节点。每个边缘的权重分别为1、2、3、4..N。任务是找到权重正好为X且其中最小权重为M的一条边的路径计数。

上图显示了直到第3级且N = 3为止的树。

例子：

Input: N = 3, M = 2, X = 3
Output: 2
The path 1-2 and 2-1 in the image above 

Input:  N = 2, M = 1, X = 4
Output:  4 

方法：可以使用动态编程和记忆来解决该问题。我们将使用自上而下的方法来解决此问题。从根开始递归，其总和最初为X，然后递归遍历所有可能的路径(从1到N)。如果节点等于M，则第二个参数变为true，否则它将保持与上一次调用中传递的参数相同。将值存储在DP [] []表中，以避免两次访问相同的状态。

下面是上述方法的实现。

C++

// C++ program to count the number of paths
#include 
using namespace std;
#define max 4
#define c 2
  
// Function to find the number of paths
int countPaths(int sum, int get, int m, int n, int dp[])
{
  
    // If the summation is more than X
    if (sum < 0)
        return 0;
  
    // If exactly X weights have reached
    if (sum == 0)
        return get;
  
    // Already visited
    if (dp[sum][get] != -1)
        return dp[sum][get];
  
    // Count paths
    int res = 0;
  
    // Traverse in all paths
    for (int i = 1; i <= n; i++) {
  
        // If the edge weight is M
        if (i == m)
            res += countPaths(sum - i, 1, m, n, dp);
        else // Edge's weight is not M
            res += countPaths(sum - i, get, m, n, dp);
    }
  
    dp[sum][get] = res;
  
    return dp[sum][get];
}
  
// Driver Code
int main()
{
    int n = 3, m = 2, x = 3;
  
    int dp[max + 1];
  
    // Initialized the DP array with -1
    for (int i = 0; i <= max; i++)
        for (int j = 0; j < 2; j++)
            dp[i][j] = -1;
  
    // Function to count paths
    cout << countPaths(x, 0, m, n, dp);
}

Java

// Java program to count the number of paths
  
public class GFG{
  
    static int max = 4 ;
    static int  c = 2 ;
      
    // Function to find the number of paths
    static int countPaths(int sum, int get, int m, int n, int dp[][])
    {
      
        // If the summation is more than X
        if (sum < 0)
            return 0;
      
        // If exactly X weights have reached
        if (sum == 0)
            return get;
      
        // Already visited
        if (dp[sum][get] != -1)
            return dp[sum][get];
      
        // Count paths
        int res = 0;
      
        // Traverse in all paths
        for (int i = 1; i <= n; i++) {
      
            // If the edge weight is M
            if (i == m)
                res += countPaths(sum - i, 1, m, n, dp);
            else // Edge's weight is not M
                res += countPaths(sum - i, get, m, n, dp);
        }
      
        dp[sum][get] = res;
      
        return dp[sum][get];
    }
      
    // Driver Code
    public static void main(String []args)
    {
        int n = 3, m = 2, x = 3;
      
        int dp[][] = new int[max + 1][2];
      
        // Initialized the DP array with -1
        for (int i = 0; i <= max; i++)
            for (int j = 0; j < 2; j++)
                dp[i][j] = -1;
      
        // Function to count paths
        System.out.println(countPaths(x, 0, m, n, dp));
    }
    // This code is contributed by Ryuga
}

Python3

# Python3 program to count the number of paths
Max = 4
c = 2
  
# Function to find the number of paths
def countPaths(Sum, get, m, n, dp):
  
    # If the Summation is more than X
    if (Sum < 0):
        return 0
  
    # If exactly X weights have reached
    if (Sum == 0):
        return get
  
    # Already visited
    if (dp[Sum][get] != -1):
        return dp[Sum][get]
  
    # Count paths
    res = 0
  
    # Traverse in all paths
    for i in range(1, n + 1): 
  
        # If the edge weight is M
        if (i == m):
            res += countPaths(Sum - i, 1, m, n, dp)
        else: # Edge's weight is not M
            res += countPaths(Sum - i, get, m, n, dp)
      
    dp[Sum][get] = res
  
    return dp[Sum][get]
  
# Driver Code
n = 3
m = 2
x = 3
dp = [[-1 for i in range(2)] 
          for i in range(Max + 1)]
  
# Initialized the DP array with -1
for i in range(Max + 1):
    for j in range(2):
        dp[i][j] = -1
  
# Function to count paths
print(countPaths(x, 0, m, n, dp))
  
# This code is contributed by Mohit kumar 29

C#

// C# program to count the number of paths
using System;
  
class GFG
{
    static int max = 4 ;
    static int c = 2 ;
      
    // Function to find the number of paths
    static int countPaths(int sum, int get, int m, 
                          int n, int[, ] dp)
    {
      
        // If the summation is more than X
        if (sum < 0)
            return 0;
      
        // If exactly X weights have reached
        if (sum == 0)
            return get;
      
        // Already visited
        if (dp[sum, get] != -1)
            return dp[sum, get];
      
        // Count paths
        int res = 0;
      
        // Traverse in all paths
        for (int i = 1; i <= n; i++) 
        {
      
            // If the edge weight is M
            if (i == m)
                res += countPaths(sum - i, 1, m, n, dp);
            else // Edge's weight is not M
                res += countPaths(sum - i, get, m, n, dp);
        }
      
        dp[sum, get] = res;
      
        return dp[sum, get];
    }
      
    // Driver Code
    public static void Main()
    {
        int n = 3, m = 2, x = 3;
      
        int[,] dp = new int[max + 1, 2];
      
        // Initialized the DP array with -1
        for (int i = 0; i <= max; i++)
            for (int j = 0; j < 2; j++)
                dp[i, j] = -1;
      
        // Function to count paths
        Console.WriteLine(countPaths(x, 0, m, n, dp));
    }
}
  
// This code is contributed by Akanksha Rai

输出：

2