Skip to content
Related Articles

Related Articles

Improve Article

Maximize the number of segments of length p, q and r

  • Difficulty Level : Medium
  • Last Updated : 10 Sep, 2021

Given a rod of length L, the task is to cut the rod in such a way that the total number of segments of length p, q and r is maximized. The segments can only be of length p, q, and r. 

Examples: 

Input: l = 11, p = 2, q = 3, r = 5 
Output:
Segments of 2, 2, 2, 2 and 3

Input: l = 7, p = 2, q = 5, r = 5 
Output:
Segments of 2 and 5



Approach: 

As the solution for a maximum number of cuts that can be made in a given length depends on the maximum number of cuts previously made in shorter lengths, this question could be solved by the approach of Dynamic Programming. Suppose we are given a length ‘l’. For finding the maximum number of cuts that can be made in length ‘l’, find the number of cuts made in shorter previous length ‘l-p’, ‘l-q’, ‘l-r’ lengths respectively. The required answer would be the max(l-p,l-q,l-r)+1 as one more cut should be needed after this to cut length ‘l’. So for solving this problem for a given length, find the maximum number of cuts that can be made in lengths ranging from ‘1’ to ‘l’

Example:  

l = 11, p = 2, q = 3, r = 5 
Analysing lengths from 1 to 11: 

  1. Not possible to cut->0
  2. Possible cut is of lengths 2->1 (2)
  3. Possible cut is of lengths 3->1 (3)
  4. Possible cuts are of lengths max(arr[4-2],arr[4-3])+1->2 (2,2)
  5. Possible cuts are of lengths max(arr[5-2],arr[5-3])+1->2 (2,3)
  6. Possible cuts are of lengths max(arr[6-2],arr[6-3],arr[6-5])+1->3 (2,2,2)
  7. Possible cuts are of lengths max(arr[7-2],arr[7-3],arr[7-5])+1->3 (2,3,2) or (2,2,3)
  8. Possible cuts are of lengths max(arr[8-2],arr[8-3],arr[8-5])+1->4 (2,2,2,2)
  9. Possible cuts are of lengths max(arr[9-2],arr[9-3],arr[9-5])+1->4 (2,3,2,2) or (2,2,3,2) or (2,2,2,3)
  10. Possible cuts are of lengths max(arr[10-2],arr[10-3],arr[10-5])+1->5 (2,2,2,2,2)
  11. Possible cuts are of lengths max(arr[11-2],arr[11-3],arr[11-5])+1->5 (2,3,2,2,2) or (2,2,3,2,2) or (2,2,2,3,2) or (2,2,2,2,3)

Algorithm: 

  1. Initialise an array DP[]={-1} and DP[0]=0.
  2. Run a loop from ‘1’ to ‘l’
  3. If DP[i]=-1 means it’s not possible to divide it using giving segments p,q,r so continue;
  4. DP[i+p]=max(DP[i+p],DP[i]+1)
  5. DP[i+q]=max(DP[i+q],DP[i]+1)
  6. DP[i+r]=max(DP[i+r],DP[i]+1)
  7. print DP[l]

Pseudo Code: 

DP[l+1]={-1}
DP[0]=0
for(i from 0 to l)
  if(DP[i]==-1)
  continue
  DP[i+p]=max(DP[i+p],DP[i]+1)
  DP[i+q]=max(DP[i+q],DP[i]+1)
  DP[i+r]=max(DP[i+r],DP[i]+1)

print(DP[l])

Implementation: 

C++




// C++ program to maximize the number
// of segments of length p, q and r
#include <bits/stdc++.h>
using namespace std;
  
// Function that returns the maximum number
// of segments possible
int findMaximum(int l, int p, int q, int r)
{
  
    // Array to store the cut at each length
    int dp[l + 1];
  
    // All values with -1
    memset(dp, -1, sizeof(dp));
  
    // if length of rod is 0 then total cuts will be 0
    // so, initialize the dp[0] with 0
    dp[0] = 0;
  
    for (int i = 0; i <= l; i++) {
  
        // if certain length is not possible
        if (dp[i] == -1)
            continue;
  
        // if a segment of p is possible
        if (i + p <= l)
            dp[i + p] = max(dp[i + p], dp[i] + 1);
  
        // if a segment of q is possible
        if (i + q <= l)
            dp[i + q] = max(dp[i + q], dp[i] + 1);
  
        // if a segment of r is possible
        if (i + r <= l)
            dp[i + r] = max(dp[i + r], dp[i] + 1);
    }
    // if no segment can be cut then return 0
    if (dp[l] == -1) {
        dp[l] = 0;
    }
    // return value corresponding to length l
    return dp[l];
}
  
// Driver Code
int main()
{
    int l = 11, p = 2, q = 3, r = 5;
  
    // Calling Function
    int ans = findMaximum(l, p, q, r);
    cout << ans;
  
    return 0;
}

Java




// Java program to maximize
// the number of segments
// of length p, q and r
import java.io.*;
  
class GFG {
  
    // Function that returns
    // the maximum number
    // of segments possible
    static int findMaximum(int l, int p, int q, int r)
    {
  
        // Array to store the
        // cut at each length
        int dp[] = new int[l + 1];
  
        // All values with -1
        for (int i = 0; i < l + 1; i++)
            dp[i] = -1;
  
        // if length of rod is 0
        // then total cuts will
        // be 0 so, initialize
        // the dp[0] with 0
        dp[0] = 0;
  
        for (int i = 0; i <= l; i++) {
  
            // if certain length
            // is not possible
            if (dp[i] == -1)
                continue;
  
            // if a segment of
            // p is possible
            if (i + p <= l)
                dp[i + p] = Math.max(dp[i + p], dp[i] + 1);
  
            // if a segment of
            // q is possible
            if (i + q <= l)
                dp[i + q] = Math.max(dp[i + q], dp[i] + 1);
  
            // if a segment of
            // r is possible
            if (i + r <= l)
                dp[i + r] = Math.max(dp[i + r], dp[i] + 1);
        }
  
        // if no segment can be cut then return 0
        if (dp[l] == -1) {
            dp[l] = 0;
        }
        // return value corresponding
        // to length l
        return dp[l];
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int l = 11, p = 2, q = 3, r = 5;
  
        // Calling Function
        int ans = findMaximum(l, p, q, r);
        System.out.println(ans);
    }
}
  
// This code is contributed
// by anuj_67.

Python3




# Python 3 program to
# maximize the number
# of segments of length
# p, q and r
  
# Function that returns
# the maximum number
# of segments possible
  
  
def findMaximum(l, p, q, r):
  
    # Array to store the cut
    # at each length
    # All values with -1
    dp = [-1]*(l + 1)
  
    # if length of rod is 0 then
    # total cuts will be 0
    # so, initialize the dp[0] with 0
    dp[0] = 0
  
    for i in range(l+1):
  
        # if certain length is not
        # possible
        if (dp[i] == -1):
            continue
  
        # if a segment of p is possible
        if (i + p <= l):
            dp[i + p] = (max(dp[i + p],
                             dp[i] + 1))
  
        # if a segment of q is possible
        if (i + q <= l):
            dp[i + q] = (max(dp[i + q],
                             dp[i] + 1))
  
        # if a segment of r is possible
        if (i + r <= l):
            dp[i + r] = (max(dp[i + r],
                             dp[i] + 1))
  
    # if no segment can be cut then return 0
    if dp[l] == -1:
        dp[l] = 0
    # return value corresponding
    # to length l
    return dp[l]
  
  
# Driver Code
if __name__ == "__main__":
    l = 11
    p = 2
    q = 3
    r = 5
  
    # Calling Function
    ans = findMaximum(l, p, q, r)
    print(ans)
  
# This code is contributed by
# ChitraNayal

C#




// C# program to maximize
// the number of segments
// of length p, q and r
using System;
  
class GFG {
  
    // Function that returns
    // the maximum number
    // of segments possible
    static int findMaximum(int l, int p,
                           int q, int r)
    {
  
        // Array to store the
        // cut at each length
        int[] dp = new int[l + 1];
  
        // All values with -1
        for (int i = 0; i < l + 1; i++)
            dp[i] = -1;
  
        // if length of rod is 0
        // then total cuts will
        // be 0 so, initialize
        // the dp[0] with 0
        dp[0] = 0;
  
        for (int i = 0; i <= l; i++) {
  
            // if certain length
            // is not possible
            if (dp[i] == -1)
                continue;
  
            // if a segment of
            // p is possible
            if (i + p <= l)
                dp[i + p] = Math.Max(dp[i + p], 
                                     dp[i] + 1);
  
            // if a segment of
            // q is possible
            if (i + q <= l)
                dp[i + q] = Math.Max(dp[i + q], 
                                     dp[i] + 1);
  
            // if a segment of
            // r is possible
            if (i + r <= l)
                dp[i + r] = Math.Max(dp[i + r], 
                                     dp[i] + 1);
        }
  
        // if no segment can be cut then return 0
        if (dp[l] == -1) {
            dp[l] = 0;
        }
        // return value corresponding
        // to length l
        return dp[l];
    }
  
    // Driver Code
    public static void Main()
    {
        int l = 11, p = 2, q = 3, r = 5;
  
        // Calling Function
        int ans = findMaximum(l, p, q, r);
        Console.WriteLine(ans);
    }
}
  
// This code is contributed
// by anuj_67.

Javascript




<script>
// Javascript program to maximize
// the number of segments
// of length p, q and r
      
    // Function that returns
    // the maximum number
    // of segments possible
    function findMaximum(l,p,q,r)
    {
        // Array to store the
        // cut at each length
        let dp = new Array(l + 1);
   
        // All values with -1
        for (let i = 0; i < l + 1; i++)
            dp[i] = -1;
   
        // if length of rod is 0
        // then total cuts will
        // be 0 so, initialize
        // the dp[0] with 0
        dp[0] = 0;
   
        for (let i = 0; i <= l; i++) {
   
            // if certain length
            // is not possible
            if (dp[i] == -1)
                continue;
   
            // if a segment of
            // p is possible
            if (i + p <= l)
                dp[i + p] = Math.max(dp[i + p], dp[i] + 1);
   
            // if a segment of
            // q is possible
            if (i + q <= l)
                dp[i + q] = Math.max(dp[i + q], dp[i] + 1);
   
            // if a segment of
            // r is possible
            if (i + r <= l)
                dp[i + r] = Math.max(dp[i + r], dp[i] + 1);
        }
   
        // if no segment can be cut then return 0
        if (dp[l] == -1) {
            dp[l] = 0;
        }
        // return value corresponding
        // to length l
        return dp[l];
    }
      
    // Driver Code
    let l = 11, p = 2, q = 3, r = 5;
    // Calling Function
    let ans = findMaximum(l, p, q, r);
      
    document.write(ans);
      
  
// This code is contributed by rag2127
</script>
Output
5

Complexity Analysis: 

  • Time Complexity: O(N). 
    Use of a single for-loop till length ‘N’.
  • Auxiliary Space: O(N). 
    Use of an array ‘DP’ to keep track of segments

Note: This problem can also be thought of as a minimum coin change problem because we are given a certain length to acquire which is the same as the value of the amount whose minimum change is needed. Now the x,y,z are the same as the denomination of the coin given. So length is the same as the amount and x y z are the same as denominations, thus we need to change only one condition that is instead of finding minimum we need to find the maximum and we will get the answer. As the minimum coin change problem is the basic dynamic programming question so this will help to solve this question also.

The condition we need to change in minimum coin change problem

for(ll i=1;i<=n;i++)
{
     for(ll j=1;j<=3;j++)
     {
          if(i>=a[j]&&m[i-a[j]]!=-1)
          {
               dp[i]=max(dp[i],1+dp[i-a[j]]);
          }
     }
}



My Personal Notes arrow_drop_up
Recommended Articles
Page :