LeetCode-1994 好子集的数目

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/the-number-of-good-subsets

题目描述

给你一个整数数组 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 中一些（可能一个都不删除，也可能全部都删除）元素后剩余元素组成的数组。如果两个子集删除的下标不同，那么它们被视为不同的子集。

示例 1：

输入：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 的乘积。

示例 2：

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

提示：

1 <= nums.length <= 10⁵
1 <= nums[i] <= 30

解题思路

这道题是十分之难的一道综合题，啃了足足一天才完全搞懂。

首先根据提示，数据样本很多，暴力枚举肯定行不通。但是注意到一个很有意思的地方，数据样本中的数量很多，但是样本数据仅仅是1-30，这就是突破口。

首先可以得知，任何数乘1都为任何数，所以1是在好子集中仅存在有或没有两种状态。而1-30中的除1以外的质数为2，3，5，7，11，13，17，19，23，29.如果想要成为一个好的子集，那么就需要子集中因数只有这些质数并且质数出现的次数仅为一次。那么我们可以使用一个int的低10位来记录这十个质数的是否在子集中出现。

由于样本数量十分大，但是实际上有许多重复的数据，所以可以使用计数的方法，将相同的数字使用一个vector统计出来，我这里使用了viCount,数组下标表示数字的值，数组的值代表出现的次数。

使用动态规划的方法来解决这个问题。建立一个dp[i][j] 表，i代表使用0-i之间的数构成子集，j是记录十个质数使用情况的int，状态转移式子分情况讨论:

如果i本身具有相同的质数，那么dp[i][j] = dp[i - 1][j];

如果i本身不具有相同的质数，那么dp[i][j] = dp[i -1][j] + dp[i -1][j ^ iFlag] * viCount[i] ;

其中iFlag是i所具有的质数状态，由于需要在子集中加入i，所以之前子集的元素不能出现i中的质数，即dp[i -1][j ^ iFlag]。

由于各个i中几乎不存在相关的联系，而j ^ iFlag  并且 j & iFlag肯定比 j 小，所以可以使用一维数组来压缩二维dp。

注意样本很大，所以运算后要及时取模。

代码展示

class Solution {
public:
    int iNumMax = 30;
    int iMod = 1000000007;
    vector<int> viPrimes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
    int numberOfGoodSubsets(vector<int>& nums) {
        vector<int> viCount(iNumMax + 1, 0);
        vector<int> dp(1 << viPrimes.size());
        for(auto num:nums)
        {
            viCount[num]++;
        }

        dp[0] = 1;
        for(int i = 0; i < viCount[1]; i++)
        {
            dp[0] = dp[0] * 2 % iMod;
        }

        for(int i = 2; i <= iNumMax; i++)
        {
            if(!viCount[i])
                continue;

            int iFlags = 0;
            bool bCheck = false;
            for(int j = 0; j < viPrimes.size(); j++)
            {
                if(i % (viPrimes[j] * viPrimes[j]) == 0)
                {
                    bCheck = true;
                    break;
                }
                if(i % viPrimes[j] == 0)
                {
                    iFlags |= 1 << j;
                }
            }
            if(bCheck)
                continue;

            for(int j = (1 << viPrimes.size()) - 1; j > 0; j--)
            {
                if((iFlags & j) == iFlags)
                {
                    dp[j] = (dp[j] + (long long)dp[j ^ iFlags] * viCount[i]) % iMod;
                }
            }

        }
        int iRet = 0;
        for(int i = 1; i < 1 << viPrimes.size(); i++)
            {
                iRet = (iRet + dp[i]) % iMod;
            }
        return iRet;

    }
};

运行结果