Count of Sub-Multisets With Bounded Sum - Practice Coding Problems

Count of Sub-Multisets With Bounded Sum - Problem

Imagine you're a data scientist working with a collection of non-negative integers. Your task is to find how many different ways you can select elements from this collection such that their sum falls within a specific range [l, r].

Here's the twist: you're working with a multiset, which means you can have duplicate values, but you can only use each occurrence once. For example, if you have [1, 2, 2, 3], you can use both 2's, but not three 2's.

What makes this challenging:

A sub-multiset can contain 0 to all occurrences of each unique value
Two sub-multisets are considered the same if they contain the same elements with the same frequencies
The empty multiset has a sum of 0 and counts toward your answer if l ≤ 0 ≤ r
Since the answer can be very large, return it modulo 10^9 + 7

Example: Given nums = [1, 2, 2], l = 1, r = 3
Possible sub-multisets and their sums: [] (0), [1] (1), [2] (2), [1,2] (3), [2,2] (4)
Sub-multisets with sum in [1,3]: [1], [2], [1,2] → Answer: 3

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 2, 2], l = 1, r = 3

› Output: 3

💡 Note: Sub-multisets with sum in [1,3]: [1] (sum=1), [2] (sum=2), [1,2] (sum=3). Total count: 3.

example_2.py — With Zeros

$ Input: nums = [0, 1, 2], l = 0, r = 2

› Output: 6

💡 Note: Sub-multisets: [] (0), [0] (0), [1] (1), [2] (2), [0,1] (1), [0,2] (2). All have sum in [0,2], so answer is 6.

example_3.py — Large Range

$ Input: nums = [1, 2, 3], l = 0, r = 10

› Output: 8

💡 Note: All possible sub-multisets: [], [1], [2], [3], [1,2], [1,3], [2,3], [1,2,3]. All have sum ≤ 10, so answer is 8.

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
0 ≤ nums[i] ≤ 2 × 10⁴
0 ≤ l ≤ r ≤ 2 × 10⁴
All elements are non-negative integers
Answer should be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Count Cookie Types

Group identical cookies: 1 chocolate chip (50 cal), 2 oatmeal (100 cal each)

DP Magic

Instead of trying all combinations, count them mathematically using dp[calories] = ways

Process Each Type

For each cookie type, update all possible calorie sums by adding that cookie

Sum Target Range

Add up dp[l] + dp[l+1] + ... + dp[r] for final answer

Key Takeaway

🎯 Key Insight: Instead of generating exponentially many combinations, use DP to count them mathematically. Handle duplicates by frequency, zeros separately, and sum the range [l,r] for the final answer.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18 Apple 15

The optimal approach uses dynamic programming with frequency counting. Instead of generating all sub-multisets (exponential time), we mathematically count them using a DP array where dp[s] represents the number of ways to achieve sum s. Key optimizations include handling zeros separately (they multiply combinations without changing sums) and using knapsack-style transitions for each unique value and its frequency. Time complexity: O(n × r), much better than the brute force O(2^n).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Frequency Map (Optimal)	O(n * r)	O(r)	Use DP with frequency counting and mathematical optimization to count sub-multisets efficiently
Brute Force (Generate All Sub-multisets)	O(2^n)	O(2^n)	Generate all possible sub-multisets and count those with sum in [l, r]

Dynamic Programming with Frequency Map (Optimal) — Algorithm Steps

Count frequency of each unique value, handle zeros separately
Initialize DP array where dp[s] = number of ways to achieve sum s
For each unique non-zero value and its frequency, update DP using knapsack-style transition
Use mathematical formula: new_dp[s] = sum of dp[s-k*val] for k from 0 to min(freq, s//val)
Sum up dp[s] for all s in range [l, r] and multiply by zero factor

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

dp[0] = 1 (one way to make sum 0), all others = 0

Process Value 1

Update dp[1] += dp[0] = 1 (one way to make sum 1)

Process Value 2

Can take 1 or 2 copies of value 2, update multiple dp states

Sum Range [l,r]

Sum dp[l] + dp[l+1] + ... + dp[r] for final answer

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MOD 1000000007
#define MAXR 10005

int countSubMultisets(int* nums, int numsSize, int l, int r) {
    int freq[MAXR] = {0};
    
    // Count frequencies
    for (int i = 0; i < numsSize; i++) {
        freq[nums[i]]++;
    }
    
    // Handle zeros separately
    int zeroCount = freq[0];
    freq[0] = 0;
    
    // DP: dp[s] = number of ways to achieve sum s
    long long dp[MAXR] = {0};
    dp[0] = 1;
    
    // For each unique non-zero value
    for (int val = 1; val <= r; val++) {
        if (freq[val] == 0) continue;
        
        long long newDp[MAXR];
        memcpy(newDp, dp, sizeof(dp));
        
        for (int s = val; s <= r; s++) {
            int maxK = freq[val] < s/val ? freq[val] : s/val;
            for (int k = 1; k <= maxK; k++) {
                newDp[s] = (newDp[s] + dp[s - k * val]) % MOD;
            }
        }
        memcpy(dp, newDp, sizeof(dp));
    }
    
    // Count valid sums in range [l, r]
    long long result = 0;
    for (int s = l; s <= r; s++) {
        result = (result + dp[s]) % MOD;
    }
    
    // Multiply by zero factor
    result = (result * (zeroCount + 1)) % MOD;
    
    return result;
}

int main() {
    int nums[] = {1, 2, 2};
    int l = 1, r = 3;
    printf("%d\n", countSubMultisets(nums, 3, l, r));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * r)

We iterate through unique values (at most n) and for each sum up to r, updating DP states

✓ Linear Growth

Space Complexity

O(r)

DP array of size r+1 to store number of ways for each possible sum

✓ Linear Space

28.4K Views

Medium-High Frequency

~35 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Frequency Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler