# Decrease the max of Array by breaking array parts at most Ok occasions

Given an integer array arr[] of measurement N and a constructive integer Ok, the duty is to attenuate the utmost of the array by changing any ingredient arr[i] into two constructive parts (X, Y) at most Ok occasions such that arr[i] = X + Y.

Examples:

Enter: arr = {9}, Ok = 2
Output: 3
Clarification: Operation 1: Exchange ingredient 9 into {6, 3} then array turns into {6, 3}.
Operation 2: Exchange ingredient 6 into {3, 3} then array turns into {3, 3, 3}.
So, the utmost ingredient in arr[] after acting at most Ok operations are 3.

Enter: arr = {2, 4, 8, 2}, Ok = 4
Output: 2

The issue might be solved utilizing binary search primarily based on the next thought:

Initilze begin with minimal attainable reply and finish with most attainable reply, then calculate the edge worth mid = (begin + finish) /2 and examine whether it is attainable to make each ingredient lower than or equals to mid in at most Ok operations. Whether it is attainable, replace the consequence and shift finish of vary to mid – 1. In any other case, shift begin of vary to mid + 1.

Comply with the steps under to implement the above thought:

• Initialize a variable begin = 1 and finish = most attainable reply.
• Initialize a variable consequence that can retailer the reply
• Whereas begin ≤ finish
• Calculate mid = (begin + finish) / 2
• Calculate the utmost variety of operations required to make each ingredient lower than or equal to mid.
• Iterate over the given array
• Test if the present ingredient is bigger than mid
• If true, then calculate the operation required to make this ingredient lower than or equals to mid
• Test if the overall operation required to make each ingredient lower than or equal to mid is bigger lower than equal to Ok
• If true, replace the consequence and transfer the finish to mid – 1
• In any other case, transfer the begin to mid + 1.
• Return the consequence.

Beneath is the implementation of the above strategy.

## C++

 ` `  `#embody ` `utilizing` `namespace` `std;` ` `  `int` `minimizeMaxElement(vector<``int``>& arr, ``int` `Ok)` `{` `    ` `    ` `    ``int` `begin = 1,` `        ``finish = *max_element(arr.start(), arr.finish());` ` `  `    ` `    ` `    ``int` `consequence = -1;` ` `  `    ` `    ``whereas` `(begin <= finish) {` ` `  `        ` `        ``int` `mid = (begin + finish) >> 1;` ` `  `        ` `        ` `        ` `        ` `        ``int` `operation = 0;` ` `  `        ` `        ``for` `(``int` `i = 0; i < arr.measurement(); i++) {` ` `  `            ` `            ` `            ` `            ` `            ` `            ``if` `(arr[i] > mid) {` `                ``operation += ``ceil``((``double``)arr[i] / mid) - 1;` `            ``}` `        ``}` ` `  `        ` `        ` `        ` `        ` `        ` `        ` `        ``if` `(operation <= Ok) {` `            ``consequence = mid;` `            ``finish = mid - 1;` `        ``}` `        ``else` `{` `            ``begin = mid + 1;` `        ``}` `    ``}` ` `  `    ` `    ``return` `consequence;` `}` ` `  `int` `primary()` `{` ` `  `    ``vector<``int``> arr = { 2, 4, 8, 2 };` `    ``int` `Ok = 4;` ` `  `    ` `    ``cout << minimizeMaxElement(arr, Ok);` ` `  `    ``return` `0;` `}`

Time Complexity: O(log2(max(arr)) * N), the place max(arr) is the utmost ingredient and N is the dimensions of the given array.
Auxiliary House: O(1)