Count number of subsets of a set with GCD equal to a given number
Last Updated :
15 Jun, 2023
Given a set of positive integer elements, find the count of subsets with GCDs equal to given numbers.
Examples:
Input: arr[] = {2, 3, 4}, gcd[] = {2, 3}
Output: Number of subsets with gcd 2 is 2
Number of subsets with gcd 3 is 1
The two subsets with GCD equal to 2 are {2} and {2, 4}.
The one subset with GCD equal to 3 ss {3}.
Input: arr[] = {6, 3, 9, 2}, gcd = {3, 2}
Output: Number of subsets with gcd 3 is 5
Number of subsets with gcd 2 is 2
The five subsets with GCD equal to 3 are {3}, {6, 3},
{3, 9}, {6, 9) and {6, 3, 9}.
The two subsets with GCD equal to 2 are {2} and {2, 6}
We strongly recommend you to minimize your browser and try this yourself first.
A Simple Solution is to generate all subsets of given set and find GCD of every subset.
Below is an Efficient Solution for small numbers, i,e, the maximum of all numbers is not very high.
1) Find the maximum number of given numbers. Let the
maximum be arrMax.
2) Count occurrences of all numbers using a hash. Let
this hash be 'freq'
3) The maximum possible GCD can be arrMax. Run a loop
for i = arrMax to 1
a) Count number of subsets for current GCD.
4) Now we have counts for all possible GCDs, return
count for given gcds.
How does step 3.a work?
How to get the number of subsets for a given GCD ‘i’ where i lies in the range from 1 to arrMax. The idea is to count all multiples of i using ‘freq’ built-in step 2. Let there be ‘add’ multiples of i. The number of all possible subsets with ‘add’ numbers would be “pow(2, add) – 1”, excluding the empty set. For example, if given array is {2, 3, 6} and i = 3, there are 2 multiples of 3 (3 and 6). So there will be 3 subsets {3}, {3, 6} and {6} which have a multiple of i as GCD. These subsets also include {6} which doesn’t have 3 as GCD, but a multiple of 3. So we need to subtract such subsets. We store subset counts for every GCD in another hash map ‘subset’. Let ‘sub’ be the number of subsets that have multiple of ‘i’ as GCD. The value of ‘sub’ for any multiple of ‘i’ can directly be obtained from subset[] as we are evaluating counts from arrMax to 1.
Below is the implementation of the above idea.
C++
#include<bits/stdc++.h>
using namespace std;
void ccountSubsets( int arr[], int n, int gcd[], int m)
{
unordered_map< int , int > freq;
unordered_map< int , int > subsets;
int arrMax = 0;
for ( int i=0; i<n; i++)
{
arrMax = max(arrMax, arr[i]);
freq[arr[i]]++;
}
for ( int i=arrMax; i>=1; i--)
{
int sub = 0;
int add = freq[i];
for ( int j = 2; j*i <= arrMax; j++)
{
add += freq[j*i];
sub += subsets[j*i];
}
subsets[i] = (1<<add) - 1 - sub;
}
for ( int i=0; i<m; i++)
cout << "Number of subsets with gcd " << gcd[i] << " is "
<< subsets[gcd[i]] << endl;
}
int main()
{
int gcd[] = {2, 3};
int arr[] = {9, 6, 2};
int n = sizeof (arr)/ sizeof (arr[0]);
int m = sizeof (gcd)/ sizeof (gcd[0]);
ccountSubsets(arr, n, gcd, m);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void ccountSubsets( int arr[], int n,
int gcd[], int m)
{
HashMap<Integer,
Integer> freq =
new HashMap<Integer,
Integer>();
HashMap<Integer,
Integer> subsets =
new HashMap<Integer,
Integer>();
int arrMax = 0 ;
for ( int i = 0 ; i < n; i++)
{
arrMax = Math.max(arrMax,
arr[i]);
if (freq.containsKey(arr[i]))
{
freq.put(arr[i],
freq.get(arr[i]) + 1 );
}
else
{
freq.put(arr[i], 1 );
}
}
for ( int i = arrMax; i >= 1 ; i--)
{
int sub = 0 ;
int add = 0 ;
if (freq.containsKey(i))
add = freq.get(i);
for ( int j = 2 ; j * i <= arrMax; j++)
{
if (freq.containsKey(i * j))
add += freq.get(j * i);
sub += subsets.get(j * i);
}
subsets.put(i, ( 1 << add) -
1 - sub);
}
for ( int i = 0 ; i < m; i++)
System.out.print( "Number of subsets with gcd " +
gcd[i] + " is " +
subsets.get(gcd[i]) + "\n" );
}
public static void main(String[] args)
{
int gcd[] = { 2 , 3 };
int arr[] = { 9 , 6 , 2 };
int n = arr.length;
int m = gcd.length;
ccountSubsets(arr, n, gcd, m);
}
}
|
Python3
def countSubsets(arr, n, gcd, m):
freq = dict ()
subsets = dict ()
arrMax = 0
for i in range (n):
arrMax = max (arrMax, arr[i])
if arr[i] not in freq:
freq[arr[i]] = 1
else :
freq[arr[i]] + = 1
for i in range (arrMax, 0 , - 1 ):
sub = 0
add = 0
if i in freq:
add = freq[i]
j = 2
while j * i < = arrMax:
if j * i in freq:
add + = freq[j * i]
sub + = subsets[j * i]
j + = 1
subsets[i] = ( 1 << add) - 1 - sub
for i in range (m):
print ( "Number of subsets with gcd %d is %d" %
(gcd[i], subsets[gcd[i]]))
if __name__ = = "__main__" :
gcd = [ 2 , 3 ]
arr = [ 9 , 6 , 2 ]
n = len (arr)
m = len (gcd)
countSubsets(arr, n, gcd, m)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static void ccountSubsets( int []arr, int n,
int []gcd, int m)
{
Dictionary< int ,
int > freq =
new Dictionary< int ,
int >();
Dictionary< int ,
int > subsets =
new Dictionary< int ,
int >();
int arrMax = 0;
for ( int i = 0; i < n; i++)
{
arrMax = Math.Max(arrMax,
arr[i]);
if (freq.ContainsKey(arr[i]))
{
freq.Add(arr[i],
freq[arr[i]] + 1);
}
else
{
freq.Add(arr[i], 1);
}
}
for ( int i = arrMax; i >= 1; i--)
{
int sub = 0;
int add = 0;
if (freq.ContainsKey(i))
add = freq[i];
for ( int j = 2;
j * i <= arrMax; j++)
{
if (freq.ContainsKey(i * j))
add += freq[j * i];
sub += subsets[j * i];
}
subsets.Add(i, (1 << add) -
1 - sub);
}
for ( int i = 0; i < m; i++)
Console.Write( "Number of subsets with gcd " +
gcd[i] + " is " +
subsets[gcd[i]] + "\n" );
}
public static void Main(String[] args)
{
int []gcd = {2, 3};
int []arr = {9, 6, 2};
int n = arr.Length;
int m = gcd.Length;
ccountSubsets(arr, n, gcd, m);
}
}
|
Javascript
<script>
function countSubsets(arr, n, gcd, m){
let freq = new Map
let subsets = new Map
let arrMax = 0
for (let i = 0; i < n; i++)
{
arrMax = Math.max(arrMax, arr[i])
if (freq.has(arr[i]) == false )
freq.set(arr[i], 1)
else
freq.set(arr[i], freq.get(arr[i])+1)
}
for (let i = arrMax; i > 0; i--)
{
let sub = 0
let add = 0
if (freq.has(i))
add = freq.get(i)
let j = 2
while (j * i <= arrMax){
if (freq.has(j * i))
add += freq.get(j * i)
sub += subsets.get(j * i)
j += 1
}
subsets.set(i , (1 << add) - 1 - sub)
}
for (let i = 0; i < m; i++)
{
document.write( `Number of subsets with gcd ${gcd[i]} is ${subsets.get(gcd[i])}`, "</br>" )
}
}
let gcd = [2, 3]
let arr = [9, 6, 2]
let n = arr.length
let m = gcd.length
countSubsets(arr, n, gcd, m)
</script>
|
Output:
Number of subsets with gcd 2 is 2
Number of subsets with gcd 3 is 1
Time Complexity: O(n * log(max(arr)) * sqrt(max(arr))), where n is the size of the input array and max(arr) represents the maximum element in the array.
Auxiliary Space: O(max(arr)), as it uses two unordered maps to store frequency of array elements and the number of subsets with a given gcd. The space required by the maps depends on the maximum element in the array.
Exercise: Extend the above solution so that all calculations are done under modulo 1000000007 to avoid overflows.
Share your thoughts in the comments
Please Login to comment...