Find the maximum possible value of the minimum value of modified array

Given an array of size N and a number S. The task is to modify the given array such that:

  • The difference between the sum of the array elements before and after modification is exactly equal to S.
  • Modified array elements should be non-negative.
  • The minimum value in the modified array must be maximized.
  • To modify the given array, you can increment or decrement any element of the array.

The task is to find the minimum number of the modified array. If it is not possible then print -1. The minimum number should be as maximum as possible.

Examples:

Input : a[] = {2, 2, 3}, S = 1
Output : 2
Explanation : Modified array is {2, 2, 2}

Input : a[] = {1, 3, 5}, S = 10
Output : -1

An efficient approach is to make a binary search between the minimum and the maximum possible value of the minimum number in a modified array. The minimum possible value is zero and the maximum possible array is minimum number in a given array. If given array elements sum is less than S then answer is not possible. so, print -1. If given array elements sum equals to S then answer will be zero.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find the maximum possible
// value of the minimum value of
// modified array
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the maximum possible value
// of the minimum value of the modified array
int maxOfMin(int a[], int n, int S)
{
    // To store minimum value of array
    int mi = INT_MAX;
  
    // To store sum of elements of array
    int s1 = 0;
  
    for (int i = 0; i < n; i++) {
        s1 += a[i];
        mi = min(a[i], mi);
    }
  
    // Solution is not possible
    if (s1 < S)
        return -1;
  
    // zero is the possible value
    if (s1 == S)
        return 0;
  
    // minimum possible value
    int low = 0;
  
    // maximum possible value
    int high = mi;
  
    // to store a required answer
    int ans;
  
    // Binary Search
    while (low <= high) {
  
        int mid = (low + high) / 2;
  
        // If mid is possible then try to increase
        // required answer
        if (s1 - (mid * n) >= S) {
            ans = mid;
            low = mid + 1;
        }
  
        // If mid is not possible then decrease
        // required answer
        else
            high = mid - 1;
    }
  
    // Return required answer
    return ans;
}
  
// Driver Code
int main()
{
    int a[] = { 10, 10, 10, 10, 10 };
  
    int S = 10;
  
    int n = sizeof(a) / sizeof(a[0]);
  
    cout << maxOfMin(a, n, S);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java  program to find the maximum possible
// value of the minimum value of
// modified array
  
import java.io.*;
  
class GFG {
      
// Function to find the maximum possible value
// of the minimum value of the modified array
static int maxOfMin(int a[], int n, int S)
{
    // To store minimum value of array
    int mi = Integer.MAX_VALUE;
  
    // To store sum of elements of array
    int s1 = 0;
  
    for (int i = 0; i < n; i++) {
        s1 += a[i];
        mi = Math.min(a[i], mi);
    }
  
    // Solution is not possible
    if (s1 < S)
        return -1;
  
    // zero is the possible value
    if (s1 == S)
        return 0;
  
    // minimum possible value
    int low = 0;
  
    // maximum possible value
    int high = mi;
  
    // to store a required answer
    int ans=0;
  
    // Binary Search
    while (low <= high) {
  
        int mid = (low + high) / 2;
  
        // If mid is possible then try to increase
        // required answer
        if (s1 - (mid * n) >= S) {
            ans = mid;
            low = mid + 1;
        }
  
        // If mid is not possible then decrease
        // required answer
        else
            high = mid - 1;
    }
  
    // Return required answer
    return ans;
}
  
// Driver Code
    public static void main (String[] args) {
  
    int a[] = { 10, 10, 10, 10, 10 };
  
    int S = 10;
  
    int n = a.length;
  
    System.out.println( maxOfMin(a, n, S));
    }
//This code is contributed by ajit.    
}

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program to find the maximum possible
# value of the minimum value of
# modified array
  
  
# Function to find the maximum possible value
# of the minimum value of the modified array
def maxOfMin(a, n, S):
  
    # To store minimum value of array
    mi = 10**9
  
    # To store sum of elements of array
    s1 = 0
  
    for i in range(n):
        s1 += a[i]
        mi = min(a[i], mi)
      
  
    # Solution is not possible
    if (s1 < S):
        return -1
  
    # zero is the possible value
    if (s1 == S):
        return 0
  
    # minimum possible value
    low = 0
  
    # maximum possible value
    high = mi
  
    # to store a required answer
    ans=0
  
    # Binary Search
    while (low <= high):
  
        mid = (low + high) // 2
  
        # If mid is possible then try to increase
        # required answer
        if (s1 - (mid * n) >= S):
            ans = mid
            low = mid + 1
          
  
        # If mid is not possible then decrease
        # required answer
        else:
            high = mid - 1
      
  
    # Return required answer
    return ans
  
  
# Driver Code
  
a=[10, 10, 10, 10, 10
  
S = 10
  
n =len(a)
  
print(maxOfMin(a, n, S))
#This code is contributed by Mohit kumar 29

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find the maximum possible 
// value of the minimum value of 
// modified array 
  
using System;
  
class GFG { 
      
    // Function to find the maximum possible value 
    // of the minimum value of the modified array 
    static int maxOfMin(int []a, int n, int S) 
    
        // To store minimum value of array 
        int mi = int.MaxValue; 
      
        // To store sum of elements of array 
        int s1 = 0; 
      
        for (int i = 0; i < n; i++) { 
            s1 += a[i]; 
            mi = Math.Min(a[i], mi); 
        
      
        // Solution is not possible 
        if (s1 < S) 
            return -1; 
      
        // zero is the possible value 
        if (s1 == S) 
            return 0; 
      
        // minimum possible value 
        int low = 0; 
      
        // maximum possible value 
        int high = mi; 
      
        // to store a required answer 
        int ans=0; 
      
        // Binary Search 
        while (low <= high) { 
      
            int mid = (low + high) / 2; 
      
            // If mid is possible then try to increase 
            // required answer 
            if (s1 - (mid * n) >= S) { 
                ans = mid; 
                low = mid + 1; 
            
      
            // If mid is not possible then decrease 
            // required answer 
            else
                high = mid - 1; 
        
      
        // Return required answer 
        return ans; 
    
  
    // Driver Code 
    public static void Main () { 
  
    int []a = { 10, 10, 10, 10, 10 }; 
  
    int S = 10; 
  
    int n = a.Length; 
  
    Console.WriteLine(maxOfMin(a, n, S)); 
    
    //This code is contributed by Ryuga 

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to find the maximum possible
// value of the minimum value of modified array
  
// Function to find the maximum possible value
// of the minimum value of the modified array
function maxOfMin($a, $n, $S)
{
    // To store minimum value 
    // of array
    $mi = PHP_INT_MAX;
  
    // To store sum of elements
    // of array
    $s1 = 0;
  
    for ($i = 0; $i < $n; $i++) 
    {
        $s1 += $a[$i];
        $mi = min($a[$i], $mi);
    }
  
    // Solution is not possible
    if ($s1 < $S)
        return -1;
  
    // zero is the possible value
    if ($s1 == $S)
        return 0;
  
    // minimum possible value
    $low = 0;
  
    // maximum possible value
    $high = $mi;
  
    // to store a required answer
    $ans;
  
    // Binary Search
    while ($low <= $high
    {
  
        $mid = ($low + $high) / 2;
  
        // If mid is possible then try 
        // to increase required answer
        if ($s1 - ($mid * $n) >= $S
        {
            $ans = $mid;
            $low = $mid + 1;
        }
  
        // If mid is not possible then
        // decrease required answer
        else
            $high = $mid - 1;
    }
  
    // Return required answer
    return $ans;
}
  
// Driver Code
$a = array( 10, 10, 10, 10, 10 );
$S = 10;
$n = sizeof($a);
echo maxOfMin($a, $n, $S);
  
// This code is contributed by akt_mit
?>

chevron_right


Output:

8


My Personal Notes arrow_drop_up