The Number of Good Subsets

The Number of Good Subsets - Problem

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

You are given an integer array nums. We call a subset of nums good if its product can be represented as a product of one or more distinct prime numbers.

For example, if nums = [1, 2, 3, 4]:

[2, 3], [1, 2, 3], and [1, 3] are good subsets with products 6 = 2*3, 6 = 2*3, and 3 = 3 respectively.
[1, 4] and [4] are not good subsets with products 4 = 2*2 and 4 = 2*2 respectively.

Return the number of different good subsets in nums modulo 10⁹ + 7.

A subset of nums is any array that can be obtained by deleting some (possibly none or all) elements from nums. Two subsets are different if and only if the chosen indices to delete are different.

Input & Output

Example 1 — Basic Case

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

› Output: 6

💡 Note: Good subsets: [2], [3], [1,2], [1,3], [2,3], [1,2,3]. The subsets [4], [1,4], [2,4], [3,4], [1,2,4], [1,3,4], [2,3,4], [1,2,3,4] are not good because 4 = 2² contains repeated prime factor 2.

Example 2 — Only Prime Numbers

$ Input: nums = [2,3,5]

› Output: 7

💡 Note: All non-empty subsets are good: [2], [3], [5], [2,3], [2,5], [3,5], [2,3,5]. Each contains only distinct prime factors.

Example 3 — Contains Invalid Numbers

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

› Output: 3

💡 Note: Good subsets: [2], [1,2], [1]. Number 4 = 2² cannot be in any good subset due to repeated prime factor.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 30

Visualization

Tap to expand

Asked in

M Meta 3 G Google 2

The key insight is that only numbers ≤ 30 with distinct prime factors matter, and we can use bitmask DP to efficiently track which primes are used. Best approach uses bitmask dynamic programming with Time: O(n + 2¹⁰), Space: O(2¹⁰).

Common Approaches

✓ Brute Force - Generate All Subsets

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

Generate every possible subset, calculate its product, and check if the product can be expressed as distinct prime factors. This involves checking if any prime appears more than once.

Dynamic Programming with Bitmask

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

Key insight: only numbers ≤ 30 with distinct prime factors can form good subsets. Use bitmask to represent which primes (2,3,5,7,11,13,17,19,23,29) are used, and count frequency of each valid number.

Brute Force - Generate All Subsets — Algorithm Steps

Generate all 2^n possible subsets
For each subset, calculate product
Check if product has only distinct prime factors
Count valid subsets

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible combinations

Check Prime Factors

Verify each subset has distinct prime factors

Count Valid

Count subsets with no repeated primes

Code -

solution.c — C

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

void getPrimeFactors(int num, int* factors, int* factorCount) {
    *factorCount = 0;
    if (num == 1) return;
    
    for (int d = 2; d * d <= num; d++) {
        while (num % d == 0) {
            factors[(*factorCount)++] = d;
            num /= d;
        }
    }
    if (num > 1) {
        factors[(*factorCount)++] = num;
    }
}

bool hasDistinctPrimes(int* factors, int count) {
    for (int i = 0; i < count; i++) {
        for (int j = i + 1; j < count; j++) {
            if (factors[i] == factors[j]) return false;
        }
    }
    return true;
}

int solution(int* nums, int numsSize) {
    const int MOD = 1000000007;
    int count = 0;
    
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int allFactors[1000];
        int totalFactors = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                int factors[100];
                int factorCount;
                getPrimeFactors(nums[i], factors, &factorCount);
                
                for (int j = 0; j < factorCount; j++) {
                    allFactors[totalFactors++] = factors[j];
                }
            }
        }
        
        if (hasDistinctPrimes(allFactors, totalFactors)) {
            count = (count + 1) % MOD;
        }
    }
    
    return count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    
    char* ptr = strchr(line, '[');
    ptr++;
    
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × k)

Generate 2^n subsets, each requiring O(k) time for prime factorization

⚠ Quadratic Growth

Space Complexity

O(k)

Space for storing prime factors and current subset

✓ Linear Space

28.0K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate All Subsets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler