The Number of Good Subsets - Practice Coding Problems

The Number of Good Subsets - Problem

Array Hash Table Math Dynamic Programming Bit Manipulation Counting Number Theory Bitmask Hard

The Number of Good Subsets

You're given an integer array nums. Your task is to find all good subsets - subsets whose product can be represented as a product of distinct prime numbers.

What makes a subset "good"?
A subset is good if its product contains each prime factor at most once. In other words, no prime number appears more than once in the prime factorization.

Examples:
• Product = 6 = 2 × 3 ✅ (distinct primes)
• Product = 12 = 2² × 3 ❌ (prime 2 appears twice)
• Product = 30 = 2 × 3 × 5 ✅ (all distinct primes)

Special case: The number 1 can be included in any subset without affecting whether it's good or not.

Return the count of all different good subsets modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Good Subsets

$ Input: nums = [1,2,3,4]

› Output: 6

💡 Note: Good subsets are: [2], [3], [2,3], [1,2], [1,3], [1,2,3]. Each has a product with distinct prime factors. [4] and [1,4] are not good since 4 = 2×2 has repeated prime factor 2.

example_2.py — All Ones

$ Input: nums = [4,2,3,15]

› Output: 5

💡 Note: Good subsets are: [2], [3], [15], [2,3], [15] where 15 = 3×5. Note that [4] is invalid due to repeated prime factor 2.

example_3.py — With Ones

$ Input: nums = [1,1,2]

› Output: 7

💡 Note: Good subsets: [2], [1,2], [1,2] (second occurrence), [1,1,2], [1], [1], [1,1]. The 1s can be combined freely with any other good subset.

Visualization

Tap to expand

Understanding the Visualization

Audition Phase

Count available musicians and reject those who would play the same note twice (numbers with repeated prime factors)

Ensemble Planning

Create a seating chart (bitmask) showing which notes are being played in each arrangement

Performance Counting

Use dynamic programming to count all valid arrangements where no note is repeated

Special Guests

Add the versatile musicians (1s) who can join any performance without changing the harmony

Key Takeaway

🎯 Key Insight: By using bitmask DP with only 10 relevant primes, we reduce the problem from exponential subset enumeration to polynomial state transitions, achieving optimal efficiency while handling the special case of 1s elegantly.

Time & Space Complexity

Time Complexity

⏱️

O(n + 2^p × k)

O(n) to count frequencies, O(2^p × k) for DP where p=10 primes and k≤10 distinct valid numbers

✓ Linear Growth

Space Complexity

O(2^p)

DP array of size 2^10 = 1024 to store states for all prime combinations

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 30
All numbers in nums are in range [1, 30]
Answer should be returned modulo 10⁹ + 7

Asked in

G Google 15 a Amazon 8 f Meta 12 ⊞ Microsoft 6

The optimal solution uses bitmask dynamic programming with frequency counting. Key insights: only numbers ≤ 30 matter, use bitmask to represent prime usage, and handle 1s specially by multiplying the result by 2^{count_of_ones}. Time complexity: O(2^p × k) where p=10 primes and k≤10 valid numbers.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsets)	O(2^n × k)	O(1)	Generate all possible subsets and check if each one is good
Dynamic Programming with Bitmask (Optimal)	O(n + 2^p × k)	O(2^p)	Use frequency counting and bitmask DP to efficiently count good subsets

Brute Force (Generate All Subsets) — Algorithm Steps

Generate all possible subsets using bit manipulation (2^n subsets)
For each subset, calculate the product of all elements
Check if the product has only distinct prime factors
Count valid subsets and return the result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Use bitmask to generate all 2^n possible subsets

Calculate Product

For each subset, multiply all elements together

Check Prime Factors

Verify if product has only distinct prime factors

Count Valid Subsets

Increment counter for each good subset found

Code -

solution.c — C

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

#define MOD 1000000007

bool getPrimeFactors(long long n, int* factors, int* count) {
    *count = 0;
    for (int d = 2; d * d <= n; d++) {
        while (n % d == 0) {
            // Check if prime already exists
            for (int i = 0; i < *count; i++) {
                if (factors[i] == d) {
                    return false; // Repeated prime factor
                }
            }
            factors[(*count)++] = d;
            n /= d;
        }
    }
    if (n > 1) {
        factors[(*count)++] = (int)n;
    }
    return true;
}

bool isGoodProduct(int* subset, int size) {
    long long product = 1;
    for (int i = 0; i < size; i++) {
        product *= subset[i];
    }
    int factors[32];
    int count;
    return getPrimeFactors(product, factors, &count);
}

int numberOfGoodSubsets(int* nums, int numsSize) {
    int count = 0;
    int* subset = (int*)malloc(numsSize * sizeof(int));
    
    // Generate all possible non-empty subsets
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int subsetSize = 0;
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subset[subsetSize++] = nums[i];
            }
        }
        
        if (isGoodProduct(subset, subsetSize)) {
            count = (count + 1) % MOD;
        }
    }
    
    free(subset);
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × k)

2^n subsets, each taking O(k) time to validate where k is average subset size

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 30
All numbers in nums are in range [1, 30]
Answer should be returned modulo 10⁹ + 7

26.4K Views

Medium 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Subsets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler