Given an array arr[] consisting of N positive integers representing the lengths of N ropes and a positive integer K, the task is to find the maximum length of the rope that has a frequency of at least K by cutting any ropes in any number of pieces.
Examples:
Input: arr[] = {5, 2, 7, 4, 9}, K = 5
Output: 4
Explanation:
Below are the possible cutting of the ropes:
- arr[0](= 5) is cutted into {4, 1}.
- arr[2](= 7) is cutted into {4, 3}.
- arr[4](= 9) is cutted into {4, 4, 1}.
After the above combinations of cuts, the maximum length is 4, which is of frequency at least(K = 5).
Input: arr[] = {1, 2, 3, 4, 9}, K = 6
Output: 2
Approach: The given problem can be solved by using the Binary Search. Follow the steps below to solve the problem:
- Initialize 3 variables, say low as 1, high as the maximum value of array arr[], and ans as -1, to store the left boundary right boundary for the binary search and to store the maximum possible length of K ropes.
- Iterate until low is less than or equal to high and perform the following steps:
- Find the mid-value of the range [low, high] and store it in a variable say mid.
- Traverse the array arr[] and find the count of ropes of length mid that can be obtained by cutting the ropes and store it in a variable say, count.
- If the value of count is at least K, then update the value of mid as ans and update the value of low as (mid + 1).
- Otherwise, update the value of high as (mid – 1).
- After completing the steps, print the value of ans as the result.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maximumSize(int a[], int k, int n)
{
int low = 1;
int high = *max_element(a, a + n);
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
int count = 0;
for (int c = 0; c < n; c++) {
count += a / mid;
}
if (count >= k) {
ans = mid;
low = mid + 1;
}
else {
high = mid - 1;
}
}
return ans;
}
int main()
{
int arr[] = { 1, 2, 3, 4, 9 };
int K = 6;
int n = sizeof(arr) / sizeof(arr[0]);
cout << (maximumSize(arr, K, n));
}
|
Java
import java.util.*;
class GFG {
static int maximumSize(Integer[] a,
int k)
{
int low = 1;
int high = Collections.max(
Arrays.asList(a));
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
int count = 0;
for (int c = 0;
c < a.length; c++) {
count += a / mid;
}
if (count >= k) {
ans = mid;
low = mid + 1;
}
else {
high = mid - 1;
}
}
return ans;
}
public static void main(String[] args)
{
Integer[] arr = { 1, 2, 3, 4, 9 };
int K = 6;
System.out.println(
maximumSize(arr, K));
}
}
|
Python3
def maximumSize(a, k):
low = 1
high = max(a)
ans = -1
while (low <= high):
mid = low + (high - low) // 2
count = 0
for c in range(len(a)):
count += a // mid
if (count >= k):
ans = mid
low = mid + 1
else:
high = mid - 1
return ans
if __name__ == '__main__':
arr = [1, 2, 3, 4, 9]
K = 6
print(maximumSize(arr, K))
|
C#
using System;
using System.Linq;
class GFG{
static int maximumSize(int[] a, int k)
{
int low = 1;
int high = a.Max();
int ans = -1;
while (low <= high)
{
int mid = low + (high - low) / 2;
int count = 0;
for(int c = 0;
c < a.Length; c++)
{
count += a / mid;
}
if (count >= k)
{
ans = mid;
low = mid + 1;
}
else
{
high = mid - 1;
}
}
return ans;
}
public static void Main(String[] args)
{
int[] arr = { 1, 2, 3, 4, 9 };
int K = 6;
Console.WriteLine(
maximumSize(arr, K));
}
}
|
Javascript
<script>
function maximumSize( a, k) {
let low = 1;
let high = Math.max.apply(Math, a);
let ans = -1;
while (low <= high) {
let mid = Math.floor(low + (high - low) / 2);
let count = 0;
for (let c = 0;
c < a.length; c++) {
count += Math.floor(a / mid);
}
if (count >= k) {
ans = mid;
low = mid + 1;
}
else {
high = mid - 1;
}
}
return ans;
}
let arr = [ 1, 2, 3, 4, 9 ];
let K = 6;
document.write(maximumSize(arr, K))
</script>
|
Time Complexity: O(N * log N)
Auxiliary Space: O(1)