Open In App

Subset with no pair sum divisible by K

Improve
Improve
Like Article
Like
Save
Share
Report

Given an array of integer numbers, we need to find maximum size of a subset such that sum of each pair of this subset is not divisible by K. 

Examples : 

Input :  arr[] = [3, 7, 2, 9, 1]        
         K = 3
Output : 3
Maximum size subset whose each pair sum 
is not divisible by K is [3, 7, 1] because,
3+7 = 10,    
3+1 = 4,    
7+1 = 8        all are not divisible by 3.
It is not possible to get a subset of size 
bigger than 3 with the above-mentioned property.

Input : arr[] = [3, 17, 12, 9, 11, 15]
        K = 5
Output : 4  

We can solve this problem by computing modulo of array numbers with K. if sum of two numbers is divisible by K, then if one of them gives remainder i, other will give remainder (K – i). First we store frequencies of numbers giving specific remainder in a frequency array of size K. Then we loop for all remainders i and include max(f[i], f[K – i]). Why? a subset with no pair sum divisible by K must include either elements with remainder f[i] or with remainder f[K – i]. Since we want to maximize the size of subset, we pick maximum of two sizes. 

In below code array numbers with remainder 0 and remainder K/2 are handled separately. If we include more than 2 numbers with remainder 0 then their sum will be divisible by K, so we have taken at max 1 number in our consideration, same is the case with array numbers giving remainder K/2.

Implementation:

C++




// C++ program to get size of subset whose
// each pair sum is not divisible by K
#include <bits/stdc++.h>
using namespace std;
  
// Returns maximum size of subset with no pair
// sum divisible by K
int subsetPairNotDivisibleByK(int arr[], int N,
                                         int K)
{
    // Array for storing frequency of modulo
    // values
    int f[K];
    memset(f, 0, sizeof(f));
  
    // Fill frequency array with values modulo K
    for (int i = 0; i < N; i++)
        f[arr[i] % K]++;
  
    //  if K is even, then update f[K/2]
    if (K % 2 == 0)
        f[K/2] = min(f[K/2], 1);
  
    // Initialize result by minimum of 1 or
    // count of numbers giving remainder 0
    int res = min(f[0], 1);
  
    // Choose maximum of count of numbers
    // giving remainder i or K-i
    for (int i = 1; i <= K/2; i++)
        res += max(f[i], f[K-i]);
  
    return res;
}
  
//  Driver code to test above methods
int main()
{
    int arr[] = {3, 7, 2, 9, 1};
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 3;
    cout << subsetPairNotDivisibleByK(arr, N, K);
    return 0;
}


Java




// Java program to get size of subset whose
// each pair sum is not divisible by K
import java.util.Arrays;
  
class Test {
      
    // Returns maximum size of subset with no pair
    // sum divisible by K
    static int subsetPairNotDivisibleByK(int arr[], 
                                      int N, int K)
    {
          
        // Array for storing frequency of modulo
        // values
        int f[] = new int[K];
        Arrays.fill(f, 0);
      
        // Fill frequency array with values modulo K
        for (int i = 0; i < N; i++)
            f[arr[i] % K]++;
      
        // if K is even, then update f[K/2]
        if (K % 2 == 0)
            f[K/2] = Math.min(f[K/2], 1);
      
        // Initialize result by minimum of 1 or
        // count of numbers giving remainder 0
        int res = Math.min(f[0], 1);
      
        // Choose maximum of count of numbers
        // giving remainder i or K-i
        for (int i = 1; i <= K/2; i++)
            res += Math.max(f[i], f[K-i]);
      
        return res;
    }
      
    // Driver method
    public static void main(String[] args)
    {
          
        int arr[] = {3, 7, 2, 9, 1};
        int N = arr.length;
        int K = 3;
          
        System.out.print(subsetPairNotDivisibleByK(
                                         arr, N, K));
    }
}
  
// This code is contributed by Anant Agarwal.


Python3




# Python3 program to get size of
# subset whose each pair sum is
# not divisible by K
  
