LeetCode 1994. 好子集的数目题解

1994. 好子集的数目题解

题目来源：1994. 好子集的数目

2022.02.22 每日一题

每日一题专栏地址：LeetCode 每日一题题解更新中❤️💕

今天是一道困难题目，乍一看题目，觉得没什么思路

那就一起逐步分析分析吧

给定一个数组nums，找到nums中是好子集的子集有多少个

好子集：子集中所有元素的乘积可以由一个或多个不相同的质数相乘得到

那我们就可以分析一下，这个好子集中的元素的乘积可以由质数相乘得到，说明这个好子集之中要么不包含质数、要么包含的质数也可以由不相同的质数相乘得到

那么我们来统计一下，在本题的数据范围里(1 <= nums[i] <= 30)，有多少符合条件的数

第一组：1 不是质数，但是可以与满足条件的好子集进行组队
1
第二组：纯质数
2, 3, 5, 7, 11, 13, 17, 19, 23, 29
第三组：可以由不同质数相乘得到的数
6, 10, 14, 15, 21, 22, 26, 30

可以发现一共有18 + 1个

那么思路就出来了，我们可以使用动态规划进行求解

class Solution {
public:
    // 创建 mod 用来取余
    int mod = 1e9 + 7;
    // 声明质数数组
    vector<int> prime = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};

    int numberOfGoodSubsets(vector<int> nums) {
        // 声明结果变量统计最后的答案
        long long res = 0;
        // 因为一共有 10 个质数，用二进制表示，一共有 1024 种方式
        vector<long long> dp(1025);
        // dp数组初始化
        dp[0] = 1;
        // 本题的数据范围 1 <= nums[i] <= 30 
        // 因此最大为 30 
        vector<int> count(31);
        // 统计 nums 中各个数字的个数
        for (int num: nums) 
            count[num]++;
        // 遍历nums中除 1 以外的每一个数
        // 因为 
        for (int num = 2; num <= 30; ++num) {
            // 当前数不存在，当前数带有平方数 跳过
            // 排除掉不满足的数字
            if (count[num] == 0 || num % 4 == 0 || num % 9 == 0 || num % 25 == 0)
                continue;

            // 对10个质数做处理，如果当前数能被质数整除，则记录进maskForNum
            int maskForNum = 0;
            for (int i = 0; i < 10; ++i)
                // 对每个质数进行与或运算，统计出现的频率
                if (num % prime[i] == 0) 
                    maskForNum |= (1 << i);            

            // 遍历每一种状态
            for (int state = 0; state < 1024; ++state) {
                // maskForNum中已经存在了其中一个质数，跳过
                if ((maskForNum & state) > 0) continue;
                //这里可能会溢出，所以dp数组类型为long
                // 更新当前状态的的好子集个数
                dp[maskForNum | state] =
                        (dp[maskForNum | state] + ((count[num] % mod) * (dp[state] % mod) % mod)) % mod;              
            }
        }
        // dp[0]不算进去
        for (int i = 1; i < 1024; ++i) res = (res + dp[i]) % mod;
        // 有多少个1，最后的结果就乘以2的多少次方
        for (int i = 0; i < count[1]; ++i) res = (res * 2) % mod;
        return (int) res;
    }
};

class Solution {

    // 创建 mod 用来取余
    int mod = 1000000007;

    // 声明质数数组
    int[] prime = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};

    public int numberOfGoodSubsets(int[] nums) {
        // 声明结果变量统计最后的答案
        long res = 0;
        // 因为一共有 10 个质数，用二进制表示，一共有 1024 种方式
        long[] dp = new long[1025];
        // dp数组初始化
        dp[0] = 1;
        // 本题的数据范围 1 <= nums[i] <= 30 
        // 因此最大为 30 
        int[] count = new int[31];
        // 统计 nums 中各个数字的个数
        for (int num : nums)
            count[num]++;
        // 遍历nums中除 1 以外的每一个数
        // 因为 
        for (int num = 2; num <= 30; ++num) {
            // 当前数不存在，当前数带有平方数 跳过
            // 排除掉不满足的数字
            if (count[num] == 0 || num % 4 == 0 || num % 9 == 0 || num % 25 == 0) continue;

            // 对10个质数做处理，如果当前数能被质数整除，则记录进maskForNum
            int maskForNum = 0;
            for (int i = 0; i < 10; ++i)
                // 对每个质数进行与或运算，统计出现的频率
                if (num % prime[i] == 0) maskForNum |= (1 << i);

            // 遍历每一种状态
            for (int state = 0; state < 1024; ++state) {
                // maskForNum中已经存在了其中一个质数，跳过
                if ((maskForNum & state) > 0) continue;
                //这里可能会溢出，所以dp数组类型为long
                // 更新当前状态的的好子集个数
                dp[maskForNum | state] = (dp[maskForNum | state] + ((count[num] % mod) * (dp[state] % mod) % mod)) % mod;
            }
        }
        // dp[0]不算进去
        for (int i = 1; i < 1024; ++i) res = (res + dp[i]) % mod;
        // 有多少个1，最后的结果就乘以2的多少次方
        for (int i = 0; i < count[1]; ++i) res = (res * 2) % mod;
        return (int) res;
    }
}

结语：

我的思路只想到了代码之前，这道题目的状态转移方程我没有想到，

感谢 livorth 的【1994. 好子集的数目】状态压缩动态规划较详细的思路

看完大佬的题解，整理了一下代码以及注释，主要的思路来自于大佬