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:

Generate all subarray and find the minimum and maximum in the subarray.
Calculate difference between minimum and maximum and if it is smaller or equal to K, then update answer

Time Complexity: O(N³)

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:

// 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; 
} 

Output:

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

My Personal Notes

Recommended Posts: