# 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 operations``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--) {` `        ``// 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``int` `main()``{``    ``int` `arr[] = { 5, 8 };``    ``int` `K = 1, C = 1;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << maxKth(arr, N, C, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `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 operations``def` `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 Code``arr ``=` `[``5``, ``8``]``K ``=` `1``C ``=` `1``N ``=` `len``(arr)` `print``(maxKth(arr, N, C, K))` `# This code is contributed by Saurabh Jaiswal`

## C#

 `// C# program for the above approach``using` `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