最长子序列，使得每对之间的绝对差最多为 1

给定一个大小为N的整数数组arr[] ，任务是找到最长的子序列S使得对于每个 a[i], a[j] ∈ S 和|a[i] – a[j]| ≤ 1 。

例子：

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

推荐：请先在“ PRACTICE ”上解决，然后再继续解决。

方法：

这个想法是观察到对于每个可能对之间存在差异的子序列，当子序列包含 [X , X + 1] 之间的元素时，最多可能有一个。

• 将所需子序列的最大长度初始化为 0。
• 创建一个 HashMap 来存储数组中每个元素的频率。
• 通过哈希映射和哈希映射中的每个元素 a[i] 进行交互 –
  • 找出元素 (a[i] + 1)、(a[i]) 和 (a[i] – 1) 的出现次数。
  • 找出元素出现的最大次数 (a[i] + 1) 或 (a[i] – 1)。
  • 如果总出现次数大于找到的最大长度，则更新子序列的最大长度。

下面是上述方法的实现。

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

输出：

5

时间复杂度： O(n)。
空间复杂度： O(n)。

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live