Count the Number of Square-Free Subsets | HARD LEETCODE PROBLEM | MATHY | OA

https://leetcode.com/problems/count-the-number-of-square-free-subsets/

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 109 + 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.



Example 1:

Input: nums = [3,4,4,5]
Output: 3
Explanation: There are 3 square-free subsets in this example:
- The subset consisting of the 0th element [3]. The product of its elements is 3, which is a square-free integer.
- The subset consisting of the 3rd element [5]. The product of its elements is 5, which is a square-free integer.
- The subset consisting of 0th and 3rd elements [3,5]. The product of its elements is 15, which is a square-free integer.
It can be proven that there are no more than 3 square-free subsets in the given array.
Example 2:

Input: nums = [1]
Output: 1
Explanation: There is 1 square-free subset in this example:
- The subset consisting of the 0th element [1]. The product of its elements is 1, which is a square-free integer.
It can be proven that there is no more than 1 square-free subset in the given array.


Constraints:

1 <= nums.length <= 1000
1 <= nums[i] <= 30


EXPLAINATION LINK -> https://leetcode.com/problems/count-the-number-of-square-free-subsets/discuss/3210623/C%2B%2B-or-KnapSack-or-DP-or-Recursive-Memo-or-Beginners-Friendly-or-Explained
-----------------------------------------------------------------------------------------------------------------------------------


class Solution {
public:
    long long dp[1<<11][1001];

    unordered_map<int,int> hash;  // the numbers are mapped to reduce bit count

    int primeFactorisation_MASK(int num){
        int mask=0;

        if(num%2==0){
            mask|=(1<<hash[2]);
            num/=2;
        }
        for(int i=3;i<=sqrt(num);i+=2){
            while(num%i==0){
                mask|=(1<<hash[i]);
                num=num/i;
            }
        }
        if(num>2){
            mask|=(1<<hash[num]);
        }

        return mask;
    }

    long long helper(int mask, int curr, vector<int> &masks){
        if(curr==masks.size()){
            return 1;
        }
        if(dp[mask][curr]!=-1){
            return dp[mask][curr];
        }

        int ACCEPT=0;
        if((masks[curr] & mask)==0){ // checking that there is no common set bit in both masks cuz that will lead to a square number
            ACCEPT=helper(masks[curr] | mask,curr+1,masks);
        }

        int IGNORE=helper(mask,curr+1,masks);

        return dp[mask][curr]=(ACCEPT+IGNORE)%1000000007;
    }

    int squareFreeSubsets(vector<int>& nums) {
        int primeFactors[]={1,2,3,5,7,11,13,17,19,23,29}; // these numbers make up the prime factorizations from 1-30

        for(int i=0;i<11;i++){ // mapping squareFreePrimes to smaller bit places
            hash[primeFactors[i]]=i;
        }

        vector<int> masks;
        for(auto x: nums){
            if(x==4 ||  x==8 || x==9 || x==12 || x==16 || x==18 || x==20 || x==24 || x==25 || x==27 || x==28){ // number having more than 1 duplicate primes leading to a square number
                continue;
            }

            int mask=primeFactorisation_MASK(x);
            masks.push_back(mask);
        }

        memset(dp,-1,sizeof(dp));
        return helper(0,0,masks)-1;
    }
};