Longest subarray such that difference of max and min is at-most K

Given an array arr[] of length N, tark is to find the length of longest subarray such that difference of its maximum element and minumum element is not more than an integer K

Examples:

Input: K = 3, arr[]= {1, 4, 5, 6, 9}
Output: 3
Explanation:
Largest Subarray is {4, 5, 6}

Input: K = 4, arr[]= {1, 2, 3, 4, 5}
Output: 5
Explanation:
Largest Subarray is {1, 2, 3, 4, 5}

Naive approach:



Time Complexity: O(N3)

Efficient approach: The idea is to first sort the array, and then use binary search to optimize the approach.

  • Sort the given array
  • For every distinct element A[i] in the array find the first element A[j] such that (A[j]-A[i]) > K.
  • For its implementation we use Binary search or lower_bound and update ans each time as maximum of previous ans and difference of indixes.

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find longest
// subarray such that difference
// of max and min is at-most K
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to calculate longest
// subarray with above condition
int findLargestSubarray(
    vector<int>& arr,
    int N, int K)
{
  
    // Sort the array
    sort(arr.begin(), arr.end());
  
    int value1 = arr[0], value2 = 0;
    int index1, index2, i, MAX;
    index1 = index2 = 0;
    i = 0, MAX = 0;
  
    // Loop which will terminate
    // when no further elements
    // can be included in the subarray
  
    while (index2 != N) {
  
        // first value such that
        // arr[index2] - arr[index1] > K
        value2 = value1 + (K + 1);
  
        // calculate its index using lower_bound
        index2 = lower_bound(arr.begin(),
                             arr.end(), value2)
                 - arr.begin();
  
        // index2- index1 will give
        // the accurate length
        // of suarray then compare
        // for MAX length and store
        // in MAX variable
        MAX = max(MAX, (index2 - index1));
  
        // change the index1
        // to next greater element
        // than previous one
        // and recalculate the value1
        index1
            = lower_bound(
                  arr.begin(),
                  arr.end(), arr[index1] + 1)
              - arr.begin();
        value1 = arr[index1];
    }
  
    // finally return answer MAX
    return MAX;
}
// Driver Code
int main()
{
    int N, K;
    N = 18;
    K = 5;
    vector<int> arr{ 1, 1, 1, 2, 2,
                     2, 2, 2, 3,
                     3, 3, 6, 6, 7,
                     7, 7, 7, 7 };
    cout << findLargestSubarray(arr, N, K);
    return 0;
}

chevron_right


Output:

15

Time Complexity: O(N*log(N))

competitive-programming-img




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.