具有可被 K 整除的所有对的绝对差的最长子序列的长度

给定一个大小为N的数组arr[]和一个整数K ，任务是从给定数组中找到最长子序列的长度，使得子序列中每对的绝对差可以被K整除。

例子：

Input: arr[] = {10, 12, 16, 20, 32, 15}, K = 4  
Output: 4 
Explanation:
The Longest subsequence in which the absolute difference of each pair divisible by K (= 4) are {12, 26, 20, 32}.
Therefore, the required output is 4

Input: arr[] = {12, 3, 13, 5, 21, 11}, K = 3
Output: 3

朴素的方法：解决这个问题的最简单的方法是生成给定数组的所有可能子序列并打印最长子序列的长度，该长度具有每对可被K整除的绝对差。

时间复杂度： O(2 ^N )
辅助空间： O(N)

高效的方法：为了优化上述方法，想法是基于以下观察使用哈希：

Absolute difference of all possible pairs of a subset having the equal value of arr[i] % K must be divisible by K.

Mathematical Proof:
If arr[i] % K = arr[j] % K
=> abs(arr[i] – arr[j]) % K must be 0.

请按照以下步骤解决问题：

• 初始化一个数组，比如hash[K]来存储arr[i] % K的频率。
• 遍历散列[]数组并找到散列[]数组的最大元素。
• 最后，打印hash[]数组的最大元素。

下面是上述方法的实现：

C++14

// C++14 program to implement
// the above approach
#include 
using namespace std;
 
// Function to find the length
// of subsequence that satisfy
// the given condition
int maxLenSub(int arr[],
              int N, int K)
{
    // Store the frequencies
    // of arr[i] % K
    int hash[K];
 
    // Initilize hash[] array
    memset(hash, 0, sizeof(hash));
 
    // Traverse the given array
    for (int i = 0; i < N; i++) {
 
        // Update frequency of
        // arr[i] % K
        hash[arr[i] % K]++;
    }
 
    // Stores the length of
    // the longest subsequence that
    // satisfy the given condition
    int LenSub = 0;
 
    // Find the maximum element
    // in hash[] array
    for (int i = 0; i < K; i++) {
        LenSub = max(LenSub, hash[i]);
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 12, 3, 13, 5, 21, 11 };
    int K = 3;
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << maxLenSub(arr, N, K);
}

Java

// Java program to implement
// the above approach
import java.util.*;
class GFG{
 
// Function to find the length
// of subsequence that satisfy
// the given condition
static int maxLenSub(int arr[],
                     int N, int K)
{
  // Store the frequencies
  // of arr[i] % K
  int []hash = new int[K];
 
  // Traverse the given array
  for (int i = 0; i < N; i++)
  {
    // Update frequency of
    // arr[i] % K
    hash[arr[i] % K]++;
  }
 
  // Stores the length of
  // the longest subsequence that
  // satisfy the given condition
  int LenSub = 0;
 
  // Find the maximum element
  // in hash[] array
  for (int i = 0; i < K; i++)
  {
    LenSub = Math.max(LenSub,
                      hash[i]);
  }
   
  return LenSub;
}
 
// Driver Code
public static void main(String[] args)
{
  int arr[] = {12, 3, 13, 5, 21, 11};
  int K = 3;
  int N = arr.length;
  System.out.print(maxLenSub(arr, N, K));
}
}
 
// This code is contributed by Rajput-Ji

Python3

# Python3 program to implement
# the above approach
 
# Function to find the length
# of subsequence that satisfy
# the given condition
def maxLenSub(arr, N, K):
     
    # Store the frequencies
    # of arr[i] % K
    hash = [0] * K
 
    # Traverse the given array
    for i in range(N):
 
        # Update frequency of
        # arr[i] % K
        hash[arr[i] % K] += 1
 
    # Stores the length of the
    # longest subsequence that
    # satisfy the given condition
    LenSub = 0
 
    # Find the maximum element
    # in hash[] array
    for i in range(K):
        LenSub = max(LenSub, hash[i])
         
    return LenSub   
 
# Driver Code
if __name__ == '__main__':
     
    arr = [ 12, 3, 13, 5, 21, 11 ]
    K = 3
    N = len(arr)
     
    print(maxLenSub(arr, N, K))
 
# This code is contributed by mohit kumar 29

C#

// C# program to implement
// the above approach
using System;
class GFG{
 
// Function to find the length
// of subsequence that satisfy
// the given condition
static int maxLenSub(int []arr,
                     int N, int K)
{
  // Store the frequencies
  // of arr[i] % K
  int []hash = new int[K];
 
  // Traverse the given array
  for (int i = 0; i < N; i++)
  {
    // Update frequency of
    // arr[i] % K
    hash[arr[i] % K]++;
  }
 
  // Stores the length of
  // the longest subsequence that
  // satisfy the given condition
  int LenSub = 0;
 
  // Find the maximum element
  // in hash[] array
  for (int i = 0; i < K; i++)
  {
    LenSub = Math.Max(LenSub,
                      hash[i]);
  }
 
  return LenSub;
}
 
// Driver Code
public static void Main(String[] args)
{
  int []arr = {12, 3, 13,
               5, 21, 11};
  int K = 3;
  int N = arr.Length;
  Console.Write(maxLenSub(arr, N, K));
}
}
 
// This code is contributed by Amit Katiyar

Javascript

 
// Javascript program to implement
// the above approach
 
// Function to find the length
// of subsequence that satisfy
// the given condition
function maxLenSub(arr, N, K)
{
     
    // Store the frequencies
    // of arr[i] % K
    let hash = Array.from({length: K}, (_, i) => 0); 
     
    // Traverse the given array
    for(let i = 0; i < N; i++)
    {
         
        // Update frequency of
        // arr[i] % K
        hash[arr[i] % K]++;
    }
     
    // Stores the length of
    // the longest subsequence that
    // satisfy the given condition
    let LenSub = 0;
     
    // Find the maximum element
    // in hash[] array
    for(let i = 0; i < K; i++)
    {
        LenSub = Math.max(LenSub,
                          hash[i]);
    }
    return LenSub;
}
  
// Driver Code
let arr = [ 12, 3, 13, 5, 21, 11 ];
let K = 3;
let N = arr.length;
 
document.write(maxLenSub(arr, N, K));
 
// This code is contributed by target_2
 

输出

3

时间复杂度： O(N)
辅助空间： O(K)

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