Open in App
Not now

# Minimize the max of Array by doing at most K increment and decrement

• Last Updated : 09 Dec, 2022

Given a positive array arr[] of size N (2 â‰¤ N â‰¤ 105) and a positive integer K, the task is to minimize the maximum value of arr[] by performing at most K operations where in each operation, you can select any two distinct integers i and j (0 â‰¤ i, j < N), then increase the value of arr[i] by 1 and decrease the value of arr[j] by 1.

Example:

Input: arr = {3, 3, 7, 1, 6}, k = 2
Output: 6
Explanation:
One set of optimal operations is as follows:
For K = 1 => Select i = 2 and j = 0  and arr becomes {4, 3, 6, 1, 6}.
For K = 2 => Select i = 4 and j = 3, and arr becomes {4, 3, 6, 2, 5}.
The maximum integer of nums is . It can be shown that the maximum number cannot be less than 6.
Therefore, we return 6.

Input: nums = {10, 1, 1}, k = 3
Output: 7

Approach: The problem can be solved using binary search based on the following idea.

Choose the minimum and maximum possible value in start and end variable respectively. Find the mid value of start and end. Check if we can choose mid as the maximum possible value in array. If its true then this is one of our valid answer. So update our answer in result and shift the start to mid – 1 to minimise the maximum possible value. Otherwise shift the end to mid + 1. Finally return the result.

Follow the steps below to implement the above idea:

• Initialise a variable start = 0, end = max value in arr[] and result
• While start is less than equal to end, do the following
• Calculate the mid by (start + end) / 2
• Check if mid can be a valid max Value by the following
• Initialize a variable operationCount = 0
• Iterate over the array arr[]
• Check if arr[i] is greater than our expected maximum is mid
• operationCount += mid – arr[i]
• Check if operationsCount is greater than K.
•  If true, return false
• Return true
• If mid is the valid maximum possible value then,
• Shift end to mid – 1
• store mid into result
• Otherwise, shift the start to mid + 1
• Return the result

Below is the implementation of the above approach.

## C++

 `#include ` `using` `namespace` `std;`   `// Function to check if maxx can be a valid value` `bool` `isValid(``int` `maxx, vector<``int``>& arr, ``int` `k)` `{` `    ``// Initialize a variable sum = 0` `    ``long` `long` `operationCount = 0;`   `    ``// Iterate over the array arr[]` `    ``for` `(``long` `long` `i = 0; i < arr.size(); i++) {`   `        ``// Keep storing the maximum value in sum` `        ``if` `(arr[i] > maxx)` `            ``operationCount += arr[i] - maxx;`   `        ``// Check if number of operation required to` `        ``// make maximum element at max maxx.` `        ``// If true, return false` `        ``if` `(operationCount > k)` `            ``return` `false``;` `    ``}`   `    ``// Return true` `    ``return` `true``;` `}`   `// Function to find the minimum possible maximum` `int` `minimizeArrayMaxValue(vector<``int``>& arr, ``int` `k)` `{` `    ``long` `long` `n = arr.size();`   `    ``// Initialise a variable start = 0,` `    ``// end = max value in, arr[] and result` `    ``long` `long` `start = *min_element(arr.begin(), arr.end()),` `              ``end = *max_element(arr.begin(), arr.end());`   `    ``long` `long` `result;`   `    ``// Do while start is less than equals to end` `    ``while` `(start <= end) {`   `        ``// Calculate the mid by (start + end) / 2;` `        ``long` `long` `mid = (start + end) / 2;`   `        ``// Check if mid can be a valid max Value.` `        ``if` `(isValid(mid, arr, k)) {`   `            ``// Shift end to mid - 1` `            ``end = mid - 1;`   `            ``// Store mid into result` `            ``result = mid;` `          ``cout< arr = { 3, 3, 7, 1, 6 };` `    ``int` `K = 3;`   `    ``// Function call` `    ``cout << minimizeArrayMaxValue(arr, K);`   `    ``return` `0;` `}`

## Java

 `// java implementation` `import` `java.io.*;` `import` `java.util.ArrayList;` `import` `java.util.Collections;`   `class` `GFG ` `{`   `  ``// Function to check if maxx can be a valid value` `  ``public` `static` `boolean` `    ``isValid(``int` `maxx, ArrayList arr, ``int` `k)` `  ``{`   `    ``// Initialize a variable sum = 0` `    ``int` `operationCount = ``0``;`   `    ``// Iterate over the array arr[]` `    ``for` `(``int` `i = ``0``; i < arr.size(); i++) {`   `      ``// Keep storing the maximum value in sum` `      ``if` `(arr.get(i) > maxx)` `        ``operationCount += arr.get(i) - maxx;`   `      ``// Check if number of operation required to` `      ``// make maximum element at max maxx.` `      ``// If true, return false` `      ``if` `(operationCount > k)` `        ``return` `false``;` `    ``}`   `    ``// Return true` `    ``return` `true``;` `  ``}`   `  ``// Function to find the minimum possible maximum` `  ``public` `static` `int` `    ``minimizeArrayMaxValue(ArrayList arr, ``int` `k)` `  ``{` `    ``int` `n = arr.size();`   `    ``// Initialise a variable start = 0,` `    ``// end = max value in, arr[] and result` `    ``int` `start = Collections.min(arr);` `    ``int` `end = Collections.max(arr);`   `    ``int` `result = ``0``;`   `    ``// Do while start is less than equals to end` `    ``while` `(start <= end) {`   `      ``// Calculate the mid by (start + end) / 2;` `      ``int` `mid = (``int``)((start + end) / ``2``);`   `      ``// Check if mid can be a valid max Value.` `      ``if` `(isValid(mid, arr, k)) {`   `        ``// Shift end to mid - 1` `        ``end = mid - ``1``;`   `        ``// Store mid into result` `        ``result = mid;` `      ``}`   `      ``// Otherwise, shift start to mid + 1` `      ``else` `{` `        ``start = mid + ``1``;` `      ``}` `    ``}`   `    ``// Return the result` `    ``return` `result;` `  ``}`   `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `n = ``5``;` `    ``ArrayList arr = ``new` `ArrayList(n);`   `    ``arr.add(``3``);` `    ``arr.add(``3``);` `    ``arr.add(``7``);` `    ``arr.add(``1``);` `    ``arr.add(``6``);`   `    ``int` `K = ``3``;`   `    ``// Function call` `    ``System.out.println(minimizeArrayMaxValue(arr, K));` `  ``}` `}` `// This code is contributed by ksam24000`

## Python3

 `# Function to check if maxx can be a valid value` `def` `isValid(maxx, arr, k):` `    ``# Initialize a variable sum = 0` `    ``operationCount ``=` `0`   `    ``# Iterate over the array arr[]` `    ``for` `i ``in` `range``(``len``(arr)):`   `        ``# Keep storing the maximum value in sum` `        ``if` `arr[i] > maxx:` `            ``operationCount ``+``=` `arr[i] ``-` `maxx`   `        ``# Check if number of operation required to` `        ``# make maximum element at max maxx.` `        ``# If true, return false` `        ``if` `operationCount > k:` `            ``return` `False`   `    ``# Return true` `    ``return` `True`   `# Function to find the minimum possible maximum` `def` `minimizeArrayMaxValue(arr, k):`   `    ``# Initialise a variable start = 0,` `    ``# end = max value in, arr[] and result` `    ``start ``=` `min``(arr)` `    ``end ``=` `max``(arr)`   `    ``result ``=` `0`   `    ``# Do while start is less than equals to end` `    ``while` `start <``=` `end:` `        ``# Calculate the mid by (start + end) / 2` `        ``mid ``=` `(start ``+` `end) ``/``/` `2`   `        ``# Check if mid can be a valid max Value.` `        ``if` `isValid(mid, arr, k):` `            ``# Shift end to mid - 1` `            ``end ``=` `mid ``-` `1`   `            ``# Store mid into result` `            ``result ``=` `mid`   `        ``# Otherwise, shift start to mid + 1` `        ``else``:` `            ``start ``=` `mid ``+` `1`   `    ``# Return the result` `    ``return` `result`     `# Driver code` `arr ``=` `[``3``, ``3``, ``7``, ``1``, ``6``]` `K ``=` `3`   `# Function call` `print``(minimizeArrayMaxValue(arr, K))`   `# This code is contributed by Tapesh(tapeshdua420)`

## C#

 `// Include namespace system` `using` `System;` `using` `System.Linq;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{` `  `  `  ``// Function to check if maxx can be a valid value` `  ``public` `static` `bool` `isValid(``int` `maxx, ``int``[] arr, ``int` `k)` `  ``{` `    `  `    ``// Initialize a variable sum = 0` `    ``var` `operationCount = 0;` `    `  `    ``// Iterate over the array arr[]` `    ``for` `(``int` `i = 0; i < arr.Length; i++)` `    ``{` `      `  `      ``// Keep storing the maximum value in sum` `      ``if` `(arr[i] > maxx)` `      ``{` `        ``operationCount += arr[i] - maxx;` `      ``}` `      `  `      ``// Check if number of operation required to` `      ``// make maximum element at max maxx.` `      ``// If true, return false` `      ``if` `(operationCount > k)` `      ``{` `        ``return` `false``;` `      ``}` `    ``}` `    `  `    ``// Return true` `    ``return` `true``;` `  ``}` `  `  `  ``// Function to find the minimum possible maximum` `  ``public` `static` `int` `minimizeArrayMaxValue(``int``[] arr, ``int` `k)` `  ``{` `    ``var` `n = arr.Length;` `    `  `    ``// Initialise a variable start = 0,` `    ``// end = max value in, arr[] and result` `    ``var` `start = arr.Min();` `    ``var` `end = arr.Max();` `    ``var` `result = 0;` `    `  `    ``// Do while start is less than equals to end` `    ``while` `(start <= end)` `    ``{` `      `  `      ``// Calculate the mid by (start + end) / 2;` `      ``var` `mid = (``int``)((``int``)((start + end) / 2));` `      `  `      ``// Check if mid can be a valid max Value.` `      ``if` `(GFG.isValid(mid, arr, k))` `      ``{` `        `  `        ``// Shift end to mid - 1` `        ``end = mid - 1;` `        `  `        ``// Store mid into result` `        ``result = mid;` `      ``}` `      ``else` `      ``{` `        ``start = mid + 1;` `      ``}` `    ``}` `    `  `    ``// Return the result` `    ``return` `result;` `  ``}` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``var` `arr = ``new` `int``[]{3,3,7,1,6};`   `    ``var` `K = 3;` `    `  `    ``// Function call` `    ``Console.WriteLine(GFG.minimizeArrayMaxValue(arr, K));` `  ``}` `}`   `// This code is contributed by aadityaburujwale.`

## Javascript

 `// Include namespace system` `// JS implementation` `  ``// Function to check if maxx can be a valid value` `function` `isValid(maxx, arr, k)` `  ``{` `    `  `    ``// Initialize a variable sum = 0` `    ``let operationCount = 0;` `    `  `    ``// Iterate over the array arr[]` `    ``for` `(let i = 0; i < arr.length; i++)` `    ``{` `      `  `      ``// Keep storing the maximum value in sum` `      ``if` `(arr[i] > maxx)` `      ``{` `        ``operationCount += arr[i] - maxx;` `      ``}` `      `  `      ``// Check if number of operation required to` `      ``// make maximum element at max maxx.` `      ``// If true, return false` `      ``if` `(operationCount > k)` `      ``{` `        ``return` `false``;` `      ``}` `    ``}` `    `  `    ``// Return true` `    ``return` `true``;` `  ``}` `  `  `  ``// Function to find the minimum possible maximum` ` ``function` `minimizeArrayMaxValue(arr,k)` `  ``{` `    ``let n = arr.length;` `    `  `    ``// Initialise a variable start = 0,` `    ``// end = max value in, arr[] and result` `    ``let start = Math.min.apply(Math, arr);` `    ``let end = Math.max.apply(Math, arr);` `    ``let result = 0;` `    `  `    ``// Do while start is less than equals to end` `    ``while` `(start <= end)` `    ``{` `      `  `      ``// Calculate the mid by (start + end) / 2;` `      ``let mid = Math.floor((start + end) / 2);` `      `  `      ``// Check if mid can be a valid max Value.` `      ``if` `(isValid(mid, arr, k))` `      ``{` `        `  `        ``// Shift end to mid - 1` `        ``end = mid - 1;` `        `  `        ``// Store mid into result` `        ``result = mid;` `      ``}` `      ``else` `      ``{` `        ``start = mid + 1;` `      ``}` `    ``}` `    `  `    ``// Return the result` `    ``return` `result;` `  ``}` `  `  `    ``let arr = [3,3,7,1,6];`   `    ``let K = 3;` `    `  `    ``// Function call` `    ``console.log(minimizeArrayMaxValue(arr, K));` ` `    `// This code is contributed by ksam24000`

Output

`5`

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

Related Articles:

My Personal Notes arrow_drop_up
Related Articles