在最多K个单位长片中将长度为N的棍子切成偶数长度的方式的数量

给定长度为N个单位的杆，任务是找到将杆切割成多个零件的方式，以使每个零件的长度均匀，每个零件最多为K个单位。
例子：

Input: N = 6, K = 4 
Output: 3 
Explanation: 
Rod of length 6 units needs to be into parts having length at most 4 units. Hence cut the rod in three ways: 
Way 1: 2 units + 2 units + 2 units 
Way 2: 2 units + 4 units 
Way 3: 4 units + 2 units

Input: N = 4, K = 2 
Output: 1 
Explanation: 
Rod of length 4 units needs to be into parts having length at most 2 units. Hence cut the rod in 2 + 2 units. 
 

方法：想法是使用动态编程，其中最佳子结构是每个部分的长度应均匀。通过对切割后获得的工件递归调用该函数，计算所有的切割杆的方法。
下面是上述方法的实现：

C++14

// C++14 program for the above approach
#include 
using namespace std;
  
// Recursive Function to count
// the total number of ways
int solve(int n, int k, int mod, int dp[])
{
    // Base case if no-solution exist
    if (n < 0)
        return 0;
  
    // Condition if a solution exist
    if (n == 0)
        return 1;
  
    // Check if already calculated
    if (dp[n] != -1)
        return dp[n];
  
    // Initilize counter
    int cnt = 0;
    for (int i = 2; i <= k; i += 2) {
        // Recursive call
        cnt = (cnt % mod
               + solve(n - i, k, mod, dp)
                     % mod)
              % mod;
    }
  
    // Store the answer
    dp[n] = cnt;
  
    // Return the answer
    return cnt;
}
  
// Driver code
int main()
{
  
    const int mod = 1e9 + 7;
    int n = 4, k = 2;
    int dp[n + 1];
    memset(dp, -1, sizeof(dp));
    int ans = solve(n, k, mod, dp);
    cout << ans << '\n';
  
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
  
class GFG{
  
// Recursive Function to count
// the total number of ways
static int solve(int n, int k, int mod, int dp[])
{
      
    // Base case if no-solution exist
    if (n < 0)
        return 0;
  
    // Condition if a solution exist
    if (n == 0)
        return 1;
  
    // Check if already calculated
    if (dp[n] != -1)
        return dp[n];
  
    // Initilize counter
    int cnt = 0;
    for(int i = 2; i <= k; i += 2) 
    {
          
        // Recursive call
        cnt = (cnt % mod + solve(n - i, k, mod,
               dp) % mod) % mod;
    }
  
    // Store the answer
    dp[n] = cnt;
  
    // Return the answer
    return cnt;
}
  
// Driver code
public static void main(String[] args)
{
    int mod = (int)(1e9 + 7);
    int n = 4, k = 2;
      
    int []dp = new int[n + 1];
    for(int i = 0; i < n + 1; i++)
        dp[i] = -1;
          
    int ans = solve(n, k, mod, dp);
      
    System.out.println(ans);
}
}
  
// This code is contributed by Amit Katiyar

Python3

# Python3 program for the above approach
  
# Recursive function to count
# the total number of ways
def solve(n, k, mod, dp):
      
    # Base case if no-solution exist
    if (n < 0):
        return 0
  
    # Condition if a solution exist
    if (n == 0):
        return 1
  
    # Check if already calculated
    if (dp[n] != -1):
        return dp[n]
  
    # Initialize counter
    cnt = 0
    for i in range(2, k + 1, 2):
          
        # Recursive call
        cnt = ((cnt % mod +
                solve(n - i, k, mod, dp) %
                                    mod) % mod)
                                     
    # Store the answer
    dp[n] = cnt
  
    # Return the answer
    return int(cnt)
  
# Driver code
if __name__ == '__main__':
      
    mod = 1e9 + 7
    n = 4
    k = 2
      
    dp = [-1] * (n + 1)
    ans = solve(n, k, mod, dp)
      
    print(ans)
      
# This code is contributed by mohit kumar 29

C#

// C# program for the above approach
using System;
  
class GFG{
  
// Recursive function to count
// the total number of ways
static int solve(int n, int k, int mod, int []dp)
{
      
    // Base case if no-solution exist
    if (n < 0)
        return 0;
  
    // Condition if a solution exist
    if (n == 0)
        return 1;
  
    // Check if already calculated
    if (dp[n] != -1)
        return dp[n];
  
    // Initilize counter
    int cnt = 0;
    for(int i = 2; i <= k; i += 2) 
    {
          
        // Recursive call
        cnt = (cnt % mod + solve(n - i, k, mod,
               dp) % mod) % mod;
    }
  
    // Store the answer
    dp[n] = cnt;
  
    // Return the answer
    return cnt;
}
  
// Driver code
public static void Main(String[] args)
{
    int mod = (int)(1e9 + 7);
    int n = 4, k = 2;
      
    int []dp = new int[n + 1];
    for(int i = 0; i < n + 1; i++)
        dp[i] = -1;
          
    int ans = solve(n, k, mod, dp);
      
    Console.WriteLine(ans);
}
}
  
// This code is contributed by Amit Katiyar

输出：

1