 GeeksforGeeks App
Open App Browser
Continue

# 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 array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// Current element``        ``int` `x = a[i];` `        ``// Remove index of minimum 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 array``        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// Current element``            ``int` `x = a[i];` `            ``// Remove index of minimum 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``;` `        ``// Function 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 array``    ``for` `i ``in` `range``(n):` `        ``# Current element``        ``x ``=` `a[i]` `        ``# Remove index of minimum 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 pointer 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` `    ``# Function 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 array``  ``for` `(``int` `i = 0; i < n; i++)``  ``{``    ``// Current element``    ``int` `x = a[i];` `    ``// Remove index of minimum``    ``// 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;` `  ``// Function call``  ``Console.WriteLine(maxSubarray(a, k));``}``}` `// This code is contributed by gauravrajput1`

## Javascript

 ``

Output:

`3`

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

My Personal Notes arrow_drop_up