# 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.

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
Recommended Articles
Page :