hdu6053(莫比乌斯+容斥+分块)

题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=6053

题意: 给出一个含 n 个元素的 a 数组, 求 bi <= ai 且 gcd(b1, ..., bn) >= 2 的 b 数组的数目；

思路: 首先想到的方法是枚举 gcd, 对于每个 gcd x 的情况, 将所有 bi / x 连乘, 然后将所有 gcd 的情况累加一下就能的到答案了 .

然而其时间复杂度为 O(t * min(a) * n), 铁定 tle；

对于后面连乘部分是可以优化一下的 . 把 a 数组元素装到一个桶里面, 然后枚举 gcd 时按照 ai / gcd 的值分下块,

对于区间 [gcd * k, gcd * (k + 1 ) - 1], 显然区间内的值除 gcd 的商都为 k, 若 a 中有 cnt 个元素处于该区间, 那么该块内的 b 数组元素有 k^cnt 种选择方案,

再将不同块的方案数乘起来就是当前 gcd 对答案的贡献了 .

然而上面还会出现重复计算(个人感觉这个有点难理解):

对于不能分解成不同素数乘积形式的 gcd, 在第一次计算其中多次出现的素因子作 gcd 时已经计算过了, 所以不累加到答案上 .

对于能分解成不同素数乘积形式的 gcd, 其中重复计算的我们可以用容斥去重, 奇加偶减 .

可以发现这和 moblus 函数很相近, 对与不能分解成不同素数乘积形式的数, 其 mu 值为 0, 对于能分解成不同素数乘积形式的数, 若其长度为奇数, mu 值为 -1, 长度为偶数则 mu 值为 1, 恰好与容斥的奇加偶减相反, 所以给 mu 加个负号即可 .

代码:

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #define ll long long
 using namespace std;

 const int mod = 1e9 + ;
 const int MAXN = 1e5 + ;

 bool check[MAXN];
 int prime[MAXN], mu[MAXN], vis[MAXN << ];

 void Moblus(void){
     memset(check, false, sizeof(check));
     int tot = ;
     mu[] = ;
     for(int i = ; i < MAXN; i++){
         if(!check[i]){
             prime[tot++] = i;
             mu[i] = -;
         }
         for(int j = ; j < tot && i * prime[j] < MAXN; j++){
             check[i * prime[j]] = true;
             if(i % prime[j] == ){
                 mu[i * prime[j]] = ;
                 break;
             }else mu[i * prime[j]] = -mu[i];
         }
     }
 }

 ll get_pow(ll x, int n){
     ll ans = ;
     while(n){
         if(n & ) ans = ans * x % mod;
         x = x * x % mod;
         n >>= ;
     }
     return ans;
 }

 int main(void){
     Moblus();
     int t, n, x;
     scanf("%d", &t);
     for(int cas = ; cas <= t; cas++){
         memset(vis, , sizeof(vis));
         int mi = MAXN, mx = - MAXN;
         scanf("%d", &n);
         for(int i = ; i < n; i++){
             scanf("%d", &x);
             vis[x] += ;
             mi = min(mi, x);
             mx = max(mx, x);
         }
         for(int i = ; i < (MAXN << ); i++){//注意范围
             vis[i] += vis[i - ];
         }
         ll ans = ;
         for(int i = ; i <= mi; i++){
             ll cnt = ;
             if(mu[i]){
                 for(int j = i; j <= mx; j += i){
                     cnt = (cnt * get_pow((ll)(j / i), vis[j + i - ] - vis[j - ])) % mod;
                 }
             }
             ans = (ans - cnt * mu[i] + mod) % mod;
         }
         printf("Case #%d: %lld\n", cas, ans);
     }
     return ;
 }