Leetcode 1994. 好子集的数目

连接：1994. 好子集的数目

给你一个整数数组 nums 。如果 nums 的一个子集中，所有元素的乘积可以表示为一个或多个 互不相同的质数 的乘积，那么我们称它为 好子集 。

比方说，如果 nums = [1, 2, 3, 4] ：
[2, 3] ，[1, 2, 3] 和 [1, 3] 是 好 子集，乘积分别为 6 = 2*3 ，6 = 2*3 和 3 = 3 。
[1, 4] 和 [4] 不是 好 子集，因为乘积分别为 4 = 2*2 和 4 = 2*2 。
请你返回 nums 中不同的 好 子集的数目对 109 + 7 取余 的结果。

nums 中的 子集 是通过删除 nums 中一些（可能一个都不删除，也可能全部都删除）元素后剩余元素组成的数组。如果两个子集删除的下标不同，那么它们被视为不同的子集。

输入：nums = [1,2,3,4]
输出：6
解释：好子集为：
- [1,2]：乘积为 2 ，可以表示为质数 2 的乘积。
- [1,2,3]：乘积为 6 ，可以表示为互不相同的质数 2 和 3 的乘积。
- [1,3]：乘积为 3 ，可以表示为质数 3 的乘积。
- [2]：乘积为 2 ，可以表示为质数 2 的乘积。
- [2,3]：乘积为 6 ，可以表示为互不相同的质数 2 和 3 的乘积。
- [3]：乘积为 3 ，可以表示为质数 3 的乘积。

提示：

• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 30

题解：

常规思路

我们直接搜索枚举哪些数字被挑选出来，然后检查这些数字乘积能否分解成不同质数的乘积，但是数据量是10^5, 搜索肯定要超时的。

动态规划

我们定义一个二维数组，dp[len][max], len 等于 nums 总数量， max 等于各个质数的乘积，dp[i][j] 表示第0个数字到第i个数字，乘积为j 的方案总数。

那么我们的动态转移方程

dp[i][j] -> dp[i-1][j](不使用当前数字) + dp[i-1][x1](使用当前数字) + ... + dp[i-1][xn](使用当前数字)

其中 xn * nums[i] == j, 且 j 等于不同的质数的乘积

由于max这个值很大，最大2*3*5...*23*29, 所以此方案需要优化

状态压缩

首先30以下的质数总共有10个，分别是 2, 3, 5, 7, 11, 13, 17, 19, 23, 29

然后对于一个好子集[num1,num2,....numx], num1 * num2 * ... *numx = 质数1 * 质数2 * ... * 质数y

对于好子集值的乘积，相当于从这10个质数里面选一些出来，那么这个选质数方法有多少种呢，就用到了排列组合了，总数是 2^10  - 1 (1023),那么好子集值的乘积有1023种。

 那么将这些质数做一个编码，用十位二进制表示，每个质数使用二进制的以为

2------>0000000001

3------>0000000010

....

29---->1000000000

对于质数的乘积也需要做编码，比如 2 * 3 = 6， 6----->0000000011,  这个二进制 0000000011 可以理解为这个乘积使用了第一个质数（0000000001），第二个质数（0000000010）。

我们重新定义一下二维数组，dp[len][1024], len 等于 nums 总数量，dp[i][j] 表示第0个数字到第i个数字，好子集乘积编码为j 的方案总数。

那么我们的动态转移方程

dp[i][j] -> dp[i-1][j](不使用当前数字) + dp[i-1][x1](使用当前数字) + ... + dp[i-1][xn](使用当前数字)

其中 xn & 编码（nums[i]） == 0, 因为乘积中不能出现相同的质数

压缩之后动态规划代码

#define mod 1000000007
class Solution {
public:
    int numberOfGoodSubsets(vector<int>& nums) {
        vector<vector<long long>> dp(nums.size()+1, vector<long long>(1024));
        unordered_map<int, int> mapCode;
        //先从大到小排序
        sort(nums.begin(), nums.end(), [](const int& l1 , const int& l2){return l1 > l2;});
        initNumCode(mapCode);
        
        for(int i = 0; i < nums.size(); ++i){

            for(int j = 0; j < 1024; ++j)
                dp[i+1][j] += dp[i][j];
            //对于1 需要特殊判断，因为任何有效的乘积，乘以1都是有效的
            if(nums[i] == 1){
                for(int j = 0; j < 1024; ++j){
                    dp[i+1][j] += dp[i][j];
                    dp[i+1][j] %= mod;
                }
            }
            //对于已经有编码的数字才能使用
            else if(mapCode.count(nums[i])){
                //单独使用当前数字
                dp[i+1][mapCode[nums[i]]]++;
                
                for(int j = 0; j < 1024; ++j){
                    if((j & mapCode[nums[i]]) == 0)
                        dp[i+1][j ^ mapCode[nums[i]]] += dp[i][j];
                    dp[i+1][j ^ mapCode[nums[i]]] %= mod;
                }
            }
        }
        long long ans = 0;
        for(int i = 0; i < 1024; ++i)
            ans += dp[nums.size()][i];

        ans %= mod;
            
        return ans;
    }
    void initNumCode(unordered_map<int, int>& mapCode){
        //对于4,8 这种不编码，因为不能使用这样的数字
        mapCode[2] = 1;
        mapCode[3] = 2;
        mapCode[5] = 4;
        mapCode[6] = 3;
        mapCode[7] = 8;
        mapCode[10] = 5;
        mapCode[11] = 16;
        mapCode[13] = 32;
        mapCode[14] = 9;
        mapCode[15] = 6;
        mapCode[17] = 64;
        mapCode[19] = 128;
        mapCode[21] = 10;
        mapCode[22] = 17;
        mapCode[23] = 256;
        mapCode[26] = 33;
        mapCode[29] = 512;
        mapCode[30] = 7;
    }
};

此时我们的时间复杂度是 nums.size() * 1024, 已经10^8,肯定是会超时的。我们还需要优化。

因为数字只有1到30，我们统计每个数字出现的次数，然后用相同转移方式优化，时间复杂度变为 30 * 1024.

#define mod 1000000007
class Solution {
public:
    int numberOfGoodSubsets(vector<int>& nums) {
        unordered_map<int, int> mapCode;
        map<int,int> mapNums;

        initNumCode(mapCode);
        
        for(auto item : nums)
            mapNums[item]++;
        
        
        vector<int> nums2;
        for(int i = 30; i >= 1; --i){
            if(mapNums[i])
                nums2.push_back(i);
        }

        vector<vector<long long>> dp(nums2.size()+1, vector<long long>(1024));
        
        for(int i = 0; i < nums2.size(); ++i){
            for(int j = 0; j < 1024; ++j)
                dp[i+1][j] += dp[i][j];

            if(nums2[i] == 1){
                //从x个1中选出一部分1的方法数是 2^x - 1, 使用快速幂计算2^x
                long long tmp = pow_quick(mapNums[nums2[i]]) - 1;
                for(int j = 0; j < 1024; ++j){
                    dp[i+1][j] += tmp * dp[i][j];
                    dp[i+1][j] %= mod;
                }
            }
            else if(mapCode.count(nums2[i])){
                dp[i+1][mapCode[nums2[i]]] += mapNums[nums2[i]];
                
                for(int j = 0; j < 1024; ++j){
                    if(!(j & mapCode[nums2[i]])){
                        dp[i+1][j ^ mapCode[nums2[i]]] += mapNums[nums2[i]] * dp[i][j];
                        dp[i+1][j ^ mapCode[nums2[i]]] %= mod;
                    }
                }
            }
        }
        long long ans = 0;
        for(int i = 0; i < 1024; ++i)
            ans += dp[nums2.size()][i];
        ans %= mod;
            
        return ans;
    }
    long long pow_quick(int num){
        long long ans = 1;
        long long base = 2;
        while(num){
            if(num % 2){
                ans *= base;
                ans %= mod;
            }
            base *= base;
            base %= mod;
            num = num / 2;
        }
        return ans;
    }
    void initNumCode(unordered_map<int, int>& mapCode){
        //因为30以下的质数只有10个  2, 3, 5, 7, 11, 13, 17, 19, 23, 29
        mapCode[2] = 1;
        mapCode[3] = 2;
        mapCode[5] = 4;
        mapCode[6] = 3;
        mapCode[7] = 8;
        mapCode[10] = 5;
        mapCode[11] = 16;
        mapCode[13] = 32;
        mapCode[14] = 9;
        mapCode[15] = 6;
        mapCode[17] = 64;
        mapCode[19] = 128;
        mapCode[21] = 10;
        mapCode[22] = 17;
        mapCode[23] = 256;
        mapCode[26] = 33;
        mapCode[29] = 512;
        mapCode[30] = 7;
    }
};