# Maximize length of subarray of equal elements by performing at most K increment operations

Given an array A[] consisting of N integers and an integer K, the task is to maximize the length of the subarray having equal elements after performing at most K increments by 1 on array elements.

Note: Same array element can be incremented more than once.

Examples:

Input: A[] = {2, 4, 8, 5, 9, 6}, K = 6
Output: 3
Explanation:
Subarray [8, 5, 9] can be modified to [9, 9, 9].
Total number of increments required is 5 which is less than K(= 6).

Input: A[] = {2, 2, 4}, K = 10
Output: 3

Naive Approach: The simplest approach to solve the problem is to generate all possible subarrays and for each subarray, check if all its elements can be made equal in at most K increments. Print the maximum length of such subarrays obtained.
Time Complexity: O(N3
Auxiliary Space: O(1)

Approach: The above approach can be optimized using the Sliding Window technique. Follow the steps below to solve the problem:

• Keep a track of the maximum element of the window.
• The total operations required for a particular window is obtained by the following equation:

Count of operations = (Length of the window calculated so far + 1) * (Maximum element from the window) – Sum of the window

• Now, check if the above-calculated value exceeds K or not. If so, then slide the starting pointer of the window towards the right, otherwise increment the length of the window calculated so far.
• Repeat the above steps to obtain the longest window satisfying the required condition.

Below is the implementation of the above approach:

## C++14

 `// C++14 program for above approach` `#include ` `using` `namespace` `std;` `#define newl "\n"`   `// Function to find the maximum length` `// of subarray of equal elements after` `// performing at most K increments` `int` `maxSubarray(``int` `a[], ``int` `k, ``int` `n)` `{`   `    ``// Stores the size` `    ``// of required subarray` `    ``int` `answer = 0;`   `    ``// Starting point of a window` `    ``int` `start = 0;`   `    ``// Stores the sum of window` `    ``long` `int` `s = 0;`   `    ``deque<``int``> dq;`   `    ``// Iterate over arrray` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{` `        `  `        ``// Current element` `        ``int` `x = a[i];`   `        ``// Remove index of minimun elements` `        ``// from deque which are less than` `        ``// the current element` `        ``while` `(!dq.empty() &&` `               ``a[dq.front()] <= x)` `            ``dq.pop_front();`   `        ``// Insert current index in deque` `        ``dq.push_back(i);`   `        ``// Update current window sum` `        ``s += x;`   `        ``// Calculate required operation to` `        ``// make current window elements equal` `        ``long` `int` `cost = (``long` `int``)a[dq.front()] *` `                        ``(answer + 1) - s;`   `        ``// If cost is less than k` `        ``if` `(cost <= (``long` `int``)k)` `            ``answer++;`   `        ``// Shift window start pointer towards` `        ``// right and update current window sum` `        ``else` `        ``{` `            ``if` `(dq.front() == start)` `                ``dq.pop_front();` `                `  `            ``s -= a[start++];` `        ``}` `    ``}` `    `  `    ``// Return answer` `    ``return` `answer;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `a[] = { 2, 2, 4 };` `    ``int` `k = 10;` `    `  `    ``// Length of array` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a);` `    `  `    ``cout << (maxSubarray(a, k, n));` `    `  `    ``return` `0;` `}`   `// This code is contributed by jojo9911`

## Java

 `// Java Program for above approach` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to find the maximum length` `    ``// of subarray of equal elements after` `    ``// performing at most K increments` `    ``static` `int` `maxSubarray(``int``[] a, ``int` `k)` `    ``{` `        ``// Length of array` `        ``int` `n = a.length;`   `        ``// Stores the size` `        ``// of required subarray` `        ``int` `answer = ``0``;`   `        ``// Starting point of a window` `        ``int` `start = ``0``;`   `        ``// Stores the sum of window` `        ``long` `s = ``0``;`   `        ``Deque dq = ``new` `LinkedList<>();`   `        ``// Iterate over arrray` `        ``for` `(``int` `i = ``0``; i < n; i++) {`   `            ``// Current element` `            ``int` `x = a[i];`   `            ``// Remove index of minimun elements` `            ``// from deque which are less than` `            ``// the current element` `            ``while` `(!dq.isEmpty() && a[dq.peek()] <= x)` `                ``dq.poll();`   `            ``// Insert current index in deque` `            ``dq.add(i);`   `            ``// Update current window sum` `            ``s += x;`   `            ``// Calculate required operation to` `            ``// make current window elements equal` `            ``long` `cost` `                ``= (``long``)a[dq.peekFirst()] * (answer + ``1``)` `                  ``- s;`   `            ``// If cost is less than k` `            ``if` `(cost <= (``long``)k)` `                ``answer++;`   `            ``// Shift window start pointer towards` `            ``// right and update current window sum` `            ``else` `{` `                ``if` `(dq.peekFirst() == start)` `                    ``dq.pollFirst();` `                ``s -= a[start++];` `            ``}` `        ``}`   `        ``// Return answer` `        ``return` `answer;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``int``[] a = { ``2``, ``2``, ``4` `};` `        ``int` `k = ``10``;`   `        ``// Funtion call` `        ``System.out.println(maxSubarray(a, k));` `    ``}` `}`

## Python3

 `# Python3 program for above approach` `from` `collections ``import` `deque`   `# Function to find the maximum length` `# of subarray of equal elements after` `# performing at most K increments` `def` `maxSubarray(a, k):` `    `  `    ``# Length of array` `    ``n ``=` `len``(a)`   `    ``# Stores the size` `    ``# of required subarray` `    ``answer ``=` `0`   `    ``# Starting po of a window` `    ``start ``=` `0`   `    ``# Stores the sum of window` `    ``s ``=` `0`   `    ``dq ``=` `deque()`   `    ``# Iterate over arrray` `    ``for` `i ``in` `range``(n):`   `        ``# Current element` `        ``x ``=` `a[i]`   `        ``# Remove index of minimun elements` `        ``# from deque which are less than` `        ``# the current element` `        ``while` `(``len``(dq) > ``0` `and` `a[dq[``-``1``]] <``=` `x):` `            ``dq.popleft()`   `        ``# Insert current index in deque` `        ``dq.append(i)`   `        ``# Update current window sum` `        ``s ``+``=` `x`   `        ``# Calculate required operation to` `        ``# make current window elements equal` `        ``cost ``=` `a[dq[``0``]] ``*` `(answer ``+` `1``) ``-` `s`   `        ``# If cost is less than k` `        ``if` `(cost <``=` `k):` `            ``answer ``+``=` `1`   `        ``# Shift window start poer towards` `        ``# right and update current window sum` `        ``else``:` `            ``if` `(dq[``0``] ``=``=` `start):` `                ``dq.popleft()` `                `  `            ``s ``-``=` `a[start]` `            ``start ``+``=` `1`   `    ``# Return answer` `    ``return` `answer`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``a ``=` `[ ``2``, ``2``, ``4` `]` `    ``k ``=` `10`   `    ``# Funtion call` `    ``print``(maxSubarray(a, k))`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# Program for` `// the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{`   `// Function to find the maximum length` `// of subarray of equal elements after` `// performing at most K increments` `static` `int` `maxSubarray(``int``[] a, ``int` `k)` `{` `  ``// Length of array` `  ``int` `n = a.Length;`   `  ``// Stores the size` `  ``// of required subarray` `  ``int` `answer = 0;`   `  ``// Starting point of a window` `  ``int` `start = 0;`   `  ``// Stores the sum of window` `  ``long` `s = 0;`   `  ``Queue<``int``> dq = ``new` `Queue<``int``>();`   `  ``// Iterate over arrray` `  ``for` `(``int` `i = 0; i < n; i++)` `  ``{` `    ``// Current element` `    ``int` `x = a[i];`   `    ``// Remove index of minimun ` `    ``// elements from deque ` `    ``// which are less than` `    ``// the current element` `    ``while` `(dq.Count!=0 && ` `           ``a[dq.Peek()] <= x)` `      ``dq.Dequeue();`   `    ``// Insert current ` `    ``// index in deque` `    ``dq.Enqueue(i);`   `    ``// Update current window sum` `    ``s += x;`   `    ``// Calculate required operation to` `    ``// make current window elements equal` `    ``long` `cost = (``long``)a[dq.Peek()] * ` `                ``(answer + 1) - s;`   `    ``// If cost is less than k` `    ``if` `(cost <= (``long``)k)` `      ``answer++;`   `    ``// Shift window start pointer towards` `    ``// right and update current window sum` `    ``else` `    ``{` `      ``if` `(dq.Peek() == start)` `        ``dq.Dequeue();` `      ``s -= a[start++];` `    ``}` `  ``}`   `  ``// Return answer` `  ``return` `answer;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``int``[] a = {2, 2, 4};` `  ``int` `k = 10;`   `  ``// Funtion call` `  ``Console.WriteLine(maxSubarray(a, k));` `}` `}`   `// This code is contributed by gauravrajput1`

Output:

```3

```

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

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.