Skip to content
Related Articles

Related Articles

Improve Article

Number of ways to cut a stick of length N into in even length at most K units long pieces

  • Difficulty Level : Medium
  • Last Updated : 01 Jun, 2021

Given a rod of length N units, the task is to find the number of ways to cut the rod into parts such that the length of each part is even and each part is at most K units.
Examples:
 

Input: N = 6, K = 4 
Output:
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:
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. 
 

Approach: The idea is to use dynamic programming where the optimal sub-structure is that the length of each part should be even. Count all the way to cut the rod by calling the function recursively for a piece obtained after a cut.
Below is the implementation of the above approach:

C++14




// C++14 program for the above approach
#include <bits/stdc++.h>
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




<script>
 
// 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);
       
</script>
Output: 
1

 

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :