Open in App
Not now

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

• Difficulty Level : Medium
• Last Updated : 23 Jan, 2023

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:
Explanation: Segments of 2, 2, 2, 2 and 3

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

Recommended Practice

## Maximize the number of segments of length p, q, and r using Memoization:

This can be visualized as a classical recursion problem, which further narrows down to the memoization ( top-down ) method of Dynamic Programming.

Follow the below steps to solve the problem:

• Initially, we have length l present with us, we’d have three size choices to cut from this, either we can make a cut of length p, q, or r
• Let’s say we made a cut of length p, so the remaining length would be l-p, and similarly, with cuts q & r resulting in remaining lengths l-q & l-r respectively.
• We will call the recursive function for the remaining lengths and at any subsequent instance, we’ll have these three choices.
• We will store the answer from all these recursive calls & take the maximum out of them +1 as at any instance we’ll have 1 cut from this particular call as well.

Note: The recursive call would be made if and only if the available length is greater than the length we want to cut i.e. suppose p=3, and after certain recursive calls the available length is 2 only, so we can’t cut this line in lengths of p anymore.

Below is the pseudocode for the above approach:

## C

 `if` `(l == 0) ``// Base Case` `    ``return` `0;`   `int` `a, b, c;` `if` `(p <= l)` `    ``a = func(l - p, p, q, r);` `if` `(q <= l)` `    ``b = func(l - q, p, q, r);` `if` `(r <= l)` `    ``c = func(l - r, p, q, r);` `return` `1 + max({ a, b, c });`

Below is the recursion tree for Input: l=4,p=2,q=1 and r=1:

Recursion Tree for l=4 , p=2 ,q=1 and r=1

One can clearly observe that at each call, the given length ( 4 initially ) is divided into 3 different subparts. Also, we can see that the recursion is being repeated for certain entries (The red arrow represents a repetitive call for l=2, Yellow for l=3, and Blue for l=1). Therefore, we can memoize the results in any container or array, so that repetition of the same recursive calls is avoided.

Now, the above pseudocode changes to:

## C++

 `vector<``int``> dp(10005,-1);         ``// Initialise DP Table ( Array can also be used )`     `if``(l==0)                         ``// Base Case` ` ``return` `0;` ` `  `if``(dp[l]!=-1)                 ``// If already memoized , return from here only` `   ``return` `dp[l];` `int` `a,b,c;` `if``(p<=l)` `  ``a=func(l-p,p,q,r);` `if``(q<=l)` `  ``b=func(l-q,p,q,r);` `if``(r<=l)` `  ``c=func(l-r,p,q,r);` `  `  `  `  `return` `dp[l]=1+max({a,b,c});          ``// Memoize the result in the dp table & return`

Below is the implementation of the above approach:

## C++

 `// C++ Code to find maximum number of cut segments` `// Memoization DP`   `#include ` `using` `namespace` `std;`   `// Function to find the maximum number of cuts.` `int` `dp[10005];`   `int` `func(``int` `l, ``int` `p, ``int` `q, ``int` `r)` `{` `    ``if` `(l == 0)` `        ``return` `0; ``// Base Case`   `    ``if` `(dp[l] != -1) ``// If already memoized` `        ``return` `dp[l];`   `    ``int` `a(INT_MIN), b(INT_MIN),` `        ``c(INT_MIN); ``// Intitialise a,b,& c with INT_MIN`   `    ``if` `(p <= l) ``// If Possible to make a cut of length p` `        ``a = func(l - p, p, q, r);`   `    ``if` `(q <= l) ``// If possible to make a cut of length q` `        ``b = func(l - q, p, q, r);`   `    ``if` `(r <= l) ``// If possible to make a cut of length r` `        ``c = func(l - r, p, q, r);`   `    ``return` `dp[l] = 1 + max({ a, b, c }); ``// Memoize & return` `}`   `int` `maximizeTheCuts(``int` `l, ``int` `p, ``int` `q, ``int` `r)` `{` `    ``memset``(dp, -1, ``sizeof``(dp)); ``// Set Lookup table to -1` `    ``int` `ans = func(l, p, q, r); ``// Utility function call`   `    ``if` `(ans < 0)` `        ``return` `0; ``// If returned answer is negative , that` `                  ``// means cuts are not possible` `    ``return` `ans;` `}`   `// Driver code` `int` `main()` `{`   `    ``int` `l = 11, p = 2, q = 3, r = 5;`   `    ``cout << maximizeTheCuts(l, p, q, r) << endl;` `    ``return` `0;` `}`

## Java

 `// Java Code to find maximum number of cut segments` `// Memoization DP` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to find the maximum number of cuts.` `    ``static` `int``[] dp;`   `    ``static` `int` `func(``int` `l, ``int` `p, ``int` `q, ``int` `r)` `    ``{` `        ``if` `(l == ``0``)` `            ``return` `0``; ``// Base Case`   `        ``if` `(dp[l] != -``1``) ``// If already memoized` `            ``return` `dp[l];`   `        ``int` `a, b, c; ``// Intitialise a,b,& c with INT_MIN` `        ``a = Integer.MIN_VALUE;` `        ``b = Integer.MIN_VALUE;` `        ``c = Integer.MIN_VALUE;` `        ``if` `(p <= l) ``// If Possible to make a cut of length p` `            ``a = func(l - p, p, q, r);`   `        ``if` `(q <= l) ``// If possible to make a cut of length q` `            ``b = func(l - q, p, q, r);`   `        ``if` `(r <= l) ``// If possible to make a cut of length r` `            ``c = func(l - r, p, q, r);`   `        ``return` `dp[l] = ``1` `                       ``+ Math.max(Math.max(a, b),` `                                  ``c); ``// Memoize & return` `    ``}`   `    ``static` `int` `maximizeTheCuts(``int` `l, ``int` `p, ``int` `q, ``int` `r)` `    ``{` `        ``Arrays.fill(dp, -``1``); ``// Set Lookup table to -1` `        ``int` `ans = func(l, p, q, r); ``// Utility function call`   `        ``if` `(ans < ``0``)` `            ``return` `0``; ``// If returned answer is negative ,` `                      ``// that means cuts are not possible` `        ``return` `ans;` `    ``}`   `      ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``dp = ``new` `int``[``10005``];` `        ``int` `l = ``11``, p = ``2``, q = ``3``, r = ``5``;` `        ``System.out.println(maximizeTheCuts(l, p, q, r));` `    ``}` `}`

## Python3

 `# Python Code to find maximum number of cut segments` `# Memoization DP` `import` `sys`   `# Function to find the maximum number of cuts.` `dp ``=` `[``0``]``*``10005`   `def` `func(l, p, q, r):` `    ``# Base Case` `    ``if` `(l ``=``=` `0``):` `        ``return` `0` `    ``# If already memoized` `    ``if` `(dp[l] !``=` `-``1``):` `        ``return` `dp[l]` `    `  `    ``# Intitialise a,b,& c with INT_MIN` `    ``a, b, c ``=` `-``1``*``sys.maxsize,``-``1``*``sys.maxsize,``-``1``*``sys.maxsize` `    `  `    ``# If Possible to make a cut of length p` `    ``if` `(p <``=` `l):` `        ``a ``=` `func(l ``-` `p, p, q, r)` `    `  `    ``# If possible to make a cut of length q` `    ``if` `(q <``=` `l):` `        ``b ``=` `func(l ``-` `q, p, q, r)` `    `  `    ``# If possible to make a cut of length r` `    ``if` `(r <``=` `l):` `        ``c ``=` `func(l ``-` `r, p, q, r)` `        `  `    ``# Memoize & return` `    ``dp[l] ``=` `1` `+` `max``(``max``(a, b),c)` `    ``return` `dp[l]` `    `  `def` `maximizeTheCuts(l, p, q, r):` `    ``# Set Lookup table to -1` `    ``for` `i ``in` `range``(``len``(dp)):` `        ``dp[i]``=``-``1` `        `  `    ``# Utility function call` `    ``ans ``=` `func(l, p, q, r)` `    `  `    ``# If returned answer is negative , that` `    ``# means cuts are not possible` `    ``if` `(ans < ``0``):` `        ``return` `0` `    `  `    ``return` `ans`   `# Driver code` `l ``=` `11` `p ``=` `2` `q ``=` `3` `r ``=` `5` `print``(maximizeTheCuts(l, p, q, r))`   `# This code is contributed by Utkarsh`

## C#

 `// C# Code to find maximum number of cut segments` `// Memoization DP` `using` `System;`   `class` `GFG {`   `  ``// Function to find the maximum number of cuts.` `  ``static` `int``[] dp;`   `  ``static` `int` `func(``int` `l, ``int` `p, ``int` `q, ``int` `r)` `  ``{` `    ``if` `(l == 0)` `      ``return` `0; ``// Base Case`   `    ``if` `(dp[l] != -1) ``// If already memoized` `      ``return` `dp[l];`   `    ``int` `a, b, c; ``// Intitialise a,b,& c with INT_MIN` `    ``a = Int32.MinValue;` `    ``b = Int32.MinValue;` `    ``c = Int32.MinValue;` `    ``if` `(p <= l) ``// If Possible to make a cut of length p` `      ``a = func(l - p, p, q, r);`   `    ``if` `(q <= l) ``// If possible to make a cut of length q` `      ``b = func(l - q, p, q, r);`   `    ``if` `(r <= l) ``// If possible to make a cut of length r` `      ``c = func(l - r, p, q, r);`   `    ``return` `dp[l] = 1` `      ``+ Math.Max(Math.Max(a, b),` `                 ``c); ``// Memoize & return` `  ``}`   `  ``static` `int` `maximizeTheCuts(``int` `l, ``int` `p, ``int` `q, ``int` `r)` `  ``{` `    ``// Set Lookup table to -1` `    ``for``(``int` `i=0;i

## Javascript

 `// Javascript Code to find maximum number of cut segments` `// Memoization DP`   `// Function to find the maximum number of cuts.` `let dp=``new` `Array(10005);`   `function` `func( l, p, q, r)` `{` `    ``if` `(l == 0)` `        ``return` `0; ``// Base Case`   `    ``if` `(dp[l] != -1) ``// If already memoized` `        ``return` `dp[l];`   `    ``// Intitialise a,b,& c with INT_MIN` `    ``let a=Number.MIN_SAFE_INTEGER;` `    ``let b=Number.MIN_SAFE_INTEGER;` `    ``let c=Number.MIN_SAFE_INTEGER; `   `    ``if` `(p <= l) ``// If Possible to make a cut of length p` `        ``a = func(l - p, p, q, r);`   `    ``if` `(q <= l) ``// If possible to make a cut of length q` `        ``b = func(l - q, p, q, r);`   `    ``if` `(r <= l) ``// If possible to make a cut of length r` `        ``c = func(l - r, p, q, r);`   `    ``return` `dp[l] = 1 + Math.max(Math.max(a, b),c); ``// Memoize & return` `}`   `function` `maximizeTheCuts(l, p, q, r)` `{` `    ``// Set Lookup table to -1` `    ``for` `(let i = 0; i < dp.length; i++)` `            ``dp[i] = -1;` `            `  `    ``let ans = func(l, p, q, r); ``// Utility function call`   `    ``if` `(ans < 0)` `        ``return` `0; ``// If returned answer is negative , that` `                ``// means cuts are not possible` `    ``return` `ans;` `}`   `// Driver code` `    ``let l = 11, p = 2, q = 3, r = 5;` `    ``console.log(maximizeTheCuts(l, p, q, r));` `    `  `// This code is contributed by Aman Kumar`

Output

`5`

Time Complexity: O(N) where n is the length of the rod or line segment that has to be cut
Auxiliary Space: O(N) where n is the length of the rod or line segment that has to be cut

## Maximize the number of segments of length p, q, and r using Dynamic Programming (DP):

As the solution for the 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)

Follow the below steps to solve the problem:

• Initialise an array DP[]={-1} and DP[0]=0.
• Run a loop from ‘1’ to ‘l’
• If DP[i]=-1 means it’s not possible to divide it using giving segments p,q,r so 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]

Pseudo-Code:

## C++

 `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])`

Below is the implementation of the above approach:

## C++

 `// C++ program to maximize the number` `// of segments of length p, q and r` `#include ` `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

 ``

Output

`5`

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, and 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 the 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 the minimum coin change problem is:

## C++

 `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
Related Articles