Count of Sub-Multisets With Bounded Sum

Count of Sub-Multisets With Bounded Sum - Problem

You are given a 0-indexed array nums of non-negative integers, and two integers l and r.

Return the count of sub-multisets within nums where the sum of elements in each subset falls within the inclusive range of [l, r].

Since the answer may be large, return it modulo 10^9 + 7.

A sub-multiset is an unordered collection of elements of the array in which a given value x can occur 0, 1, ..., occ[x] times, where occ[x] is the number of occurrences of x in the array.

Note that:

Two sub-multisets are the same if sorting both sub-multisets results in identical multisets.
The sum of an empty multiset is 0.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Valid sub-multisets: [1] (sum=1), [2] (sum=2), [1,2] (sum=3), [2,2] (sum=4). All sums are in range [1,4].

Example 2 — With Zeros

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

› Output: 4

💡 Note: Valid sub-multisets: [1] (sum=1), [2] (sum=2), [1,2] (sum=3), [0,1,2] (sum=3). The zero can be included or excluded.

Example 3 — No Valid Sums

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

› Output: 0

💡 Note: Maximum possible sum is 1+2+3=6, which is less than l=10. No valid sub-multisets exist.

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
0 ≤ nums[i] ≤ 2 × 10⁴
1 ≤ l ≤ r ≤ 2.5 × 10⁴

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is to use dynamic programming with frequency counting to avoid generating duplicate sub-multisets. Count frequency of each unique element, then use DP where dp[sum] represents ways to achieve that sum. Handle zeros separately for optimization. Best approach is optimized DP. Time: O(n × r), Space: O(r)

Common Approaches

✓ One Pass Hash

⏱️ Time: N/A Space: N/A

Brute Force with Backtracking

⏱️ Time: O(2^n) Space: O(n)

Use recursive backtracking to generate every possible sub-multiset by deciding how many times to include each unique element (from 0 to its frequency). Check if the sum falls within the given range.

Dynamic Programming with Frequency Count

⏱️ Time: O(n × r) Space: O(r)

First count the frequency of each unique number. Then use dynamic programming where dp[sum] represents the number of ways to achieve that sum. For each unique number, update the DP array considering all possible counts of that number.

Optimized DP with Space Reduction

⏱️ Time: O(n × r) Space: O(r)

Improve the frequency-based DP approach by using space-efficient techniques, processing zeros separately, and implementing early termination when sums exceed the range. This reduces both time and space complexity in practice.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define HASH_SIZE 1000007

typedef struct Edge {
    int to, charBit;
    struct Edge* next;
} Edge;

typedef struct HashNode {
    int mask, count;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];
long long result = 0;

int hashFunc(int mask) {
    return ((long long)mask * 1000000007LL) % HASH_SIZE;
}

void insertHash(int mask, int count) {
    int idx = hashFunc(mask);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    node->mask = mask; node->count = count; node->next = hashTable[idx];
    hashTable[idx] = node;
}

int getHash(int mask) {
    int idx = hashFunc(mask);
    for (HashNode* node = hashTable[idx]; node; node = node->next) {
        if (node->mask == mask) return node->count;
    }
    return 0;
}

void updateHash(int mask, int delta) {
    int idx = hashFunc(mask);
    for (HashNode* node = hashTable[idx]; node; node = node->next) {
        if (node->mask == mask) {
            node->count += delta;
            return;
        }
    }
    insertHash(mask, delta);
}

void dfs(int node, int parentNode, int currentMask, Edge** adj) {
    result += getHash(currentMask);
    
    for (int i = 0; i < 26; i++) {
        int complementMask = currentMask ^ (1 << i);
        result += getHash(complementMask);
    }
    
    updateHash(currentMask, 1);
    
    for (Edge* e = adj[node]; e; e = e->next) {
        if (e->to != parentNode) {
            int newMask = currentMask ^ (1 << e->charBit);
            dfs(e->to, node, newMask, adj);
        }
    }
}

long long countPalindromePaths(int* parent, int parentSize, char* s) {
    int n = parentSize;
    Edge** adj = (Edge**)calloc(n, sizeof(Edge*));
    memset(hashTable, 0, sizeof(hashTable));
    result = 0;
    
    for (int i = 1; i < n; i++) {
        int charBit = s[i] - 'a';
        Edge* e1 = (Edge*)malloc(sizeof(Edge));
        e1->to = i; e1->charBit = charBit; e1->next = adj[parent[i]];
        adj[parent[i]] = e1;
        
        Edge* e2 = (Edge*)malloc(sizeof(Edge));
        e2->to = parent[i]; e2->charBit = charBit; e2->next = adj[i];
        adj[i] = e2;
    }
    
    updateHash(0, 1);
    dfs(0, -1, 0, adj);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

245 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