TrickGCD hdu6053

                                  

                          TrickGCD

Problem Description

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

* 1≤Bi≤Ai
* For each pair( l , r ) ( 1≤l≤r≤n) , gcd(bl,bl+1...br)≥2

 

Input

The first line is an integer T( 1≤T≤10) describe the number of test cases.

Each test case begins with an integer number n describe the size of array A.

Then a line contains n numbers describe each element of A

You can assume that 1≤n,Ai≤105

 

Output

For the kth 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 mod 109+7

 

Sample Input

1 4 4 4 4 4

 

Sample Output

Case #1: 17

题意：

给一个长度为n的数组A，让你构造等长的数组B，B数组中的元素取值为小于等于A数组中对应位置的元素，现在询问B数组中的gcd大于等于2的方案数.

分析：

找到 ai 中最小的那个数，枚举他的因数作为gcd，然后根据这个gcd我们可知 ∏ai/gcd 即为这个这个以这个数为gcd的序列对答案的贡献，然而这么算会有重复。比如我们在算2和3的时候已经把6的序列算了，所以我们需要容斥一下。

容斥的方法：莫比乌斯函数。
考虑一个数n，假设他能分解成三个质因数相乘：a*b*c，那么在算gcd为a、b、c时分别算了一遍，所以我们要减去gcd为a*b、a*c、b*c的，再加上gcd为a*b*c的。推广：我们需要加上质因数为奇数个的，减去质因数为偶数个的。当某个质因数的指数大于等于2，那么这个数我们之前肯定算过，所以这个不计入最后答案。
而莫比乌斯函数正好符合我们的需要（取个相反数就ok了）。

      
但是这样肯定会超时，所以我们可以进行一下优化，把式子化简为∏maxa/gcdj=1im。

      就是把枚举n个 ai 转化成了枚举 ai/gcd 的值，这个点  值一定在1和maxa/gcd之间，这个化简大概优化到了logn。然后就是m了，m代表n个 ai 中除以gcd为i的数量为m，这个m我们可以通过求一遍 ai 的前缀和得到（就是开个数组，把 ai 当作下标，记录 ai 出现了多少次，然后求这个数组的前缀和，这样就可以O（1）的求出一个范围内 ai 出现了多少次了，也就得到了m的值）

AC代码如下：

#include 
#include 
#include 
#include 
#include 
#define inf 0x3f3f3f3f

using namespace std;
const int mod = 1e9+7;
const int maxn = 100200;
bool isprime[maxn];///1代表是素数
int prime[maxn];
int miu[maxn];///存储的是莫比乌斯函数的值
void moblus()///莫比乌斯函数值的打表
{
    int cnt = 0;///记录素数的个数
    miu[1] = 1;
    memset(isprime,1,sizeof(isprime));
    for(long long i = 2; i < maxn; i++)
    {
        if(isprime[i])
        {
            prime[cnt++] = i;
            miu[i] = -1;
        }
        for(long long j = 0; j < cnt && i*prime[j] < maxn; j++)
        {
            isprime[i*prime[j]] = 0;///0代表不是素数
            if(i % prime[j])///比如i=5，prime[0]=2,prime[1]=3,prime[3]=5;miu[5*2]=1,miu[5*2*3]=1;
                miu[i*prime[j]] = -miu[i];
            else
            {
                miu[i*prime[j]] = 0;
                break;
            }
        }
    }
}

long long quick_mod(long long a,long long b)///快速幂取模
{
    long long ans = 1;
     while(b)
     {
         if(b&1)
         {
             ans=(ans*a)%mod;
             b--;
         }
         b>>=1;
         a=(a*a)%mod;
     }
     return ans;
}

int a[102000];///下标代表输入的数，值代表这个数出现的次数
int suma[202000];///累加的和

int main()
{
    int cas,ncase = 0;
    int n,v;
    int maxa,mina;
    scanf("%d",&cas);
    moblus();
    while(cas--)
    {
        ncase++;
        long long ans = 0;///方案数
        maxa = -100200,mina = 102000;
        scanf("%d",&n);
        memset(a,0,sizeof(a));///初始化
        for(int i = 1; i <= n; i++)
        {
            scanf("%d",&v);
            a[v]++;
            mina = min(mina,v);///a数组的最小值
            maxa = max(maxa,v);///a数组中的最大值
        }
        for(int i = 1; i <= maxa*2; i++)///求出这个数组的前缀和
        {
            suma[i] = suma[i-1] + a[i];
        }

        long long tempans = 1;
        for(int i = 2; i <= mina; i++)///从2依次枚举
        {
            tempans = 1;
            for(int j = 1; j*i <= maxa; j++)
            {
                tempans *= quick_mod(j,(suma[i*j+i-1]-suma[i*j-1]));
                tempans %= mod;
            }
            ans -= miu[i]*tempans;
            ans %= mod;
        }
        printf("Case #%d: %lld\n",ncase,(ans+mod)%mod);
    }
}

把式子化简为∏maxa/gcdj=1im。