Given an array arr[] of N elements and an integer **K, **the task is to perform at most K operation on the array. In the one operation increment any element by one of the array. Find maximize median after doing K such operation.

Example:

Input:_ arr[] = {1, 3, 4, 5}, K = 3_

_Output: _5

Explanation:_ Here we add two in the second element and one in the third element then we will get a maximum median. After k operation the array can become {1, 5, 5, 5}. So the maximum median we can make is ( 5 + 5 ) / 2 = 5, because here N is even._

_Input: _arr[]_ = _{1, 3, 6, 4, 2}, K = 10

_Output: _7

Approach:

1. Sort the array in increasing order.
2. Since the median is the middle element of the array doing the operation in the left half then it will be worthless because it will not increase the median.
3. Perform the operation in the second half and start performing the operations from the n/2th element to the end.
4. If N is even then start doing the operation from the n/2 element to the end.
5. Using Binary Search we will check for any number is possible as a median or not after doing K operation.
6. If the median is possible then we will check for the next number which is greater than the current median calculated. Otherwise, the last possible value of the median is the required result.

Below is the implementation of the above approach:

• C++

// C++ program for the above approach

#include <bits/stdc++.h>

**using** **namespace** std;

// Function to check operation can be

// perform or not

**bool** possible(``**int** arr[], **int** N,

**int** mid, **int** K)

{

**int** add = 0;

**for** (``**int** i = N / 2 - (N + 1) % 2;

i < N; ++i) {

**if** (mid - arr[i] > 0) {

// Number of operation to

// perform s.t. mid is median

add += (mid - arr[i]);

**if** (add > K)

**return** **false**``;

}

}

// If mid is median of the array

**if** (add <= K)

**return** **true**``;

**else**

**return** **false**``;

}

// Function to find max median

// of the array

**int** findMaxMedian(``**int** arr[], **int** N,

**int** K)

{

// Lowest possible median

**int** low = 1;

**int** mx = 0;

**for** (``**int** i = 0; i < N; ++i) {

mx = max(mx, arr[i]);

}

// Highest possible median

**long** **long** **int** high = K + mx;

**while** (low <= high) {

**int** mid = (high + low) / 2;

// Checking for mid is possible

// for the median of array after

// doing at most k operation

**if** (possible(arr, N, mid, K)) {

low = mid + 1;

}

**else** {

high = mid - 1;

}

}

**if** (N % 2 == 0) {

**if** (low - 1 < arr[N / 2]) {

**return** (arr[N / 2] + low - 1) / 2;

}

}

// Return the max possible ans

**return** low - 1;

}

// Driver Code

**int** main()

{

// Given array

**int** arr[] = { 1, 3, 6 };

// Given number of operation

**int** K = 10;

// Size of array

**int** N = **sizeof**``(arr) / **sizeof**``(arr[0]);

// Sort the array

sort(arr, arr + N);

// Function call

cout << findMaxMedian(arr, N, K);

**return** 0;

}

Output:

9

Time Complexity: O(N*log(K + M)), where M is the maximum element of the given array.

**Auxiliary Space: **O(1)

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.

#arrays #greedy #searching #sorting #binary search #median-finding