hdu 6053 TrickGCD 容斥原理（莫比乌斯工具）

You are given an array AA , and Zhu wants to know there are how many different array BB satisfy the following conditions?

1≤Bi≤Ai1≤Bi≤Ai
For each pair( l , r ) (1≤l≤r≤n1≤l≤r≤n) , gcd(bl,bl+1…br)≥2gcd(bl,bl+1…br)≥2
Input
The first line is an integer T(1≤T≤101≤T≤10) describe the number of test cases.
Each test case begins with an integer number n describe the size of array AA.

Then a line contains nn numbers describe each element of AA

You can assume that 1≤n,Ai≤1051≤n,Ai≤105
Output
For the kkth test case , first output “Case #k: ” , then output an integer as answer in a single line . because the answer may be large , so you are only need to output answer modmod 109+7109+7
Sample Input
1
4
4 4 4 4
Sample Output
Case #1: 17

http://blog.csdn.net/hallelujah520/article/details/76597862 和hdu 1695
的比较 这一题和hdu 6053不一样的地方在于，在hdu6053 x,y 是确定的一个数而不是一个范围，所以hdu 6053
不是纯正的莫比乌斯，只是单纯的容斥的时候利用到了莫比乌斯函数而已，如果把hdu 6053 强行归类到
正版的莫比乌斯，像我这样的新手就会很纠结。。hdu 6053应该归类到容斥。

题意：给你一个A序列，让你求有多少个b序列满足的条件是 1<=B[i]<=A[i];

一个比较朴素的想法是，所有的数都含有那么一个相同的因子>=2 而所有的素数的组合可以组合成任意的数，所以所有的数就是/2的数+/3的数-6 之类的重复的数，也就是组成的合数
所以就是很明显的容斥了，那么现在的问题是，数能到1e5，求所有的素数的组合再看每个数有多少个这样的数这个过程。。肯定会爆炸的

如何快速求出 两个办法 一个是桶装分段，看每一段有多少个数然后用一个快速幂就好。这样的时间复杂度是onlognlogn，或者用莫比乌斯函数也是一个nlognlogn
分段的思想就是 找出mi之前所有的素数
找到在1e5内 在素数t到t+1段的a[i]个数有多少个。然后就可以用快速幂了。然后对于每次on的查询可以优化到变成一个logn的复杂度 调和级数
用莫比乌斯函数的话，前面也是一样的然后在容斥部分就不是单纯的利用个数判断+-，而是预处理了= = 反正就是预处理了你要选择的符号了，其实也就是特殊容斥，具体的还要继续学

学了一天莫比乌斯，终于知道是个什么鬼，虽然只会用公式 1：

其实莫比乌斯函数就是一个系数 预处理后得到的是 f(1)-f(2)-f(3)-f(5)+f(6)-f(7)+f(10)-f(11) 的每个函数前面的系数，其实就是容斥前面的系数。

但是这题里面要从 2 开始算所以就是相反数 用-即可

再次更新：其实这用到的就是莫比乌斯的本质：莫比乌斯其实就容斥次数的 这里 容斥的 234 到 mi 其实就是最基本的容斥本质

#include <bits/stdc++.h>
using namespace std;
const int N = 3e5+10;
typedef long long ll;
ll mu[N+100];
ll T[N+100];
int a[N+100];
const int mod = 1e9+7;

void mobi(int mn)
{
    mu[1]=1;
    for(int i=1;i<=mn;i++)
    {
        for(int j=i+i;j<=mn;j+=i)
        {
            mu[j]-=mu[i];
        }
    }
}


ll qpow(ll a,ll b)  
{  
    ll ans=1;  
    while(b)  
    {  
        if(b%2==1)ans=ans*a%mod;  
        a=(a*a)%mod;  
        b/=2;  
    }  
    return ans;  
}  


int main()
{
    int t;
    cin>>t;
    mobi(100000);
    int cas=1;
    while(t--)
    {
        memset(T,0,sizeof(T));
        int mi=1e9+7;
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            mi=min(a[i],mi);
            T[a[i]]++;
        }

        for(int i=1;i<=N;i++)
        {
            T[i]+=T[i-1];
        }

        ll ans=0;
        for(ll i=2;i<=mi;i++)// 枚举共有的gcd，也就是枚举共有因子了，就是枚举共有因子
        {
            ll gg=1;
            for(ll j=1;j*i<=100000;j++)
            {

                gg=(gg*qpow(j,(T[(j+1)*i-1]-T[j*i-1])))%mod; //求每个数有多少个这样的gcd
                //并相乘，这里利用了拥有相同个数的同种gcd，进行快速幂加速相乘

            }
            ans=(ans-mu[i]*gg%mod+mod)%mod;
        }
        printf("Case #%d: %lld\n",cas++,ans );
    }
}

转载于:https://www.cnblogs.com/dabai520/p/7554175.html