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 ? ?arri.
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. 

Implementation:

Yes, No, 

Time complexity: O(n * MAX_ELEMENT ) for pre-calculating since left shift operator takes O(q) for p<<q . It takes O(1) for subsequent queries, where n is the number of elements in the array.
Auxiliary Space:O(n)

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.