Subset sum queries using bitset
Last Updated : 20 Mar, 2024
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:
CPP // 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; } import java.util.BitSet; public class SubsetSumQueries { // Maximum allowed query value static final int MAXSUM = 10000; // function to check whether a subset sum equal to n // exists in the array or not. static void processQueries(int[] query, int nq, BitSet 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) { System.out.print("NA, "); continue; } // Else if x is a subset sum, then x'th bit // must be set System.out.print(bit.get(x) ? "Yes, " : "No, "); } } static void preprocess(BitSet bit, int[] arr, int n) { // Set the 0th bit because subset sum of 0 exists bit.set(0); // 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. for (int j = MAXSUM - arr[i] - 1; j >= 0; j--) { if (bit.get(j)) { bit.set(j + arr[i]); } } bit.set(arr[i]); } } // Driver program public static void main(String[] args) { int[] arr = {3, 1, 5}; int[] query = {8, 7}; int n = arr.length; int nq = query.length; // a bit vector BitSet bit = new BitSet(MAXSUM); preprocess(bit, arr, n); processQueries(query, nq, bit); } } using System; using System.Collections; public class SubsetSumQueries { // Maximum allowed query value const int MAXSUM = 10000; // function to check whether a subset sum equal to n // exists in the array or not. static void processQueries(int[] query, int nq, BitArray 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) { Console.Write("NA, "); continue; } // Else if x is a subset sum, then x'th bit // must be set Console.Write(bit[x] ? "Yes, " : "No, "); } } static void preprocess(BitArray bit, int[] arr, int n) { // Set the 0th bit because subset sum of 0 exists bit.Set(0, true); // 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. for (int j = MAXSUM - arr[i] - 1; j >= 0; j--) { if (bit.Get(j)) { bit.Set(j + arr[i], true); } } bit.Set(arr[i], true); } } // Driver program public static void Main(string[] args) { int[] arr = { 3, 1, 5 }; int[] query = { 8, 7 }; int n = arr.Length; int nq = query.Length; // a bit vector BitArray bit = new BitArray(MAXSUM); preprocess(bit, arr, n); processQueries(query, nq, bit); } } // JavaScript program to answer subset sum queries using bitset // Maximum allowed query value const MAXSUM = 10000; // function to check whether a subset sum equal to n // exists in the array or not. function processQueries(query, nq, bit) { let output = ""; for (let i = 0; i < nq; i++) { const x = query[i]; if (x >= MAXSUM) { output += "NA, "; continue; } bit[x] ? output += "Yes, " : output += "No, "; } console.log(output.slice(0, -2)); } // function to store all the subset sums in bit vector function preprocess(bit, arr, n) { // set all the bits to 0 for (let i = 0; i < MAXSUM; i++) { bit[i] = false; } // set the 0th bit because subset sum of 0 exists bit[0] = true; // Process all array elements one by one for (let 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. for (let j = MAXSUM - 1; j >= arr[i]; j--) { bit[j] = bit[j] || bit[j - arr[i]]; } } } // Driver program function main() { const arr = [3, 1, 5]; const query = [8, 7]; const n = arr.length; const nq = query.length; // a vector of MAXSUM number of bits const bit = new Array(MAXSUM); preprocess(bit, arr, n); processQueries(query, nq, bit); } main(); # Maximum allowed query value MAXSUM = 10000 # function to check whether a subset sum equal to n # exists in the array or not. def processQueries(query, nq, bit): # One by one process subset sum queries for i in range(nq): x = query[i] # If x is beyond size of bit[] if x >= MAXSUM: print("NA, ", end="") continue # Else if x is a subset sum, then x'th bit # must be set print("Yes, ", end="") print("No, ", end="") print() # function to store all the subset sums in bit vector def preprocess(bit, arr, n): # Process all array elements one by one for i in range(n): # 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 if __name__ == '__main__': import array arr = array.array('i', [3, 1, 5]) query = array.array('i', [8, 7]) n = len(arr) nq = len(query) # a bit vector bit = 0 preprocess(bit, arr, n) processQueries(query, nq, bit) 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 [email protected]. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Similar Reads
Subset Sum Queries in a Range using Bitset
Given an array[] of N positive integers and M queries. Each query consists of two integers L and R represented by a range. For each query, find the count of numbers that lie in the given range which can be expressed as the sum of any subset of given array. Prerequisite : Subset Sum Queries using Bit
7 min read
Subset vs Subsequence
Understanding the concepts of subsets and subsequences is essential in mathematics and computer science. Although they may seem similar at first glance, there are key differences between the two. What is a Subset?A subset is a set formed from another set by selecting zero or more elements, regardles
4 min read
Sum of numbers with exactly 2 bits set
Given a number n. Find the sum of all numbers up to n whose 2 bits are set. Examples: Input : 10 Output : 33 3 + 5 + 6 + 9 + 10 = 33 Input : 100 Output : 762 Naive Approach: Find each number up to n whose 2 bits are set. If its 2 bits are set add it to the sum. C/C++ Code // CPP program to find sum
8 min read
Partition of a set into k subsets with equal sum using BitMask and DP
Given an integer array arr[] and an integer k, the task is to check if it is possible to divide the given array into k non-empty subsets of equal sum such that every array element is part of a single subset. Examples: Input: arr[] = [2, 1, 4, 5, 6], k = 3 Output: trueExplanation: Possible subsets of
9 min read
Implementation of C++ Bitset using String
Let's implement bitset in C++, such that following operations can be performed in stated time complexities : init(int size): initializes a bitset of size number of 0 bits.void fix(int pos): Change the bit at position pos to 1. No change if it was already 1.void unfix(int pos): Change the bit at posi
4 min read
Maximum subset with bitwise OR equal to k
Given an array of non-negative integers and an integer k, find the subset of maximum length with bitwise OR equal to k. Examples: Input : arr[] = [1, 4, 2] k = 3 Output : [1, 2] Explanation: The bitwise OR of 1 and 2 equals 3. It is not possible to obtain a subset of length greater than 2. Input : a
8 min read
C++ bitset interesting facts
Bitset is a container in C++ Standard Template Library for dealing with data at the bit level. 1. A bitset stores bits (elements with only two possible values: 0 or 1). We can however get the part of a string by providing positions to bitset constructor (Positions are with respect to string position
4 min read
XOR Queries on a given set
Given a set S with the initial element 0 that is S = { 0 }. The task is to perform each query when Q number of queries are given and print the answer after every query of type 3. We can perform three types of query operations: 1 X: We can add X to the set S.2 Y: For each element i, perform i ? Y.3:
11 min read
Count number of set bits in a range using bitset
Given a large binary number.The task is to count the number of 1's in a given range from L to R (1 based indexing).Examples: Input : s = "101101011010100000111", L = 6, R = 15 Output : 5 s [L : R] = "1011010100" There is only 5 set bits.Input : s = "10110", L = 2, R = 5 Output : 2 Approach: Convert
5 min read
Sum of bitwise OR of all possible subsets of given set
Given an array arr[] of size n, we need to find sum of all the values that comes from ORing all the elements of the subsets. Prerequisites : Subset Sum of given set Examples : Input : arr[] = {1, 2, 3} Output : 18 Total Subsets = 23 -1= 7 1 = 1 2 = 2 3 = 3 1 | 2 = 3 1 | 3 = 3 2 | 3 = 3 1 | 2 | 3 = 3
8 min read