# Longest subsequence such that absolute difference between every pair is atmost 1

• Last Updated : 05 Oct, 2021

Given an integer array arr[] of size N, the task is to find the longest subsequence S such that for every a[i], a[j] ∈ S and |a[i] – a[j]| ≤ 1.

Examples:

Input: arr[] = {2, 2, 3, 5, 5, 6, 6, 6}
Output:
Explanation:
There are 2 such subsequence such that difference between every pair is atmost 1
{2, 2, 3} and {5, 5, 6, 6, 6}
The longest one of these is {5, 5, 6, 6, 6} with length of 5.

Input: arr[] = {5, 7, 6, 4, 4, 2}
Output:

Approach:
The idea is to observe that for a subsequence with a difference between every possible pair at most one is possible when the subsequence contains elements between [X , X + 1].

• Initialize the maximum length of the required subsequence to 0.
• Create a HashMap to store the frequency of every element of the array.
• Iterate through the Hash Map and for every element a[i] in hash map –
• Find the count of occurrence of element (a[i] + 1), (a[i]) and (a[i] – 1).
• Find the Maximum count out of occurrence of elements (a[i] + 1) or (a[i] – 1).
• If the Total count of occurrence is greater than the maximum length found then update the maximum length of subsequence.

Below is the implementation of the above approach.

## Java

 `// Java implementation for``// Longest subsequence such that absolute``// difference between every pair is atmost 1` `import` `java.util.*;``public` `class` `GeeksForGeeks {``    ``public` `static` `int` `longestAr(``            ``int` `n, ``int` `arr[]){``        ``Hashtable count``            ``= ``new` `Hashtable();` `        ``// Storing the frequency of each``        ``// element in the hashtable count``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `(count.containsKey(arr[i]))``                ``count.put(arr[i], count.get(``                    ``arr[i]) + ``1``                ``);``            ``else``                ``count.put(arr[i], ``1``);``        ``}` `        ``Set kset = count.keySet();``        ``Iterator it = kset.iterator();` `        ``// Max is used to keep a track of``        ``// maximum length of the required``        ``// subsequence so far.``        ``int` `max = ``0``;` `        ``while` `(it.hasNext()) {``            ``int` `a = (``int``)it.next();``            ``int` `cur = ``0``;``            ``int` `cur1 = ``0``;``            ``int` `cur2 = ``0``;` `            ``// Store frequency of the``            ``// given element+1.``            ``if` `(count.containsKey(a + ``1``))``                ``cur1 = count.get(a + ``1``);` `            ``// Store frequency of the``            ``// given element-1.``            ``if` `(count.containsKey(a - ``1``))``                ``cur2 = count.get(a - ``1``);` `            ``// cur store the longest array``            ``// that can be formed using a.``            ``cur = count.get(a) +``                  ``Math.max(cur1, cur2);` `            ``// update max if cur>max.``            ``if` `(cur > max)``                ``max = cur;``        ``}` `        ``return` `(max);``    ``}``    ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``8``;``        ``int` `arr[] = { ``2``, ``2``, ``3``, ``5``, ``5``, ``6``, ``6``, ``6` `};``        ``int` `maxLen = longestAr(n, arr);``        ``System.out.println(maxLen);``    ``}``}`

## Python3

 `# Python3 implementation for``# Longest subsequence such that absolute``# difference between every pair is atmost 1` `def` `longestAr(n, arr):``    ``count ``=` `dict``()` `    ``# Storing the frequency of each``    ``# element in the hashtable count``    ``for` `i ``in` `arr:``        ``count[i] ``=` `count.get(i, ``0``) ``+` `1` `    ``kset ``=` `count.keys()` `    ``# Max is used to keep a track of``    ``# maximum length of the required``    ``# subsequence so far.``    ``maxm ``=` `0` `    ``for` `it ``in` `list``(kset):``        ``a ``=` `it``        ``cur ``=` `0``        ``cur1 ``=` `0``        ``cur2 ``=` `0` `        ``# Store frequency of the``        ``# given element+1.``        ``if` `((a ``+` `1``) ``in` `count):``            ``cur1 ``=` `count[a ``+` `1``]` `        ``# Store frequency of the``        ``# given element-1.``        ``if` `((a ``-` `1``) ``in` `count):``            ``cur2 ``=` `count[a ``-` `1``]` `        ``# cur store the longest array``        ``# that can be formed using a.``        ``cur ``=` `count[a] ``+` `max``(cur1, cur2)` `        ``# update maxm if cur>maxm.``        ``if` `(cur > maxm):``            ``maxm ``=` `cur` `    ``return` `maxm` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``n ``=` `8``    ``arr ``=` `[``2``, ``2``, ``3``, ``5``, ``5``, ``6``, ``6``, ``6``]``    ``maxLen ``=` `longestAr(n, arr)``    ``print``(maxLen)` `# This code is contributed by mohit kumar 29`

## Javascript

 ``

Output:

`5`

Time Complexity: O(n).
Space Complexity: O(n).

My Personal Notes arrow_drop_up