给定由N个整数和整数K组成的数组arr [] ，任务是找到给定数组的最长子序列，以使子序列中最大元素和最小元素之间的差恰好为K。
例子：
Input: arr[] = {1, 3, 2, 2, 5, 2, 3, 7}, K = 1
Output: 5
Explanation:
The longest subsequence whose difference between the maximum and minimum element is K(= 1) is {3, 2, 2, 2, 3}.
Therefore, the length is 5.
Input: arr [] = {4, 3, 3, 4}, K = 4
Output: 0
天真的方法：最简单的方法是生成给定数组的所有可能的子序列，并为每个子序列找到子序列中最大值和最小值之间的差。如果等于K ，则更新所得的最长子序列长度。检查所有子序列后，打印获得的最大长度。
时间复杂度： O(2 N )
辅助空间： O(1)
高效方法：为了优化上述方法，该想法是基于以下观察结果：在所需的子序列中，只能存在两个唯一元素，并且它们的差应为K。该问题可以通过哈希解决，以存储每个数组元素的频率。请按照以下步骤解决问题：
- 初始化一个变量，例如ans ，以存储最长子序列的长度。
- 初始化一个哈希图，例如M ，该哈希图存储数组元素的频率。
- 使用变量i遍历数组arr [] ，对于每个数组元素arr [i] ，将M中arr []的频率增加1 。
- 现在以M遍历散列映射M和用于每个键(说X)，如果(X + K)也存在于所述M，则ANS的值更新为最大ANS的和两个键的值的总和。
- 完成上述步骤后，输出ans的值作为结果。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Function to find longest subsequence
// having absolute difference between
// maximum and minimum element K
void longestSubsequenceLength(int arr[],
int N, int K)
{
// Stores the frequency of each
// array element
unordered_map um;
// Traverse the array arr[]
for (int i = 0; i < N; i++)
// Increment um[arr[i]] by 1
um[arr[i]]++;
// Store the required answer
int ans = 0;
// Traverse the hashmap
for (auto it : um) {
// Check if it.first + K
// exists in the hashmap
if (um.find(it.first + K)
!= um.end()) {
// Update the answer
ans = max(ans,
it.second
+ um[it.first + K]);
}
}
// Print the result
cout << ans;
}
// Driver Code
int main()
{
int arr[] = { 1, 3, 2, 2, 5, 2, 3, 7 };
int N = sizeof(arr) / sizeof(arr[0]);
int K = 1;
longestSubsequenceLength(arr, N, K);
return 0;
} Java
// Java program for the above approach
import java.util.*;
class GFG{
// Function to find longest subsequence
// having absolute difference between
// maximum and minimum element K
static void longestSubsequenceLength(int []arr,
int N, int K)
{
// Stores the frequency of each
// array element
Map um = new HashMap();
// Traverse the array arr[]
for(int i = 0; i < N; i++)
{
if (um.containsKey(arr[i]))
um.put(arr[i], um.get(arr[i]) + 1);
else
um.put(arr[i], 1);
}
// Store the required answer
int ans = 0;
// Traverse the hashmap
for(Map.Entry e : um.entrySet())
{
// Check if it.first + K
// exists in the hashmap
if (um.containsKey(e.getKey() + K))
{
// Update the answer
ans = Math.max(ans, e.getValue() +
um.get(e.getKey() + K));
}
}
// Print the result
System.out.println(ans);
}
// Driver Code
public static void main(String args[])
{
int []arr = { 1, 3, 2, 2, 5, 2, 3, 7 };
int N = arr.length;
int K = 1;
longestSubsequenceLength(arr, N, K);
}
}
// This code is contributed by bgangwar59 Python3
# Python3 program for the above approach
from collections import defaultdict
# Function to find longest subsequence
# having absolute difference between
# maximum and minimum element K
def longestSubsequenceLength(arr, N, K):
# Stores the frequency of each
# array element
um = defaultdict(int)
# Traverse the array arr[]
for i in range(N):
# Increment um[arr[i]] by 1
um[arr[i]] += 1
# Store the required answer
ans = 0
# Traverse the hashmap
for it in um.keys():
# Check if it.first + K
# exists in the hashmap
if (it + K) in um:
# Update the answer
ans = max(ans,
um[it]
+ um[it + K])
# Print the result
print(ans)
# Driver Code
if __name__ == "__main__":
arr = [1, 3, 2, 2, 5, 2, 3, 7]
N = len(arr)
K = 1
longestSubsequenceLength(arr, N, K)
# This code is contributed by chitranayal.C#
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG
{
// Function to find longest subsequence
// having absolute difference between
// maximum and minimum element K
static void longestSubsequenceLength(int[] arr,
int N, int K)
{
// Stores the frequency of each
// array element
Dictionary um = new Dictionary();
// Traverse the array
for(int i = 0; i < N; i++)
{
// Increase the counter of
// the array element by 1
int count = um.ContainsKey(arr[i]) ? um[arr[i]] : 0;
if (count == 0)
{
um.Add(arr[i], 1);
}
else
{
um[arr[i]] = count + 1;
}
}
// Store the required answer
int ans = 0;
// Traverse the hashmap
foreach(KeyValuePair it in um)
{
// Check if it.first + K
// exists in the hashmap
if (um.ContainsKey(it.Key + K))
{
// Update the answer
ans = Math.Max(ans, (it.Value + um[it.Key + K]));
}
}
// Print the result
Console.Write(ans);
}
// Driver Code
public static void Main()
{
int[] arr = { 1, 3, 2, 2, 5, 2, 3, 7 };
int N = arr.Length;
int K = 1;
longestSubsequenceLength(arr, N, K);
}
}
// This code is contributed by splevel62. 输出：
5时间复杂度： O(N)
辅助空间： O(N)