Educational Codeforces Round 20 F. Coprime Subsequences（DP+容斥）

原题链接：F. Coprime Subsequences

---

题目大意：

---

给出一个长度为 $n$ 的数组 $a$，询问有多少个非空 子序列 $b$ 满足 $\gcd (b_1,b_2,...,b_k)=1$ ，答案对 $10^9+7$ 取模。

解题思路：

---

子序列的问题，我们只需要知道某个数字有和没有就好了。

考虑容斥，我们定义 $dp[i]$ 表示子序列 $b$ 的 $\gcd$ 至少为 $i$ 的倍数方案数，考虑一下这个怎么求。

注意这个 $\gcd$ 至少为 $i$ 的倍数的含义。

即考虑 $\gcd =2$ 时，我们 $dp[2]$ 同时也包含了 $\gcd =6,12,22$ 这类的情况。

不理解这一步的可以思考一下如下的数列

假设原数组为 $[1,2,4,7,6,2,8,9]$

考虑此时 $\gcd$ 至少 为 $2$ 的倍数，我们一定只能从这些数字中选。

$[2,4,6,2,8]$

但是我们可能选出 $\gcd (4,8)=4,\gcd (4,6,8)=2,...$ 之类的情况，但此时 $\gcd$ 的值都至少是 $2$ 的倍数。

此时的方案数就是 $dp[2]$ 的含义。

考虑将每个数字装入桶 $cnt[x]$，定义 $cnt[x]$ 为数字 $x$ 的倍数 $y$ 出现的次数，显然：

$$\begin{array}{rl}cnt[x]& =\sum _{x|y}cnt[y]\end{array}$$

这个可以直接 $O(V\log V)$ 做即可。

由于要求非空子序列，那么显然可得：

$$\begin{array}{rl}dp[x]& =2^{cnt[x]}-1\end{array}$$

此时我们的 $dp[x]$ 就知道了，但显然我们要求的不是 $\gcd$ 至少为 $x$ 的方案数，而是 恰好 为 $x$ 的方案数。

考虑容斥，如 $dp[2]$ 中包含了 $\gcd =2,4,6,8,...$ 的信息，那么我们直接考虑减去这些信息就好了。

怎么减？既然 $dp[2]$ 中包含了若干个信息，那么我们从只包含自身的信息（即最尾部的信息）倒着开始做减法不就好了吗？

假设 $a_i\in [1,6]$，那么我们的 $dp[x]$ 的构成为：

$dp[1]=gc{d}_1+gc{d}_2+gc{d}_3+gc{d}_4+gc{d}_5+gc{d}_6$
$dp[2]=gc{d}_2+gc{d}_4+gc{d}_6$
$dp[3]=gc{d}_3+gc{d}_6$
$dp[4]=gc{d}_4$
$dp[5]=gc{d}_5$
$dp[6]=gc{d}_6$

（上面的 $gc{d}_x$ 表示 $\gcd$ 恰好等于 $x$ 时的方案数）

我们要求 $\gcd$ 恰好 等于 $x$ 的方案数，那么答案就呼之欲出了：

$$\begin{array}{rl}gc{d}_3& =dp[3]-gc{d}_6\\ & =dp[3]-dp[6]\\ & \\ gc{d}_2& =dp[2]-gc{d}_4-gc{d}_6\\ & =dp[2]-dp[4]-dp[6]\end{array}$$

最后使 $dp[3]=gc{d}_3,dp[2]=gc{d}_2$ 此时：

$dp[1]=gc{d}_1+gc{d}_2+gc{d}_3+gc{d}_4+gc{d}_5+gc{d}_6$
$dp[2]=gc{d}_2$
$dp[3]=gc{d}_3$
$dp[4]=gc{d}_4$
$dp[5]=gc{d}_5$
$dp[6]=gc{d}_6$

那么：

$$\begin{array}{rl}gc{d}_1& =dp[1]-gc{d}_2-gc{d}_3-gc{d}_4-gc{d}_5-gc{d}_6\\ & =dp[1]-dp[2]-dp[3]-dp[4]-dp[5]-dp[6]\end{array}$$

那么答案就在 $dp[1]$ 取得了。

时间复杂度： $O(V\log V)$

#include <bits/stdc++.h>

using i64 = long long;

const int mod = 1e9 + 7;

i64 qpow(i64 a, i64 b) {
    i64 res = 1; a %= mod;
    for (; b; b >>= 1, a = a * a % mod) {
        if (b & 1) res = res * a % mod;
    }
    return res;
}

const int N = 1e6;

i64 cnt[N + 1], dp[N + 1];

void solve() {
    int n;
    std::cin >> n;

    for (int i = 1; i <= n; ++i) {
        int x;
        std::cin >> x;
        ++cnt[x];
    }

    for (int i = 1; i <= N; ++i) {
        for (int j = i + i; j <= N; j += i) {
            cnt[i] += cnt[j];
        }
        dp[i] = (qpow(2, cnt[i]) - 1 + mod) % mod;
    }

    for (int i = N; i >= 1; --i) {
        for (int j = i + i; j <= N; j += i) {
            dp[i] = (dp[i] - dp[j] + mod) % mod;
        }
    }

    std::cout << dp[1] << '\n';
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t = 1;
    //std::cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}