Maximize the minimum element and return it

Given an array A[] of size N along with W, K. We can increase W continuous elements by 1 where we are allowed to perform this operation K times, the task is to maximize the minimum element and return the minimum element after operations.

Examples:

Input: N = 6, K = 2, W = 3, A[] = {2, 2, 2, 2, 1, 1}
Output: 2
Explanation: Increase the last three elements for the first time &  first three elements for the second time. The new elements will be {3, 3, 3, 3, 2, 2}

Input: N = 2, K = 5, W = 1, A[] = {5, 8}
Output: 9
Explanation: Four times increase the first element then increase the last flower once.

Approach: This can be solved with the following idea:

The idea is to use a binary search between the minimum and maximum possible element and at every iteration of the binary search check if we can get the minimum of the element equal to the mid value of the binary search by increasing the element k times.

Steps involved in the implementation of code:

• Initially take the answer as 0 and do a binary search between the minimum and maximum possible height of the tree, i.e: l = 0 and h = 10^14.
• Run a loop while(l ≤ h) for binary searching.
  • Find mid = (l + h) / 2
  • Now check if this mid value is one of the possible values for our answer or not, if it is possible to get the minimum of the array to be equal to mid then update the answer as mid and l = mid + 1.
  • To check whether this mid value is valid or not we call another function isValid this function implementation is as follows:
  • Create an array ps which keeps track of which element is increased by how many values and initialize it with zero.
  • Now run a loop and check if the initial element  + increased element( a[i] + ps[i] ) is less than the mid then incr the i^th height with the required value so that its height is equal to mid, and along with that we also increase the value the next w elements as we can increase the value of w element in one time.
  • When coming out of the loop check if k is greater than or equal to we increased the value of the element true else return false
  • Else if this mid value is not a possible value then updates h = mid-1.
• Return answer. 

Below is the implementation of the above approach:

C++

// C++ code of the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to check whether the mid is
// smallest minimum of array
bool isvalid(vector<int>& a, int n, int k, int w,
             long long int mid)
{

    long long int ps[n];
    fill(ps, ps + n, 0ll);
    long long int ans = 0;

    for (long long int i = 0; i < n; i++) {

        if (i - 1 >= 0)
            ps[i] += ps[i - 1];

        if (a[i] + ps[i] < mid) {

            long long int e = mid - a[i] - ps[i];
            ans += e;
            ps[i] += e;
            if (i + w < n)
                ps[i + w] -= e;
        }
    }

    // If it is true
    return (ans <= k);
}

// Function to maximize the minimum height
long long int maximizeMinHeight(int n, int k, int w,
                                vector<int>& a)
{
    int ans = 0;
    long long int l = 0, h = 1e14;
    while (l <= h) {
        long long int mid = (l + h) / 2;

        // Check for mid
        if (isvalid(a, n, k, w, mid)) {
            l = mid + 1;
            ans = mid;
        }
        else {
            h = mid - 1;
        }
    }

    // Return the minimum height
    return ans;
}

// Driver code
int main()
{
    int N = 6, K = 2, W = 3;
    vector<int> a = { 2, 2, 2, 2, 1, 1 };

    // Function call
    int ans = maximizeMinHeight(N, K, W, a);
    cout << ans;

    return 0;
}

Java

import java.util.*;

public class Main {

    // Function to check whether the mid is
    // smallest minimum opf array
    public static boolean isvalid(int[] a, int n, int k,
                                  int w, long mid)
    {
        long[] ps = new long[n];
        Arrays.fill(ps, 0);
        long ans = 0;

        for (long i = 0; i < n; i++) {

            if (i - 1 >= 0)
                ps[(int)i] += ps[(int)i - 1];

            if (a[(int)i] + ps[(int)i] < mid) {

                long e = mid - a[(int)i] - ps[(int)i];
                ans += e;
                ps[(int)i] += e;
                if (i + w < n)
                    ps[(int)i + w] -= e;
            }
        }

        // If it is true
        return (ans <= k);
    }

    // Function to maximize the minimum height
    public static long maximizeMinHeight(int n, int k,
                                         int w, int[] a)
    {
        int ans = 0;
        long l = 0, h = (long)1e14;
        while (l <= h) {
            long mid = (l + h) / 2;

            // Check for mid
            if (isvalid(a, n, k, w, mid)) {
                l = mid + 1;
                ans = (int)mid;
            }
            else {
                h = mid - 1;
            }
        }

        // Return the minimum height
        return ans;
    }

    // Driver code
    public static void main(String[] args)
    {
        int N = 6, K = 2, W = 3;
        int[] a = { 2, 2, 2, 2, 1, 1 };

        // Function call
        long ans = maximizeMinHeight(N, K, W, a);
        System.out.println(ans);
    }
}

Python3

def isvalid(a, n, k, w, mid):
    """
    Function to check whether the mid is the smallest minimum of the array
    """
    ps = [0] * n
    ans = 0

    for i in range(n):
        if i - 1 >= 0:
            ps[i] += ps[i - 1]

        if a[i] + ps[i] < mid:
            e = mid - a[i] - ps[i]
            ans += e
            ps[i] += e
            if i + w < n:
                ps[i + w] -= e

    # If it is true
    return ans <= k


def maximizeMinHeight(n, k, w, a):
    """
    Function to maximize the minimum height
    """
    ans = 0
    l, h = 0, 10 ** 14
    while l <= h:
        mid = (l + h) // 2

        # Check for mid
        if isvalid(a, n, k, w, mid):
            l = mid + 1
            ans = mid
        else:
            h = mid - 1

    # Return the minimum height
    return ans


if __name__ == '__main__':
    N, K, W = 6, 2, 3
    a = [2, 2, 2, 2, 1, 1]

    # Function call
    ans = maximizeMinHeight(N, K, W, a)
    print(ans)

C#

// C# code of the above approach

using System;

public class GFG {
    // Function to check whether the mid is
    // smallest minimum opf array
    public static bool isvalid(int[] a, int n, int k, int w,
                               long mid)
    {

        long[] ps = new long[n];
        Array.Fill(ps, 0L);
        long ans = 0;

        for (long i = 0; i < n; i++) {

            if (i - 1 >= 0)
                ps[i] += ps[i - 1];

            if (a[i] + ps[i] < mid) {

                long e = mid - a[i] - ps[i];
                ans += e;
                ps[i] += e;
                if (i + w < n)
                    ps[i + w] -= e;
            }
        }

        // If it is true
        return (ans <= k);
    }

    // Function to maximize the minimum height
    public static long maximizeMinHeight(int n, int k,
                                         int w, int[] a)
    {
        long ans = 0;
        long l = 0, h = (long)1e14;
        while (l <= h) {
            long mid = ((l+ h) / 2);

            // Check for mid
            if (isvalid(a, n, k, w, mid)) {
                l = mid + 1;
                ans = mid;
            }
            else {
                h = mid - 1;
            }
        }

        // Return the minimum height
        return ans;
    }

    // Driver code
    public static void Main() {
        int N = 6, K = 2, W = 3;
        int[] a = { 2, 2, 2, 2, 1, 1 };

        // Function call
        long ans = maximizeMinHeight(N, K, W, a);
        Console.WriteLine(ans);
    }
}

Javascript

// Function to check whether the mid is
// smallest minimum of array
function isvalid(a, n, k, w, mid) {
let ps = new Array(n).fill(0);
let ans = 0;

for (let i = 0; i < n; i++) {
if (i - 1 >= 0) ps[i] += ps[i - 1];
if (a[i] + ps[i] < mid) {
  let e = mid - a[i] - ps[i];
  ans += e;
  ps[i] += e;
  if (i + w < n) ps[i + w] -= e;
}
}

// If it is true
return ans <= k;
}

// Function to maximize the minimum height
function maximizeMinHeight(n, k, w, a) {
let ans = 0;
let l = 0,
h = 1e14;
while (l <= h) {
let mid = Math.floor((l + h) / 2);
// Check for mid
if (isvalid(a, n, k, w, mid)) {
  l = mid + 1;
  ans = mid;
} else {
  h = mid - 1;
}
}

// Return the minimum height
return ans;
}

// Driver code
let N = 6,
K = 2,
W = 3;
let a = [2, 2, 2, 2, 1, 1];

// Function call
let ans = maximizeMinHeight(N, K, W, a);
console.log(ans);

Output

2

Time Complexity: O(N*LogN)
Auxiliary Space: O(N)