# Maximize Kth largest element after splitting the given Array at most C times

• Difficulty Level : Hard
• Last Updated : 01 Nov, 2021

Given an array arr[] and two positive integers K and C, the task is to maximize the Kth maximum element obtained after splitting an array element arr[] into two parts(not necessarily an integer) C number of times. Print -1 if there doesn’t exist Kth maximum element.

Note: It is compulsory to do splitting operation until the size of the array arr[] is â‰¥ K.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:

Input: arr[] = {5, 8}, K = 1, C = 1
Output: 8.0
Explanation: There is no need to perform any operations. The finally array will be {8, 5} Hence 8.0 is the maximum achievable value.

Input: arr[] = {5, 9}, K = 3, C = 1
Output: 4.5
Explanation: The value 9 can be splitted as 4.5 and 4.5. The final array will be {5, 4.5, 4.5} where the 3rd value is 4.5 which is maximum achievable.

Approach: The given problem can be solved by using Binary Search on the answer. Follow the steps below to solve the given problem.

• Initialize two variables, say low and high as 0 and 109 respectively that represents the range where Binary Search can be performed.
• Perform the Binary Search using the following steps:
• Find the value of mid as (low + high)*0.5.
• Traverse the given array arr[] and store the count of elements which is at least the value of mid in the variable, say A and also find the number of operations performed in the variable, say B.
• If the value of (A â‰¥ K) and (B + C â‰¥ K) then update the value of low as mid. Otherwise, update the value of high as mid.
• After completing the above steps, the value stored in the variable low is the resultant maximized Kth maximum element.

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach #include using namespace std; // Function to find the K-th maximum// element after upto C operationsdouble maxKth(int arr[], int N,              int C, int K){    // Check for the base case    if (N + C < K) {        return -1;    }    // Stores the count iterations of BS    int iter = 300;     // Create the left and right bounds    // of binary search    double l = 0, r = 1000000000.0;     // Perform binary search    while (iter--) {         // Find the value of mid        double mid = (l + r) * 0.5;        double a = 0;        double b = 0;         // Traverse the array        for (int i = 0; i < N; i++) {            a += int((double)arr[i] / mid);            if ((double)arr[i] >= mid) {                b++;            }        }         // Update the ranges        if (a >= K && b + C >= K) {            l = mid;        }        else {            r = mid;        }    }     // Return the maximum value obtained    return l;} // Driver Codeint main(){    int arr[] = { 5, 8 };    int K = 1, C = 1;    int N = sizeof(arr) / sizeof(arr[0]);     cout << maxKth(arr, N, C, K);     return 0;}

## Java

 // Java program for the above approachimport java.io.*; class GFG{     // Function to find the K-th maximum    // element after upto C operations    static double maxKth(int arr[], int N, int C, int K)    {               // Check for the base case        if (N + C < K) {            return -1;        }               // Stores the count iterations of BS        int iter = 300;         // Create the left and right bounds        // of binary search        double l = 0, r = 1000000000.0;         // Perform binary search        while (iter-- > 0) {             // Find the value of mid            double mid = (l + r) * 0.5;            double a = 0;            double b = 0;             // Traverse the array            for (int i = 0; i < N; i++) {                a += (int)((double)arr[i] / mid);                if ((double)arr[i] >= mid) {                    b++;                }            }             // Update the ranges            if (a >= K && b + C >= K) {                l = mid;            }            else {                r = mid;            }        }         // Return the maximum value obtained        return l;    }     // Driver Code    public static void main(String[] args)    {        int arr[] = { 5, 8 };        int K = 1, C = 1;        int N = arr.length;         System.out.println(maxKth(arr, N, C, K));    }} // This code is contributed by Dharanendra L V.

## Python3

 # Python Program to implement# the above approach # Function to find the K-th maximum# element after upto C operationsdef maxKth(arr, N, C, K):     # Check for the base case    if (N + C < K):        return -1         # Stores the count iterations of BS    iter = 300     # Create the left and right bounds    # of binary search    l = 0    r = 1000000000.0     # Perform binary search    while (iter):        iter = iter - 1        # Find the value of mid        mid = (l + r) * 0.5        a = 0        b = 0         # Traverse the array        for i in range(N) :            a += arr[i] // mid            if (arr[i] >= mid) :                b += 1                               # Update the ranges        if (a >= K and b + C >= K) :                l = mid                 else :                r = mid          # Return the maximum value obtained    return int(l)  # Driver Codearr = [5, 8]K = 1C = 1N = len(arr) print(maxKth(arr, N, C, K)) # This code is contributed by Saurabh Jaiswal

## C#

 // C# program for the above approachusing System; class GFG{     // Function to find the K-th maximum    // element after upto C operations    static double maxKth(int []arr, int N, int C, int K)    {               // Check for the base case        if (N + C < K) {            return -1;        }               // Stores the count iterations of BS        int iter = 300;         // Create the left and right bounds        // of binary search        double l = 0, r = 1000000000.0;         // Perform binary search        while (iter-- > 0) {             // Find the value of mid            double mid = (l + r) * 0.5;            double a = 0;            double b = 0;             // Traverse the array            for (int i = 0; i < N; i++) {                a += (int)((double)arr[i] / mid);                if ((double)arr[i] >= mid) {                    b++;                }            }             // Update the ranges            if (a >= K && b + C >= K) {                l = mid;            }            else {                r = mid;            }        }         // Return the maximum value obtained        return l;    }     // Driver Code    public static void Main(String[] args)    {        int []arr = { 5, 8 };        int K = 1, C = 1;        int N = arr.Length;         Console.Write(maxKth(arr, N, C, K));    }} // This code is contributed by shivanisinghss2110

## Javascript


Output:
8

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

My Personal Notes arrow_drop_up