Count the Number of Square-Free Subsets - Problem

You are given a positive integer 0-indexed array nums.

A subset of the array nums is square-free if the product of its elements is a square-free integer.

A square-free integer is an integer that is divisible by no square number other than 1.

Return the number of square-free non-empty subsets of the array nums. Since the answer may be too large, return it modulo 10^9 + 7.

A non-empty subset of nums is an array that can be obtained by deleting some (possibly none but not 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 = [3,4,4,5]

› Output: 3

💡 Note: Square-free subsets are [3], [4], [5]. Note that [4,4] has product 16 = 4², so it's not square-free. [3,4], [3,5], [4,5] would work but [3,4,4] and others with 4,4 don't.

Example 2 — All Valid

$ Input: nums = [1]

› Output: 1

💡 Note: Only subset is [1], and 1 is square-free (no square factors other than 1).

Example 3 — Prime Numbers

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

› Output: 7

💡 Note: All 7 non-empty subsets work: [2], [3], [5], [2,3], [2,5], [3,5], [2,3,5]. Products are 2,3,5,6,10,15,30 - all square-free.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is representing each number by its prime factors as a bitmask - a square-free subset means no prime factor appears more than once across all numbers. Best approach uses Dynamic Programming with bitmasks to count valid combinations efficiently. Time: O(n × 2^k), Space: O(2^k) where k ≤ 10.

Common Approaches

✓ Brute Force

⏱️ Time: O(2^n × √max_product) Space: O(1)

Generate all 2^n possible subsets, calculate the product of each subset, and check if the product is square-free by testing divisibility by perfect squares.

Dynamic Programming with Prime Factorization

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

First, represent each number by its prime factors as a bitmask. Then use dynamic programming where dp[mask] represents the count of subsets with prime factor combination 'mask'.

Recursive Memoization

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

Define a recursive function that tries including/excluding each number while maintaining the current prime factor state. Use memoization to avoid recalculating the same states.

Brute Force — Algorithm Steps

Generate all 2^n subsets using bit manipulation
For each subset, calculate the product of elements
Check if product is square-free by testing divisibility by squares 4, 9, 16, 25...

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Use bit manipulation to create all 2^n subsets

Calculate Product

Multiply elements in each subset

Check Square-Free

Test if product has square factors

Code -

solution.c — C

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

bool isSquareFree(long long num) {
    if (num <= 1) return true;
    for (long long i = 2; i * i <= num; i++) {
        if (num % (i * i) == 0) {
            return false;
        }
    }
    return true;
}

int solution(int* nums, int numsSize) {
    const int MOD = 1000000007;
    int count = 0;
    
    // Generate all non-empty subsets
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        long long product = 1;
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                product *= nums[i];
            }
        }
        
        if (isSquareFree(product)) {
            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);
    
    // Parse JSON array manually
    int nums[20];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]"); // Skip '['
    
    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 × √max_product)

Generate 2^n subsets, each requiring square-free check up to √max_product

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for calculation, no extra data structures

✓ Linear Space

12.0K Views

Medium Frequency

~35 min Avg. Time

456 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

Count the Number of Square-Free Subsets - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler