Related Articles
Cut all the rods with some length such that the sum of cut-off length is maximized
• Difficulty Level : Medium
• Last Updated : 12 Oct, 2018

Given N rods of different lengths. The task is to cut all the rods with some maximum integer height ‘h’ such that sum of cut-off lengths of the rod is maximized and must be greater than M. Print -1 if no such cut is possible.

Note: A rod cannot be cut also.

Examples:

Input: N = 7, M = 8, a[] = {1, 2, 3, 5, 4, 7, 6}
Output: 3
Rod 1 and 2 are untouched, and rod 3, 4, 5, 6, 7 are cut with the cut-off lengths being (3-3) + (4-3) + (5-3) + (7-3) + (6-3) which is equal to 10 which is greater than M = 8.

Input: N = 4, M = 2, a[] = {1, 2, 3, 3}
Output: 2

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• Sort the array in ascending order
• Run a binary search with values low=0 and high=length[n-1], such that mid=(low+high)/2.
• Run a loop from n-1 till 0 adding the height of the rod cut-off to the sum.
• If the sum is greater than or equal to m, assign low with mid+1 otherwise high will be updated with mid.
• After Binary search is completed the answer will be low-1.

Below is the implementation of the above approach:

## C++

 `// C++ program to find the maximum possible ` `// length of rod which will be cut such that ` `// sum of cut off lengths will be maximum ` `#include ` `using` `namespace` `std; ` ` `  `// Function to run Binary Search to ` `// find maximum cut off length ` `int` `binarySearch(``int` `adj[], ``int` `target, ``int` `length) ` `{ ` ` `  `    ``int` `low = 0; ` `    ``int` `high = adj[length - 1]; ` `    ``while` `(low < high) { ` ` `  `        ``// f is the flag varibale ` `        ``// sum is for the total length cutoff ` `        ``int` `f = 0, sum = 0; ` ` `  `        ``int` `mid = low + (high - low) / 2; ` ` `  `        ``// Loop from higer to lower ` `        ``// for optimization ` `        ``for` `(``int` `i = length - 1; i >= 0; i--) { ` ` `  `            ``// Only if length is greater ` `            ``// than cut-off length ` `            ``if` `(adj[i] > mid) { ` `                ``sum = sum + adj[i] - mid; ` `            ``} ` ` `  `            ``// When total cut off length becomes greater ` `            ``// than desired cut off length ` `            ``if` `(sum >= target) { ` `                ``f = 1; ` `                ``low = mid + 1; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If flag variable is not set ` `        ``// Change high ` `        ``if` `(f == 0) ` `            ``high = mid; ` `    ``} ` ` `  `    ``// returning the maximum cut off length ` `    ``return` `low - 1; ` `} ` ` `  `// Driver Function ` `int` `main() ` `{ ` `    ``int` `n1 = 7; ` `    ``int` `n2 = 8; ` ` `  `    ``int` `adj[] = { 1, 2, 3, 4, 5, 7, 6 }; ` ` `  `    ``// Sorting the array in ascending order ` `    ``sort(adj, adj + n1); ` ` `  `    ``// Calling the binarySearch Function ` `    ``cout << binarySearch(adj, n2, n1); ` `} `

## Java

 `// Java program to find the  ` `// maximum possible length  ` `// of rod which will be cut  ` `// such that sum of cut off  ` `// lengths will be maximum ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `// Function to run Binary  ` `// Search to find maximum  ` `// cut off length ` `static` `int` `binarySearch(``int` `adj[],  ` `                        ``int` `target, ` `                        ``int` `length) ` `{ ` `int` `low = ``0``; ` `int` `high = adj[length - ``1``]; ` `while` `(low < high)  ` `{ ` ` `  `    ``// f is the flag varibale ` `    ``// sum is for the total ` `    ``// length cutoff ` `    ``int` `f = ``0``, sum = ``0``; ` ` `  `    ``int` `mid = low + (high - low) / ``2``; ` ` `  `    ``// Loop from higer to lower ` `    ``// for optimization ` `    ``for` `(``int` `i = length - ``1``;  ` `            ``i >= ``0``; i--)  ` `    ``{ ` ` `  `        ``// Only if length is greater ` `        ``// than cut-off length ` `        ``if` `(adj[i] > mid)  ` `        ``{ ` `            ``sum = sum + adj[i] - mid; ` `        ``} ` ` `  `        ``// When total cut off length  ` `        ``// becomes greater than ` `        ``// desired cut off length ` `        ``if` `(sum >= target)  ` `        ``{ ` `            ``f = ``1``; ` `            ``low = mid + ``1``; ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``// If flag variable is  ` `    ``// not set Change high ` `    ``if` `(f == ``0``) ` `        ``high = mid; ` `} ` ` `  `// returning the maximum  ` `// cut off length ` `return` `low - ``1``; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `n1 = ``7``; ` `    ``int` `n2 = ``8``; ` ` `  `    ``int` `adj[] = { ``1``, ``2``, ``3``, ``4``, ``5``, ``7``, ``6` `}; ` ` `  `    ``// Sorting the array  ` `    ``// in ascending order ` `    ``Arrays.sort(adj); ` ` `  `    ``// Calling the binarySearch Function ` `    ``System.out.println(binarySearch(adj, n2, n1)); ` `} ` `} ` ` `  `// This code is contributed ` `// by Arnab Kundu `

## Python3

 `# Python 3 program to find the  ` `# maximum possible length of  ` `# rod which will be cut such  ` `# that sum of cut off lengths  ` `# will be maximum ` ` `  `# Function to run Binary Search  ` `# to find maximum cut off length  ` `def` `binarySearch(adj, target, length) : ` `    ``low ``=` `0` `    ``high ``=` `adj[length ``-` `1``] ` `     `  `    ``while` `(low < high) : ` ` `  `        ``# f is the flag varibale  ` `        ``# sum is for the total  ` `        ``# length cutoff ` ` `  `        ``# multiple assignments ` `        ``f, ``sum` `=` `0``, ``0` ` `  `        ``# take integer value  ` `        ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2``; ` ` `  `        ``# Loop from higer to lower  ` `        ``# for optimization  ` `        ``for` `i ``in` `range``(length ``-` `1``, ``-``1` `, ``-``1``) : ` `             `  `            ``# Only if length is greater  ` `            ``# than cut-off length  ` `            ``if` `adj[i] > mid : ` `                ``sum` `=` `sum` `+` `adj[i] ``-` `mid ` `                 `  `            ``# When total cut off length  ` `            ``# becomes greater than  ` `            ``# desired cut off length ` `            ``if` `sum` `>``=` `target : ` `                ``f ``=` `1` `                ``low ``=` `mid ``+` `1` `                ``break` ` `  `        ``# If flag variable is  ` `        ``# not set. Change high  ` `        ``if` `f ``=``=` `0` `: ` `            ``high ``=` `mid ` ` `  `    ``# returning the maximum  ` `    ``# cut off length  ` `    ``return` `low ``-` `1` ` `  `# Driver code ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``n1 ``=` `7` `    ``n2 ``=` `8` ` `  `    ``# adj = [1,2,3,3] ` `    ``adj ``=` `[ ``1``, ``2``, ``3``, ``4``, ``5``, ``7``, ``6``] ` ` `  `    ``# Sorting the array  ` `    ``# in ascending order ` `    ``adj.sort() ` ` `  `    ``# Calling the binarySearch Function  ` `    ``print``(binarySearch(adj, n2, n1)) ` ` `  `# This code is contributed ` `# by ANKITRAI1 `

## C#

 `// C# program to find the  ` `// maximum possible length  ` `// of rod which will be cut  ` `// such that sum of cut off  ` `// lengths will be maximum ` `using` `System; ` ` `  `class` `GFG ` `{ ` `// Function to run Binary  ` `// Search to find maximum  ` `// cut off length ` `static` `int` `binarySearch(``int` `[]adj,  ` `                        ``int` `target, ` `                        ``int` `length) ` `{ ` `int` `low = 0; ` `int` `high = adj[length - 1]; ` `while` `(low < high)  ` `{ ` ` `  `    ``// f is the flag varibale ` `    ``// sum is for the total ` `    ``// length cutoff ` `    ``int` `f = 0, sum = 0; ` ` `  `    ``int` `mid = low + (high - low) / 2; ` ` `  `    ``// Loop from higer to lower ` `    ``// for optimization ` `    ``for` `(``int` `i = length - 1;  ` `            ``i >= 0; i--)  ` `    ``{ ` ` `  `        ``// Only if length is greater ` `        ``// than cut-off length ` `        ``if` `(adj[i] > mid)  ` `        ``{ ` `            ``sum = sum + adj[i] - mid; ` `        ``} ` ` `  `        ``// When total cut off length  ` `        ``// becomes greater than ` `        ``// desired cut off length ` `        ``if` `(sum >= target)  ` `        ``{ ` `            ``f = 1; ` `            ``low = mid + 1; ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``// If flag variable is  ` `    ``// not set Change high ` `    ``if` `(f == 0) ` `        ``high = mid; ` `} ` ` `  `// returning the maximum  ` `// cut off length ` `return` `low - 1; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `n1 = 7; ` `    ``int` `n2 = 8; ` ` `  `    ``int` `[]adj = {1, 2, 3, 4, 5, 7, 6}; ` ` `  `    ``// Sorting the array  ` `    ``// in ascending order ` `    ``Array.Sort(adj); ` ` `  `    ``// Calling the binarySearch Function ` `    ``Console.WriteLine(binarySearch(adj, n2, n1)); ` `} ` `} ` ` `  `// This code is contributed ` `// by Subhadeep Gupta `

## PHP

 `= 0; ``\$i``--)  ` `        ``{ ` ` `  `            ``// Only if length is greater ` `            ``// than cut-off length ` `            ``if` `(``\$adj``[``\$i``] > ``\$mid``)  ` `            ``{ ` `                ``\$sum` `= ``\$sum` `+ ``\$adj``[``\$i``] - ``\$mid``; ` `            ``} ` ` `  `            ``// When total cut off length becomes  ` `            ``// greater than desired cut off length ` `            ``if` `(``\$sum` `>= ``\$target``)  ` `            ``{ ` `                ``\$f` `= 1; ` `                ``\$low` `= ``\$mid` `+ 1; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If flag variable is not ` `        ``// set Change high ` `        ``if` `(``\$f` `== 0) ` `            ``\$high` `= ``\$mid``; ` `    ``} ` ` `  `    ``// returning the maximum cut off length ` `    ``return` `\$low` `- 1; ` `} ` ` `  `// Driver Code ` `\$n1` `= 7; ` `\$n2` `= 8; ` ` `  `\$adj` `= ``array``( 1, 2, 3, 4, 5, 7, 6 ); ` ` `  `// Sorting the array in ascending order ` `sort(``\$adj``); ` ` `  `// Calling the binarySearch Function ` `echo` `(int)binarySearch(``\$adj``, ``\$n2``, ``\$n1``); ` ` `  `// This code is contributed by ChitraNayal ` `?> `

Output:

```3
```

Time Complexity:
O(N * log N)
Auxiliary Space: O(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 :