Codeforces449D - Jzzhu and Numbers - 容斥、状压dp

D. Jzzhu and Numbers

题意: 给出数列 a 1 , a 2 , ⋯   , a n a_1,a_2,\cdots, a_n a1,a2,,an,询问有多少个子序列满足 a i 1   &   a i 2   &   ⋯   &   a i k = 0 a_{i_1}\ \&\ a_{i_2}\ \&\ \cdots\ \&\ a_{i_k}=0 ai1 & ai2 &  & aik=0,答案取模 1 0 9 + 7 10^9+7 109+7

  • 1 ≤ n ≤ 1 0 6 1\le n\le 10^6 1n106
  • 0 ≤ a i ≤ 1 0 6 0\le a_i\le 10^6 0ai106

题解: 非常美妙的容斥解法。二进制考虑这个问题,设 f [ i ] f[i] f[i] 表示取子序列使得它们与操作后至少有 i i i 1 1 1 的方案数,那么答案就是对 f f f 进行容斥的结果( f [ 0 ] − f [ 1 ] + f [ 2 ] − ⋯ + f [ 20 ] f[0]-f[1]+f[2]-\cdots+f[20] f[0]f[1]+f[2]+f[20])!然后思考如何求 f f f。设 g [ s ] g[s] g[s] 表示取子序列使得它们与操作后至少包含状态 s s s 的整数 a i a_i ai 个数(注意到 g [ s ] g[s] g[s] 不会超过 n n n),那么对于每个 g [ s ] g[s] g[s],假设状态 s s s i i i 1 1 1,那么它也应该贡献到 f [ i ] f[i] f[i] 上,因为不管怎么取 s s s 的子序列,对它们进行与操作之后也至少有 i i i 1 1 1,容易发现它的贡献就是非空子集数目,即 2 g [ s ] − 1 2^{g[s]}-1 2g[s]1。接下来问题变成了如何求 g [ s ] g[s] g[s]。这其实是个经典的动态规划问题, g [ s ] = ∑ t & s = s g [ t ] g[s]=\sum\limits_{t\&s=s} g[t] g[s]=t&s=sg[t],具体做法是按位转移,依次从 s s s 递推到 s ⊕ 2 i s\oplus 2^i s2i,这样可以 O ( 20 ⋅ max { a i } ) O(20\cdot \texttt{max}\{a_i\}) O(20max{ai}) 做到不重而且不漏地计算。

当然如果计算出了 g [ s ] g[s] g[s],直接对 g g g 进行容斥也能得到答案,即讨论 g [ s ] g[s] g[s] s s s 1 1 1 的个数,讨论正负号,这个和上面做法的等价的。

代码:

#include 
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
const int max_n = 1e6 + 5;
int dp[max_n];
ll f[21], b[max_n];
int main() {
    int n;
    scanf("%d", &n);
    memset(dp, 0, sizeof dp);
    int mx = 0;
    b[0] = 1;
    for (int i = 1; i <= n; i++) b[i] = (b[i-1] << 1) % mod;
    for (int i = 1; i <= n; i++) {
        int a_i;
        scanf("%d", &a_i);
        mx = max(mx, a_i);
        dp[a_i]++;
    }
    for (int j = 0; j <= 20; j++) {
        for (int i = 1; i <= mx; i++) if (dp[i]) {
            if (i & (1 << j)) {
                dp[i^(1<

你可能感兴趣的:(动态规划(DP),数学,Codeforces)