Skip to content
Related Articles

Related Articles

Improve Article

Maximize the smallest array element by incrementing all elements in a K-length subarray by 1 exactly M times

  • Difficulty Level : Medium
  • Last Updated : 13 Aug, 2021
Geek Week

Given an array arr[] of size N, and integers M and K, the task is to find the maximum possible value of the smallest array element by performing M operations. In each operation, increase the value of all elements in a contiguous subarray of length K by 1.

Examples:

Input: arr[ ] = {2, 2, 2, 2, 1, 1}, M = 1, K = 3
Output: 2
Explanation: Update the last 3 elements on the first move then updated array is [2, 2, 2, 3, 2, 2]. The smallest element has a value of 2.

Input: arr[ ] = {5, 8}, M = 5, K = 1
Output: 9

Approach: The problem can be solved by using Binary Search. Traverse the array arr[] and for every element arr[i], count the number of operations required. If the current element is required to be updated x times, then add x to the answer and update the consecutive segment of length K by x times.



Below is the implementation of the above approach:

C++




// C++ program for above approach
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll n, m, k, l, r, i;
 
// Function to check if the smallest
// value of v is achievable or not
ll check(ll v, vector<ll>& a)
{
    ll tec = 0, ans = 0;
 
    // Create array to
    // store previous moves
    vector<ll> b(n + k + 1);
 
    for (i = 0; i < n; i++) {
 
        // Remove previous moves
        tec -= b[i];
 
        if (a[i] + tec < v) {
 
            // Add balance to ans
            ll mov = v - a[i] - tec;
            ans = ans + mov;
 
            // Update contiguous
            // subarray of length k
            tec += mov;
            b[i + k] = mov;
        }
    }
 
    // Number of moves
    // should not exceed m
    return (ans <= m);
}
 
// Function to find the maximum
// value of the smallest array
// element that can be obtained
ll FindLargest(vector<ll> a)
{
    l = 1;
    r = pow(10, 10);
 
    // Perform Binary search
    while (r - l > 0) {
 
        ll tm = (l + r + 1) / 2;
 
        if (check(tm, a))
            l = tm;
        else
            r = tm - 1;
    }
    return l;
}
 
// Driver Code
int main()
{
    // Given Input
    vector<ll> a{ 2, 2, 2, 2, 1, 1 };
    m = 2;
    k = 3;
    n = a.size();
 
    // Function Call
    cout << FindLargest(a);
    return 0;
}

Java




// Java program for above approach
class GFG{
     
static long n, m, k, l, r, i;
 
// Function to check if the smallest
// value of v is achievable or not
static boolean check(long v, long[] a)
{
    long tec = 0, ans = 0;
     
    // Create array to
    // store previous moves
    long[] b = new long[(int)(n + k + 1)];
 
    for(int i = 0; i < n; i++)
    {
         
        // Remove previous moves
        tec -= b[i];
 
        if (a[i] + tec < v)
        {
             
            // Add balance to ans
            long mov = v - a[i] - tec;
            ans = ans + mov;
 
            // Update contiguous
            // subarray of length k
            tec += mov;
            b[i + (int)k] = mov;
        }
    }
 
    // Number of moves
    // should not exceed m
    return ans <= m;
}
 
// Function to find the maximum
// value of the smallest array
// element that can be obtained
static long FindLargest(long[] a)
{
    l = 1;
    r = (long)Math.pow(10, 10);
 
    // Perform Binary search
    while (r - l > 0)
    {
        long tm = (l + r + 1) / 2;
 
        if (check(tm, a))
            l = tm;
        else
            r = tm - 1;
    }
    return l;
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given Input
    long[] a = { 2, 2, 2, 2, 1, 1 };
    m = 2;
    k = 3;
    n = a.length;
 
    // Function Call
    System.out.println(FindLargest(a));
}
}
 
// This code is contributed by hritikrommie.

Python3




# Python 3 program for above approach
 
n = 0
m = 0
k = 0
l = 0
r = 0
i = 0
 
from math import pow
# Function to check if the smallest
# value of v is achievable or not
def check(v, a):
    tec = 0
    ans = 0
 
    # Create array to
    # store previous moves
    b = [0 for i in range(n + k + 1)]
 
    for i in range(n):
        # Remove previous moves
        tec -= b[i]
 
        if (a[i] + tec < v):
            # Add balance to ans
            mov = v - a[i] - tec
            ans = ans + mov
 
            # Update contiguous
            # subarray of length k
            tec += mov
            b[i + k] = mov
 
    # Number of moves
    # should not exceed m
    return (ans <= m)
 
# Function to find the maximum
# value of the smallest array
# element that can be obtained
def FindLargest(a):
    l = 1
    r = pow(10, 10)
 
    # Perform Binary search
    while (r - l > 0):
        tm = (l + r + 1) // 2
 
        if (check(tm, a)):
            l = tm
        else:
            r = tm - 1
    return l
 
# Driver Code
if __name__ == '__main__':
   
    # Given Input
    a = [2, 2, 2, 2, 1, 1]
    m = 2
    k = 3
    n = len(a)
 
    # Function Call
    print(int(FindLargest(a)))
     
    # This code is contributed by ipg2016107.

C#




// C# program for above approach
using System;
 
public class GFG
{
     
static long n, m, k, l, r, i;
 
// Function to check if the smallest
// value of v is achievable or not
static bool check(long v, long[] a)
{
    long tec = 0, ans = 0;
     
    // Create array to
    // store previous moves
    long[] b = new long[(int)(n + k + 1)];
 
    for(int i = 0; i < n; i++)
    {
         
        // Remove previous moves
        tec -= b[i];
 
        if (a[i] + tec < v)
        {
             
            // Add balance to ans
            long mov = v - a[i] - tec;
            ans = ans + mov;
 
            // Update contiguous
            // subarray of length k
            tec += mov;
            b[i + (int)k] = mov;
        }
    }
 
    // Number of moves
    // should not exceed m
    return ans <= m;
}
 
// Function to find the maximum
// value of the smallest array
// element that can be obtained
static long FindLargest(long[] a)
{
    l = 1;
    r = (long)Math.Pow(10, 10);
 
    // Perform Binary search
    while (r - l > 0)
    {
        long tm = (l + r + 1) / 2;
 
        if (check(tm, a))
            l = tm;
        else
            r = tm - 1;
    }
    return l;
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given Input
    long[] a = { 2, 2, 2, 2, 1, 1 };
    m = 2;
    k = 3;
    n = a.Length;
 
    // Function Call
    Console.WriteLine(FindLargest(a));
}
}
 
// This code is contributed by shikhasingrajput

Javascript




<script>
 
// Javascript program for above approach
let n = 0, m = 0, k = 0, l = 0, r = 0, i = 0;
 
// Function to check if the smallest
// value of v is achievable or not
function check(v, a)
{
    let tec = 0,
    ans = 0;
     
    // Create array to
    // store previous moves
    let b = new Array(n + k + 1).fill(0);
     
    for(i = 0; i < n; i++)
    {
         
        // Remove previous moves
        tec -= b[i];
         
        if (a[i] + tec < v)
        {
             
            // Add balance to ans
            let mov = v - a[i] - tec;
            ans = ans + mov;
             
            // Update contiguous
            // subarray of length k
            tec += mov;
            b[i + k] = mov;
        }
    }
     
    // Number of moves
    // should not exceed m
    return ans <= m;
}
 
// Function to find the maximum
// value of the smallest array
// element that can be obtained
function FindLargest(a)
{
    l = 1;
    r = Math.pow(10, 10);
     
    // Perform Binary search
    while (r - l > 0)
    {
        let tm = Math.floor((l + r + 1) / 2);
         
        if (check(tm, a)) l = tm;
        else r = tm - 1;
    }
    return l;
}
 
// Driver Code
 
// Given Input
let a = [ 2, 2, 2, 2, 1, 1 ];
m = 2;
k = 3;
n = a.length;
 
// Function Call
document.write(FindLargest(a));
 
// This code is contributed by _saurabh_jaiswal
 
</script>
Output: 
2

 

Time Complexity: O(NlogN) 
Auxiliary Space: O(N + K)
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :