JAVA程序设计：好子集的数目（LeetCode：1994）

最新推荐文章于 2022-09-25 19:24:00 发布

信仰..

最新推荐文章于 2022-09-25 19:24:00 发布

阅读量480

点赞数

分类专栏： LeetCode刷题记录(基于java语言) 文章标签： leetcode java 算法

本文链接：https://blog.csdn.net/haut_ykc/article/details/120556743

版权

LeetCode刷题记录(基于java语言) 专栏收录该内容

620 篇文章 39 订阅

订阅专栏

该博客介绍了如何解决一个数学与算法相结合的问题，即找到整数数组中所有乘积由互不相同质数相乘组成的好子集。博主使用了状态压缩和动态规划的方法，通过枚举素数并结合01背包的思想，计算出符合条件的子集数目。文章重点讨论了算法的实现细节，并提供了代码示例进行解释。

摘要由CSDN通过智能技术生成

给你一个整数数组 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 <= 105
1 <= nums[i] <= 30

思路：题目保证元素的大小范围在[1,30]内，因此我们可以枚举出素数只有10个，通过采用状态压缩的方式枚举当前选取的素数自己，然后借助01背包实现凑出当前子集的方案数，最终求和即可。唯一需要注意的一点是元素1要另算，其对答案产生的贡献是2的x次方，其中x为元素1的个数。

class Solution {

    private int[] f;
    private static final int mod = 1000000007;
    private static final int[] arr = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};

    public int numberOfGoodSubsets(int[] nums) {
        long ans = 0;
        int n = nums.length;
        int[] sum = new int[35];
        for (int i = 0; i < n; i++)
            sum[nums[i]]++;
        long[] count = new long[n];
        long[] dp = new long[1 << 10];
        count[0] = 1;
        for (int i = 1; i < n; i++)
            count[i] = count[i - 1] * 2 % mod;
        dp[0] = 1;
        for (int j = 2; j <= 30; j++) {
            if (sum[j] == 0 || jud(j))
                continue;
            for (int i = (1 << 10) - 1; i >= 0; i--) {
                boolean flag = false;
                int state = 0;
                for (int k = 0; k < 10; k++) {
                    if ((i >> k & 1) != 0 && j % arr[k] == 0) {
                        flag = true;
                        break;
                    }
                    if (j % arr[k] == 0)
                        state |= 1 << k;
                }
                if (!flag && state != 0)
                    dp[i | state] = (dp[i | state] + dp[i] * sum[j] % mod) % mod;
            }
        }
        for (int i = 1; i < (1 << 10); i++) {
            if (dp[i] == 0)
                continue;
            ans = (ans + dp[i] * count[sum[1]] % mod) % mod;
        }
        return (int) ans;
    }

    private boolean jud(int x) {
        if (x % 4 == 0 || x % 9 == 0 || x == 25)
            return true;
        return false;
    }
}