Given a set of positive integer elements, find 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 number of subsets for a given GCD ‘i’ where i lies in 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 which 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 above idea.

## C++

`// C++ program to count number of subsets with given GCDs ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// n is size of arr[] and m is sizeof gcd[] ` `void` `ccountSubsets(` `int` `arr[], ` `int` `n, ` `int` `gcd[], ` `int` `m) ` `{ ` ` ` `// Map to store frequency of array elements ` ` ` `unordered_map<` `int` `, ` `int` `> freq; ` ` ` ` ` `// Map to store number of subsets with given gcd ` ` ` `unordered_map<` `int` `, ` `int` `> subsets; ` ` ` ` ` `// Initialize maximum element. Assumption: all array ` ` ` `// elements are positive. ` ` ` `int` `arrMax = 0; ` ` ` ` ` `// Find maximum element in array and fill frequency ` ` ` `// map. ` ` ` `for` `(` `int` `i=0; i<n; i++) ` ` ` `{ ` ` ` `arrMax = max(arrMax, arr[i]); ` ` ` `freq[arr[i]]++; ` ` ` `} ` ` ` ` ` `// Run a loop from max element to 1 to find subsets ` ` ` `// with all gcds ` ` ` `for` `(` `int` `i=arrMax; i>=1; i--) ` ` ` `{ ` ` ` `int` `sub = 0; ` ` ` `int` `add = freq[i]; ` ` ` ` ` `// Run a loop for all multiples of i ` ` ` `for` `(` `int` `j = 2; j*i <= arrMax; j++) ` ` ` `{ ` ` ` `// Sum the frequencies of every element which ` ` ` `// is a multiple of i ` ` ` `add += freq[j*i]; ` ` ` ` ` `// Excluding those subsets which have gcd > i but ` ` ` `// not i i.e. which have gcd as multiple of i in ` ` ` `// the subset for ex: {2,3,4} cnsidering i = 2 and ` ` ` `// subset we need to exclude are those havng gcd as 4 ` ` ` `sub += subsets[j*i]; ` ` ` `} ` ` ` ` ` `// Number of subsets with GCD equal to 'i' is pow(2, add) ` ` ` `// - 1 - sub ` ` ` `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; ` `} ` ` ` `// Driver program ` `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; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to count number of ` `# subsets with given GCDs ` ` ` `# n is size of arr[] and m is sizeof gcd[] ` `def` `countSubsets(arr, n, gcd, m): ` ` ` ` ` `# Map to store frequency of array elements ` ` ` `freq ` `=` `dict` `() ` ` ` ` ` `# Map to store number of subsets ` ` ` `# with given gcd ` ` ` `subsets ` `=` `dict` `() ` ` ` ` ` `# Initialize maximum element. ` ` ` `# Assumption: all array elements ` ` ` `# are positive. ` ` ` `arrMax ` `=` `0` ` ` ` ` `# Find maximum element in array and ` ` ` `# fill frequency map. ` ` ` `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` ` ` ` ` `# Run a loop from max element to 1 ` ` ` `# to find subsets with all gcds ` ` ` `for` `i ` `in` `range` `(arrMax, ` `0` `, ` `-` `1` `): ` ` ` `sub ` `=` `0` ` ` `add ` `=` `0` ` ` `if` `i ` `in` `freq: ` ` ` `add ` `=` `freq[i] ` ` ` `j ` `=` `2` ` ` ` ` `# Run a loop for all multiples of i ` ` ` `while` `j ` `*` `i <` `=` `arrMax: ` ` ` ` ` `# Sum the frequencies of every element ` ` ` `# which is a multiple of i ` ` ` `if` `j ` `*` `i ` `in` `freq: ` ` ` `add ` `+` `=` `freq[j ` `*` `i] ` ` ` ` ` `# Excluding those subsets which have ` ` ` `# gcd > i but not i i.e. which have gcd ` ` ` `# as multiple of i in the subset. ` ` ` `# for ex: {2,3,4} cnsidering i = 2 and ` ` ` `# subset we need to exclude are those ` ` ` `# havng gcd as 4 ` ` ` `sub ` `+` `=` `subsets[j ` `*` `i] ` ` ` `j ` `+` `=` `1` ` ` ` ` `# Number of subsets with GCD equal ` ` ` `# to 'i' is pow(2, add) - 1 - sub ` ` ` `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]])) ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` `gcd ` `=` `[` `2` `, ` `3` `] ` ` ` `arr ` `=` `[` `9` `, ` `6` `, ` `2` `] ` ` ` `n ` `=` `len` `(arr) ` ` ` `m ` `=` `len` `(gcd) ` ` ` `countSubsets(arr, n, gcd, m) ` ` ` `# This code is contributed by ` `# sanjeev2552 ` |

*chevron_right*

*filter_none*

Output:

Number of subsets with gcd 2 is 2 Number of subsets with gcd 3 is 1

**Exercise:** Extend the above solution so that all calculations are done under modulo 1000000007 to avoid overflows.

This article is contributed by **Ekta Goel**. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
- Count pairs of natural numbers with GCD equal to given number
- Pair of integers having least GCD among all given pairs having GCD exceeding K
- Divide array in two Subsets such that sum of square of sum of both subsets is maximum
- Check if array can be sorted by swapping pairs with GCD of set bits count equal to that of the smallest array element
- Count of subsets with sum equal to X using Recursion
- Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
- Count numbers in a range having GCD of powers of prime factors equal to 1
- Count of quadruplets from range [L, R] having GCD equal to K
- Count of all possible pairs having sum of LCM and GCD equal to N
- Count of Subsets of a given Set with element X present in it
- Partition of a set into K subsets with equal sum using BitMask and DP
- Pairs with GCD equal to one in the given range
- Number of Quadruples with GCD equal to K
- Number of subarrays with GCD equal to 1
- Count of Subsets containing only the given value K
- Divide first N natural numbers into 3 equal sum subsets
- Subsets of size K with product equal to difference of two perfect squares
- Minimum deletions required to make GCD of the array equal to 1
- Check if array can be sorted by swapping pairs having GCD equal to the smallest element in the array