Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit in C++

Suppose we have an array of integers called nums and an integer limit, we have to find the size of the longest non-empty subarray such that the absolute difference between any two items of this subarray is less than or equal to the given limit.

So, if the input is like nums = [8,2,4,7], limit = 4, then the output will be 2, this is because −

• [8] so |8-8| = 0 <= 4.

• [8,2] so |8-2| = 6 > 4.

• [8,2,4] so |8-2| = 6 > 4.

• [8,2,4,7] so |8-2| = 6 > 4.

• [2] so |2-2| = 0 <= 4.

• [2,4] so |2-4| = 2 <= 4.

• [2,4,7] so |2-7| = 5 > 4.

• [4] so |4-4| = 0 <= 4.

• [4,7] so |4-7| = 3 <= 4.

• [7] so |7-7| = 0 <= 4.

Finally, the size of the longest subarray is 2.

To solve this, we will follow these steps −

• ret := 0, i := 0, j := 0

• Define one deque maxD and another deque minD

• n := size of nums

• for initialize i := 0, when i < n, update (increase i by 1), do −

  • while (not maxD is empty and last element of maxD < nums[i]), do −

    • delete last element from maxD

  • while (not minD is empty and last element of minD > nums[i]), do −

    • delete last element from minD

  • insert nums[i] at the end of maxD

  • insert nums[i] at the end of minD

  • while (first element of maxD - first element of minD) > k, do −

    • if nums[j] is same as first element of maxD, then−

      • delete front element from maxD

    • if nums[j] is same as first element of minD, then −

      • delete front element from minD

    • (increase j by 1)

  • ret := maximum of ret and (i - j + 1)

• return ret

Example 

Let us see the following implementation to get better understanding −

 Live Demo

#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
   int longestSubarray(vector<int>& nums, int k) {
      int ret = 0;
      int i = 0;
      int j = 0;
      deque<int> maxD;
      deque<int> minD;
      int n = nums.size();
      for (int i = 0; i < n; i++) {
         while (!maxD.empty() && maxD.back() < nums[i])
            maxD.pop_back();
         while (!minD.empty() && minD.back() > nums[i])
            minD.pop_back();
         maxD.push_back(nums[i]);
         minD.push_back(nums[i]);
         while (maxD.front() - minD.front() > k) {
            if (nums[j] == maxD.front())
               maxD.pop_front();
            if (nums[j] == minD.front())
               minD.pop_front();
            j++;
         }
         ret = max(ret, i - j + 1);
      }
      return ret;
   }
};
main(){
   Solution ob;
   vector<int> v = {7,8,2,4};
   cout << (ob.longestSubarray(v, 4));
}

Input

{7,8,2,4}, 4

Output

2