Subset Sum Queries in a Range using Bitset
Last Updated :
21 Mar, 2023
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 Bitset
Examples:
Input : arr[] = { 1, 2, 2, 3, 5 }, M = 4 L = 1, R = 2 L = 1, R = 5 L = 3, R = 6 L = 9, R = 30
Output : 2 5 4 5
Explanation : For the first query, in range [1, 2] all numbers i.e. 1 and 2 can be expressed as a subset sum, 1 as 1, 2 as 2. For the second query, in range [1, 5] all numbers i.e. 1, 2, 3, 4 and 5 can be expressed as subset sum, 1 as 1, 2 as 2, 3 as 3, 4 as 2 + 2 or 1 + 3, 5 as 5. For the third query, in range [3, 6], all numbers i.e. 3, 4, 5 and 6 can be expressed as subset sum. For the last query, only numbers 9, 10, 11, 12, 13 can be expressed as subset sum, 9 as 5 + 2 + 2, 10 as 5 + 2 + 2 + 1, 11 as 5 + 3 + 2 + 1, 12 as 5 + 3 + 2 + 2 and 13 as 5 + 3 + 2 + 2 + 1.
Approach: The idea is to use a bitset and iterate over the array to represent all possible subset sums. The current state of bitset is defined by ORing it with the previous state of bitset left shifted X times where X is the current element processed in the array. To answer the queries in O(1) time, we can precompute the count of numbers upto every number and for a range [L, R], the answer would be pre[R] – pre[L – 1], where pre[] is the precomputed array.
Below is the implementation of the above approach.
C++
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1001;
bitset<MAX> bit;
int pre[MAX];
struct que {
int L, R;
};
void answerQueries( int Q, que Queries[], int N,
int arr[])
{
bit[0] = 1;
for ( int i = 0; i < N; i++)
bit |= (bit << arr[i]);
for ( int i = 1; i < MAX; i++)
pre[i] = pre[i - 1] + bit[i];
for ( int i = 0; i < Q; i++) {
int l = Queries[i].L;
int r = Queries[i].R;
cout << pre[r] - pre[l - 1] << endl;
}
}
int main()
{
int arr[] = { 1, 2, 2, 3, 5 };
int N = sizeof (arr) / sizeof (arr[0]);
int M = 4;
que Queries[M];
Queries[0].L = 1, Queries[0].R = 2;
Queries[1].L = 1, Queries[1].R = 5;
Queries[2].L = 3, Queries[2].R = 6;
Queries[3].L = 9, Queries[3].R = 30;
answerQueries(M, Queries, N, arr);
return 0;
}
|
Java
import java.util.Arrays;
class Que {
int L, R;
Que( int L, int R) {
this .L = L;
this .R = R;
}
}
public class Main {
private static final int MAX = 1001 ;
private static boolean [] bit = new boolean [MAX];
private static int [] pre = new int [MAX];
public static void answerQueries( int Q, Que[] Queries, int N, int [] arr) {
bit[ 0 ] = true ;
for ( int i = 0 ; i < N; i++) {
for ( int j = MAX - 1 ; j >= arr[i]; j--) {
bit[j] |= bit[j - arr[i]];
}
}
for ( int i = 1 ; i < MAX; i++) {
pre[i] = pre[i - 1 ] + (bit[i] ? 1 : 0 );
}
for ( int i = 0 ; i < Q; i++) {
int l = Queries[i].L;
int r = Queries[i].R;
System.out.println(pre[r] - pre[l - 1 ]);
}
}
public static void main(String[] args) {
int [] arr = { 1 , 2 , 2 , 3 , 5 };
int N = arr.length;
int M = 4 ;
Que[] Queries = { new Que( 1 , 2 ), new Que( 1 , 5 ), new Que( 3 , 6 ), new Que( 9 , 30 )};
answerQueries(M, Queries, N, arr);
}
}
|
Python3
from typing import List
MAX = 1001
bit = [ 0 ] * MAX
pre = [ 0 ] * MAX
class Que:
def __init__( self , L, R):
self .L = L
self .R = R
def answerQueries(Q: int , Queries: List [Que], N: int , arr: List [ int ]) - > None :
global bit, pre
bit[ 0 ] = 1
for i in range (N):
bit = [b or (bit[j - arr[i]] if j - arr[i] > = 0 else 0 ) for j, b in enumerate (bit)]
for i in range ( 1 , MAX ):
pre[i] = pre[i - 1 ] + bit[i]
for i in range (Q):
l = Queries[i].L
r = Queries[i].R
print (pre[r] - pre[l - 1 ])
if __name__ = = "__main__" :
arr = [ 1 , 2 , 2 , 3 , 5 ]
N = len (arr)
M = 4
Queries = [Que( 1 , 2 ), Que( 1 , 5 ), Que( 3 , 6 ), Que( 9 , 30 )]
answerQueries(M, Queries, N, arr)
|
C#
using System;
public class GFG
{
private const int MAX = 1001;
private static bool [] bit = new bool [MAX];
private static int [] pre = new int [MAX];
public class Que
{
public int L, R;
public Que( int L, int R)
{
this .L = L;
this .R = R;
}
}
public static void answerQueries( int Q, Que[] Queries, int N, int [] arr)
{
bit[0] = true ;
for ( int i = 0; i < N; i++)
{
for ( int j = MAX - 1; j >= arr[i]; j--)
{
bit[j] |= bit[j - arr[i]];
}
}
for ( int i = 1; i < MAX; i++)
{
pre[i] = pre[i - 1] + (bit[i] ? 1 : 0);
}
for ( int i = 0; i < Q; i++)
{
int l = Queries[i].L;
int r = Queries[i].R;
Console.WriteLine(pre[r] - pre[l - 1]);
}
}
public static void Main(String[] args)
{
int [] arr = { 1, 2, 2, 3, 5 };
int N = arr.Length;
int M = 4;
Que[] Queries = { new Que(1, 2), new Que(1, 5), new Que(3, 6), new Que(9, 30) };
answerQueries(M, Queries, N, arr);
}
}
|
Javascript
const MAX = 1001;
let bit = Array(MAX).fill(0);
let pre = Array(MAX).fill(0);
class Que {
constructor(L, R) {
this .L = L;
this .R = R;
}
}
function answerQueries(Q, Queries, N, arr) {
bit[0] = 1;
for (let i = 0; i < N; i++) {
for (let j = MAX - 1; j >= arr[i]; j--) {
bit[j] |= bit[j - arr[i]];
}
}
for (let i = 1; i < MAX; i++) {
pre[i] = pre[i - 1] + bit[i];
}
for (let i = 0; i < Q; i++) {
let l = Queries[i].L;
let r = Queries[i].R;
console.log(pre[r] - pre[l - 1]);
}
}
let arr = [1, 2, 2, 3, 5];
let N = arr.length;
let M = 4;
let Queries = [ new Que(1, 2), new Que(1, 5), new Que(3, 6), new Que(9, 30)];
answerQueries(M, Queries, N, arr);
|
Time Complexity: Each query can be answered in O(1) time and precomputation requires O(MAX) time.
Auxiliary Space: O(MAX)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...