# Find all distinct subsets of a given set using BitMasking Approach

• Difficulty Level : Hard
• Last Updated : 07 Feb, 2022

Given a set of positive integers, find all its subsets. The set can contain duplicate elements, so any repeated subset should be considered only once in the output.
Examples:

```Input:  S = {1, 2, 2}
Output:  {}, {1}, {2}, {1, 2}, {2, 2}, {1, 2, 2}

Explanation:
The total subsets of given set are -
{}, {1}, {2}, {2}, {1, 2}, {1, 2}, {2, 2}, {1, 2, 2}
Here {2} and {1, 2} are repeated twice so they are considered
only once in the output```

Prerequisite: Power Set
The idea is to use a bit-mask pattern to generate all the combinations as discussed in previous post. But previous post will print duplicate subsets if the elements are repeated in the given set. To handle duplicate elements, we construct a string out of given subset such that subsets having similar elements will result in same string. We maintain a list of such unique strings and finally we decode all such string to print its individual elements.

Note: This method will only work on sorted array.
Below is its implementation –

## C++14

 `// C++ program to find all subsets of given set. Any``// repeated subset is considered only once in the output``#include ``using` `namespace` `std;` `// Function to find all subsets of given set. Any repeated``// subset is considered only once in the output``vector > findPowerSet(vector<``int``>& nums)``{``    ``int` `bits = nums.size();     ``// size of array to set bit``    ``unsigned ``int` `pow_set_size = ``pow``(2, bits);     ``// total number of subsets = pow(2, sizeof(arr))``    ``sort(nums.begin(), nums.end());     ``// sort to avoid adding permutation of the substring``    ``vector> ans;``    ``vector list;     ``// to store subset as a list to avoid adding exact duplicates` `    ` `    ``// counter 000..0 to 111..1``    ``for` `(``int` `counter = 0; counter < pow_set_size; counter++) {``        ``vector<``int``> subset;``        ``string temp = ``""``;``    ` `        ``// check for the current bit in the counter``        ``for` `(``int` `j = 0; j < bits; j++) {``            ``if` `(counter & (1 << j)) {``                ``subset.push_back(nums[j]);``                ``// add special character to separate integers``                ``temp += to_string(nums[j]) + ``'\$'``;``            ``}``        ``}``    ` `        ``if` `(find(list.begin(), list.end(), temp) == list.end()) {``            ``ans.push_back(subset);``            ``list.push_back(temp);``        ``}``    ``}` `    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``vector<``int``> arr{ 10,12,12 };` `    ``vector > power_set = findPowerSet(arr);``    ` `    ``for``(``int` `i=0;i

## Python3

 `# Python3 program to find all subsets of``# given set. Any repeated subset is``# considered only once in the output``def` `printPowerSet(arr, n):``    ` `    ``# Function to find all subsets of given set.``    ``# Any repeated subset is considered only``    ``# once in the output``    ``_list ``=` `[]` `    ``# Run counter i from 000..0 to 111..1``    ``for` `i ``in` `range``(``2``*``*``n):``        ``subset ``=` `""` `        ``# consider each element in the set``        ``for` `j ``in` `range``(n):` `            ``# Check if jth bit in the i is set.``            ``# If the bit is set, we consider``            ``# jth element from set``            ``if` `(i & (``1` `<< j)) !``=` `0``:``                ``subset ``+``=` `str``(arr[j]) ``+` `"|"` `        ``# if subset is encountered for the first time``        ``# If we use set, we can directly insert``        ``if` `subset ``not` `in` `_list ``and` `len``(subset) > ``0``:``            ``_list.append(subset)` `    ``# consider every subset``    ``for` `subset ``in` `_list:` `        ``# split the subset and print its elements``        ``arr ``=` `subset.split(``'|'``)``        ``for` `string ``in` `arr:``            ``print``(string, end ``=` `" "``)``        ``print``()` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``10``, ``12``, ``12``]``    ``n ``=` `len``(arr)``    ``printPowerSet(arr, n)` `# This code is contributed by vibhu4agarwal`

Output:

```10
12
10 12
12 12
10 12 12 ```

Time Complexity: O(N*2N)

Auxiliary Space: O(N*N)

Refer to the below article to solve the problem using the backtracking approach.

https://www.geeksforgeeks.org/backtracking-to-find-all-subsets/