Related Articles
Longest subsequence such that absolute difference between every pair is atmost 1
• Last Updated : 15 Jun, 2020

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: 5
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: 3

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Approach:

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

• Intialize the maximum length of required subsequence to 0.
• Create a HashMap to store frequency of every element of the array.
• Interate 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 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 `

Output:

```5
```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :