Count the Number of Square-Free Subsets - Practice Coding Problems

Count the Number of Square-Free Subsets - Problem

Given a positive integer array nums, you need to find all square-free subsets and count them.

A subset is square-free if the product of its elements is a square-free integer. A square-free integer is one that isn't divisible by any perfect square greater than 1 (like 4, 9, 16, 25, etc.).

Example: If nums = [3, 4, 4, 5], the subset [3, 5] is square-free because 3 × 5 = 15, and 15 isn't divisible by any perfect square > 1. However, [4, 4] isn't square-free because 4 × 4 = 16 = 4².

Return the count of all non-empty square-free subsets modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: [3, 4, 4, 5]

› Output: 3

💡 Note: Square-free subsets are [3], [5], and [3,5]. The subset [4] has product 4 = 2², [4,4] has product 16 = 4², [3,4] has product 12 = 4×3, and [4,5] has product 20 = 4×5, all containing square factors.

example_2.py — With Ones

$ Input: [1, 2, 3]

› Output: 6

💡 Note: All possible non-empty subsets are square-free: [1], [2], [3], [1,2], [1,3], [2,3], [1,2,3]. The number 1 can be combined with any other square-free subset.

example_3.py — Only Perfect Squares

$ Input: [4, 9, 16]

› Output: 0

💡 Note: All numbers are perfect squares (4=2², 9=3², 16=4²), so no subset can be square-free except the empty set, which is not counted.

Visualization

Tap to expand

Understanding the Visualization

Extract Prime Factors

Convert each number to a bitmask representing its unique prime factors

Initialize DP

dp[mask] represents the number of ways to achieve prime factor combination 'mask'

Process Each Number

For each valid number, combine it with existing compatible states

Handle Special Cases

Process 1's separately as they can combine with any square-free subset

Calculate Final Result

Sum all non-empty states and account for subsets containing only 1's

Key Takeaway

🎯 Key Insight: By representing each number as a bitmask of its prime factors, we can use bitwise operations to quickly determine if two numbers can coexist in a square-free subset (no overlapping bits = no repeated prime factors).

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^k)

n elements, 2^k possible prime factor combinations where k ≤ 10

✓ Linear Growth

Space Complexity

O(2^k)

DP table storing counts for each prime factor bitmask

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
Time limit: 2 seconds
Memory limit: 256 MB

Asked in

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

The optimal solution uses dynamic programming with bitmasks to represent prime factor combinations. Convert each number to a bitmask of its prime factors (≤30), then use DP to count subsets where no prime appears twice. Handle the special case of 1's separately since they can combine with any square-free subset. Time complexity: O(n × 2^k) where k ≤ 10 is the number of relevant primes.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask	O(n × 2^k)	O(2^k)	Use DP with prime factor bitmasks to efficiently count square-free subsets

Dynamic Programming with Bitmask — Algorithm Steps

Identify all prime factors ≤ 30 (since numbers ≤ 1000)
Convert each valid number to a bitmask of its prime factors
Use DP where dp[mask] = number of ways to achieve prime factor set 'mask'
For each number, update DP table by combining with existing states
Sum all non-zero DP states to get the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Masks

Each number becomes a bitmask of its prime factors

DP States

dp[mask] = ways to achieve this prime factor combination

Update States

For each number, combine with compatible existing states

Count Results

Sum all non-empty states for final answer

Code -

solution.c — C

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

const int MOD = 1000000007;
const int primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
const int PRIME_COUNT = 10;

int getPrimeMask(int num) {
    int mask = 0;
    for (int i = 0; i < PRIME_COUNT; i++) {
        int p = primes[i];
        if (num % (p * p) == 0) return -1;
        if (num % p == 0) mask |= 1 << i;
    }
    return mask;
}

int squareFreeSubsets(int* nums, int n) {
    int masks[1000], maskCount = 0;
    int onesCount = 0;
    
    for (int i = 0; i < n; i++) {
        if (nums[i] == 1) {
            onesCount++;
        } else {
            int mask = getPrimeMask(nums[i]);
            if (mask != -1) masks[maskCount++] = mask;
        }
    }
    
    if (maskCount == 0) {
        return onesCount > 0 ? ((long long)pow(2, onesCount) - 1) % MOD : 0;
    }
    
    long long dp[1 << 10] = {0};
    dp[0] = 1;
    
    for (int i = 0; i < maskCount; i++) {
        long long newDp[1 << 10];
        for (int j = 0; j < (1 << 10); j++) newDp[j] = dp[j];
        
        for (int state = 0; state < (1 << 10); state++) {
            if (dp[state] > 0 && (state & masks[i]) == 0) {
                newDp[state | masks[i]] = (newDp[state | masks[i]] + dp[state]) % MOD;
            }
        }
        
        for (int j = 0; j < (1 << 10); j++) dp[j] = newDp[j];
    }
    
    long long result = 0;
    for (int i = 0; i < (1 << 10); i++) result = (result + dp[i]) % MOD;
    result = (result - 1 + MOD) % MOD;
    
    result = (result * (long long)pow(2, onesCount)) % MOD;
    if (onesCount > 0) {
        result = (result + (long long)pow(2, onesCount) - 1) % MOD;
    }
    
    return result;
}

int main() {
    int nums[1000], n = 0;
    char c;
    
    scanf("%c", &c); // Skip '['
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", squareFreeSubsets(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^k)

n elements, 2^k possible prime factor combinations where k ≤ 10

✓ Linear Growth

Space Complexity

O(2^k)

DP table storing counts for each prime factor bitmask

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
Time limit: 2 seconds
Memory limit: 256 MB

28.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Dynamic Programming with Bitmask — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler