Skip to content
Related Articles

Related Articles

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 : 05 Aug, 2020

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

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :