Related Articles

# 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

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 ` `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& a)` `{` `    ``ll tec = 0, ans = 0;`   `    ``// Create array to` `    ``// store previous moves` `    ``vector 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 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 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

 ``

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 :