Cut all the rods with some length such that the sum of cut-off length is maximized

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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 <bits/stdc++.h>
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);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php 
// PHP 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
function 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
        $f = 0;
        $sum = 0;
  
        $mid = $low + ($high - $low) / 2;
  
        // Loop from higer to lower
        // for optimization
        for ($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
$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
?>

chevron_right


Output:

3


Time Complexity:
O(N * log N)
Auxiliary Space: O(1)



My Personal Notes arrow_drop_up

Coder only XD Do send reference if contacting me

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.