将一根长度为 N 的棍棒切成最多 K 个长度的均匀长度的方法数

给定一根长度为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];
 
    // Initialize 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];
 
    // Initialize 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];
 
    // Initialize 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

Javascript

 
// Javascript program to implement
// the above approach
 
// Recursive Function to count
// the total number of ways
function 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
    let cnt = 0;
    for(let 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
         
    let mod = (1e9 + 7);
    let n = 4, k = 2;
       
    let dp = new Array(n+1).fill(0);
    for(let i = 0; i < n + 1; i++)
        dp[i] = -1;
           
    let ans = solve(n, k, mod, dp);
       
    document.write(ans);
       

输出：

1

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。