# Count number of distinct sum subsets within given range

Given a set S of N numbers and a range specified by two numbers L (Lower Bound) and R (Upper Bound). Find the number of distinct values of all possible sums of some subset of S that lie between the given range.

Examples :

Input : S = { 1, 2, 2, 3, 5 }, L = 1 and R = 5 Output : 5Explanation :Every number between 1 and 5 can be made out using some subset of S. {1 as 1, 2 as 2, 3 as 3, 4 as 2 + 2 and 5 as 5} Input : S = { 2, 3, 5 }, L = 1 and R = 7 Output : 4Explanation :Only 4 numbers between 1 and 7 can be made out, i.e. {2, 3, 5, 7}. 3 numbers which are {1, 4, 6} can't be made out in any way.

**Prerequisites : ** Bitset | Bit Manipulation

**Method 1(Simple) : ** A naive approach is to generate all possible subsets of given set, calculate their sum subset wise and push them into a hashmap. Iterate over the complete given range and count the numbers which exists in the hashmap.

**Method 2(Efficient) : ** An efficient way to solve this problem is by using bitset of size 10^{5}. Update the bitset for every element X by left shifting the bitset and doing bitwise OR with previous bitset so that the bitset at the new possible sums become 1. Then by using the concept of **Prefix Sums**, precompute the required count of numbers between 1 and i for prefix[1..i] to answer each query in O(1) if there are more than query being asked simultaneously. For a query L and R, answer would be simply **prefix[R] – prefix[L – 1]**

For e.g.S = { 2, 3, 5 }, L = 1 and R = 7

Considering a bitset of size 32 for simplicity. Initially 1 is at 0_{th}position of bitset

00000000000000000000000000000001

For incoming 2, left shifting the bitset by 2 and doing OR with previous bitset

00000000000000000000000000000101

Similarly for 3,

00000000000000000000000000101101

for 5,

00000000000000000000010110101101

This final bitset contains 1 at those positions(possible sums) which can be made out using some

subset of S. Hence between position 1 and 7, there are 4 set bits, thus the required answer.

**Below is the implementation of above approach in C++ :**

`// CPP Program to count the number ` `// distinct values of sum of some ` `// subset in a range ` `#include <bits/stdc++.h> ` ` ` `using` `namespace` `std; ` ` ` `// Constant size for bitset ` `#define SZ 100001 ` ` ` `int` `countOfpossibleNumbers(` `int` `S[], ` `int` `N, ` ` ` `int` `L, ` `int` `R) ` `{ ` ` ` `// Creating a bitset of size SZ ` ` ` `bitset <SZ> BS; ` ` ` ` ` `// Set 0th position to 1 ` ` ` `BS[0] = 1; ` ` ` ` ` `// Build the bitset ` ` ` `for` `(` `int` `i = 0; i < N; i++) { ` ` ` ` ` `// Left shift the bitset for each ` ` ` `// element and taking bitwise OR ` ` ` `// with previous bitset ` ` ` `BS = BS | (BS << S[i]); ` ` ` `} ` ` ` ` ` `int` `prefix[SZ]; ` ` ` ` ` `// Intializing the prefix array to zero ` ` ` `memset` `(prefix, 0, ` `sizeof` `(prefix)); ` ` ` ` ` `// Build the prefix array ` ` ` `for` `(` `int` `i = 1; i < SZ; i++) { ` ` ` `prefix[i] = prefix[i - 1] + BS[i]; ` ` ` `} ` ` ` ` ` `// Answer the given query ` ` ` `int` `ans = prefix[R] - prefix[L - 1]; ` ` ` ` ` `return` `ans; ` `} ` ` ` `// Driver Code to test above functions ` `int` `main() ` `{ ` ` ` `int` `S[] = { 1, 2, 3, 5, 7 }; ` ` ` `int` `N = ` `sizeof` `(S) / ` `sizeof` `(S[0]); ` ` ` ` ` `int` `L = 1, R = 18; ` ` ` ` ` `cout << countOfpossibleNumbers(S, N, L, R); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

18

**Time Complexity : ** O(S*Z) where S*Z is the maximum sum for given constraints, i.e. 10^{5}

## Recommended Posts:

- Find the count of distinct numbers in a range
- Count number of subsets having a particular XOR value
- Count number of set bits in a range using bitset
- Count distinct Bitwise OR of all Subarrays
- Number of subsets with product less than k
- Count of numbers having only 1 set bit in the range [0, n]
- Count set bits in a range
- Count unset bits in a range
- Python | Count set bits in a range
- Range query for count of set bits
- Python | Count unset bits in a range
- Count and Print the alphabets having ASCII value in the range [l, r]
- Count and Print the alphabets having ASCII value not in the range [l, r]
- Queries to find the count of integers in a range that contain the given pattern
- Count numbers in range such that digits in it and it's product with q are unequal

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.