# Returns maximum size of subset 
# with no pair sum divisible by K
def subsetPairNotDivisibleByK(arr, N, K):
  
    # Array for storing frequency 
    # of modulo values
    f = [0 for i in range(K)]
  
    # Fill frequency array with
    # values modulo K
    for i in range(N):
        f[arr[i] % K] += 1
  
    # if K is even, then update f[K/2]
    if (K % 2 == 0):
        f[K//2] = min(f[K//2], 1)
  
    # Initialize result by minimum of 1 or
    # count of numbers giving remainder 0
    res = min(f[0], 1)
  
    # Choose maximum of count of numbers
    # giving remainder i or K-i
    for i in range(1,(K // 2) + 1):
        res += max(f[i], f[K - i])
  
    return res
      
# Driver Code
arr = [3, 7, 2, 9, 1]
N = len(arr)
K = 3
print(subsetPairNotDivisibleByK(arr, N, K))
  
# This code is contributed by Anant Agarwal.


C#




// C# program to get size of subset whose
// each pair sum is not divisible by K
using System;
  
class Test {
      
    // Returns maximum size of subset 
    // with no pair sum divisible by K
    static int subsetPairNotDivisibleByK(int []arr, 
                                         int N, int K)
    {
        // Array for storing 
        // frequency of modulo values
        int []f = new int[K];
        for(int i = 0; i < K; i++)
        f[i] = 0;
          
      
        // Fill frequency array with values modulo K
        for (int i = 0; i < N; i++)
            f[arr[i] % K]++;
      
        // if K is even, then update f[K/2]
        if (K % 2 == 0)
            f[K/2] = Math.Min(f[K/2], 1);
      
        // Initialize result by minimum of 1 or
        // count of numbers giving remainder 0
        int res = Math.Min(f[0], 1);
      
        // Choose maximum of count of numbers
        // giving remainder i or K-i
        for (int i = 1; i <= K/2; i++)
            res += Math.Max(f[i], f[K-i]);
      
        return res;
    }
      
    // Driver method
    public static void Main()
    {
        int []arr = {3, 7, 2, 9, 1};
        int N = arr.Length;
        int K = 3;
          
        // Function calling
        Console.Write(subsetPairNotDivisibleByK(arr, N, K));
    }
}
  
// This code is contributed by nitin mittal.


PHP




<?php 
// PHP program to get size of subset whose
// each pair sum is not divisible by K
  
// Returns maximum size of subset with 
// no pair sum divisible by K
function subsetPairNotDivisibleByK(&$arr, $N, $K)
{
    // Array for storing frequency of 
    // modulo values
    $f = array_fill(0, $K, NULL);
  
    // Fill frequency array with
    // values modulo K
    for ($i = 0; $i < $N; $i++)
        $f[$arr[$i] % $K]++;
  
    // if K is even, then update f[K/2]
    if ($K % 2 == 0)
        $f[$K / 2] = min($f[$K / 2], 1);
  
    // Initialize result by minimum of 1 or
    // count of numbers giving remainder 0
    $res = min($f[0], 1);
  
    // Choose maximum of count of numbers
    // giving remainder i or K-i
    for ($i = 1; $i <= $K / 2; $i++)
        $res += max($f[$i], $f[$K - $i]);
  
    return $res;
}
  
// Driver Code
$arr = array(3, 7, 2, 9, 1);
$N = sizeof($arr);
$K = 3;
echo subsetPairNotDivisibleByK($arr, $N, $K);
  
// This code is contributed by ita_c
?>


Javascript




<script>
  
// Javascript program to get size of subset whose
// each pair sum is not divisible by K
      
    // Returns maximum size of subset with no pair
    // sum divisible by K
    function subsetPairNotDivisibleByK(arr,N,K)
    {
        // Array for storing frequency of modulo
        // values
        let f = new Array(K);
        for(let i=0;i<K;i++)
        {
            f[i]=0;
        }
          
          
        
        // Fill frequency array with values modulo K
        for (let i = 0; i < N; i++)
            f[arr[i] % K]++;
        
        // if K is even, then update f[K/2]
        if (K % 2 == 0)
            f[K/2] = Math.min(f[K/2], 1);
        
        // Initialize result by minimum of 1 or
        // count of numbers giving remainder 0
        let res = Math.min(f[0], 1);
        
        // Choose maximum of count of numbers
        // giving remainder i or K-i
        for (let i = 1; i <= K/2; i++)
            res += Math.max(f[i], f[K-i]);
        
        return res;
    }
      
    let arr=[3, 7, 2, 9, 1];
    let N = arr.length;
    let K = 3;
    document.write(subsetPairNotDivisibleByK(
                                         arr, N, K));
      
    // This code is contributed by avanitrachhadiya2155
  
</script>


Output

3

Time Complexity: O(N + K) 
Auxiliary Space: O(K)

 



Last Updated : 19 Sep, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads