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; } |
Java
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); }} |
Python3
# Maximum allowed query valueMAXSUM = 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 vectordef 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 programif __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) |
C#
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
// JavaScript program to answer subset sum queries using bitset// Maximum allowed query valueconst 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 vectorfunction 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 programfunction 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(); |
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.
Auxiliary Space: O(n)
This article is contributed by Avinash Kumar Saw. If you like neveropen 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 neveropen main page and help other Geeks.
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
