# Subset sum queries using bitset

Given an array **arr[]** and a number of queries, where in each query we have to check whether a subset whose sum is equal to given number exists in the array or not.

Examples:

Input : arr[] = {1, 2, 3}; query[] = {5, 3, 8} Output : Yes, Yes, No There is a subset with sum 5, subset is {2, 3} There is a subset with sum 3, subset is {1, 2} There is no subset with sum 8. Input : arr[] = {4, 1, 5}; query[] = {7, 9} Output : No, Yes There is no subset with sum 7. There is a subset with sum 9, subset is {4, 5}

The idea is to use bitset container in C++. Using bitset, we can precalculate the existence all the subset sums in an array in O(n) and answer subsequent queries in just O(1).

We basically use an array of bits **bit[]** to represent the subset sum of elements in the array. Size of bit[] should be at least sum of all array elements plus 1 to answer all queries. We keep of bit[x] as 1 if x is a subset sum of given array, else false. Note that indexing is assumed to begin with 0.

For every element arr[i] of input array, we do following // bit[x] will be 1 if x is a subset // sum of arr[], else 0 bit = bit | (bit << arr[i])

**How does this work?**

Let us consider arr[] = {3, 1, 5}, we need to whether a subset sum of x exists or not, where 0 ≤ x ≤ Σarr_{i}. We create a bitset bit[10] and reset all the bits to 0, i.e., we make it 0000000000. Set the 0th bit, because a subset sum of 0 exists in every array. Now, the bit array is 0000000001 Apply the above technique for all the elements of the array : Current bitset = 0000000001 After doing "bit = bit | (bit << 3)", bitset becomes 0000001001 After doing "bit | (bit << 1)", bitset becomes 0000011011 After doing "bit | (bit << 5)", bitset becomes 1101111011

Finally, we have the bit array as 1101111011, so, if bit[x] is 1 then a subset sum of x exists otherwise not. We can clearly observe that a subset sum of all the numbers from 0 to 9 except 2 and 7 exists in the array.

Here is a C++ implementation :

`// C++ program to answer subset sum queries using bitset ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Maximum allowed query value ` `# define MAXSUM 10000 ` ` ` `// function to check whether a subset sum equal to n ` `// exists in the array or not. ` `void` `processQueries(` `int` `query[], ` `int` `nq, bitset<MAXSUM> bit) ` `{ ` ` ` `// One by one process subset sum queries ` ` ` `for` `(` `int` `i=0; i<nq; i++) ` ` ` `{ ` ` ` `int` `x = query[i]; ` ` ` ` ` `// If x is beyond size of bit[] ` ` ` `if` `(x >= MAXSUM) ` ` ` `{ ` ` ` `cout << ` `"NA, "` `; ` ` ` `continue` `; ` ` ` `} ` ` ` ` ` `// Else if x is a subset sum, then x'th bit ` ` ` `// must be set ` ` ` `bit[x]? cout << ` `"Yes, "` `: cout << ` `"No, "` `; ` ` ` `} ` `} ` ` ` `// function to store all the subset sums in bit vector ` `void` `preprocess(bitset<MAXSUM> &bit, ` `int` `arr[], ` `int` `n) ` `{ ` ` ` `// set all the bits to 0 ` ` ` `bit.reset(); ` ` ` ` ` `// set the 0th bit because subset sum of 0 exists ` ` ` `bit[0] = 1; ` ` ` ` ` `// Process all array elements one by one ` ` ` `for` `(` `int` `i = 0; i < n; ++i) ` ` ` ` ` `// Do OR of following two ` ` ` `// 1) All previous sums. We keep previous value ` ` ` `// of bit. ` ` ` `// 2) arr[i] added to every previous sum. We ` ` ` `// move all previous indexes arr[i] ahead. ` ` ` `bit |= (bit << arr[i]); ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `arr[] = {3, 1, 5}; ` ` ` `int` `query[] = {8, 7}; ` ` ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` `int` `nq = ` `sizeof` `(query) / ` `sizeof` `(query[0]); ` ` ` ` ` `// a vector of MAXSUM number of bits ` ` ` `bitset<MAXSUM> bit; ` ` ` ` ` `preprocess(bit, arr, n); ` ` ` `processQueries(query, nq, bit); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

Yes, No,

**Time complexity** : O(n) for pre-calculating and O(1) for subsequent queries, where n is the number of elements in the array.

Refer http://stackoverflow.com/questions/12459563/what-is-the-size-of-bitset-in-c for space requirements of this approach.

This article is contributed by **Avinash Kumar Saw**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: **DSA Self Paced**. Become industry ready at a student-friendly price.

## Recommended Posts:

- Subset Sum Queries in a Range using Bitset
- std::bitset::to_ullong and std::bitset::to_ulong in C++ STL
- Find maximum subset sum formed by partitioning any subset of array into 2 partitions with equal sum
- bitset any() in C++ STL
- bitset none() in C++ STL
- bitset size() in C++ STL
- bitset count() in C++ STL
- bitset all() function in C++ STL
- bitset::flip() in C++ STL
- bitset operator[] in C++ STL
- C++ bitset and its application
- bitset test() in C++ STL
- bitset set() function in C++ STL
- bitset reset() function in C++ STL
- C++ bitset interesting facts
- _Find_next() function in C++ bitset with Examples
- _Find_first() function in C++ bitset with Examples
- Count number of set bits in a range using bitset
- Count number of common elements between two arrays by using Bitset and Bitwise operation
- Array range queries over range queries