bzoj 4961: 除除除

Description

我们定义一种操作是将一个正整数n(n>1)用某个整数d替换，这个数必须是n的约数(1≤d≤n)。给你一个正整数n，

你需要确定操作进行的期望次数，如果我们希望不断地使用这种操作来将n变成1，假设每次操作选择每个可能的d

的概率均等。为了便于计算，输入将给出n和它的所有不同质因数p_1,p_2,?p_m，保证n恰好有m个不同的质因数。

为了便于输出，设答案是有理数a/b，并且有bc≡1(mod10^9+7)，你只需要输出ac对10^9+7取模的值。例如当n=351

384000时，期望运算的次数为

1384855049944986283970053414177036273994739277918823/282971529872677632598150446595770345000925504317000≈4.893973081

但你只需要输出321468106即可。

Input

输入包含多组测试数据，以EOF结束。

对于每组测试数据：

第一行包含两个正整数n和m，其中m表示n的不同质因数个数，满足2≤n≤10^24。

第二行包含m个质数p_1,p_2,...,p_m，对于i=1,2,...,m满足2≤p_i≤10^6。

约200000组数据。

Output

对于每组测试数据，输出一行一个整数，表示题目要求输出的值。

对一个询问，答案只和每个质因子的幂次构成的可重集有关，在数据范围内只有约170000个本质不同的询问，因此可以预处理递推出答案

递推式为（f为答案，d为约数个数）：

$f(n)=\frac{d(n)+\sum_{i|n and i<n}f(d)}{d(n)-1}$

为了优化这个递推式，将n的质因子的幂次降序排列为p(n,1),p(n,2),p(n,3),...，求和部分考虑记录一个前缀和g(n,k)辅助计算，表示满足 当x<=k时p(a,x)=p(n,x)，否则p(a,x)<=p(n,x) 的f(a)之和，按p(n)的字典序升序处理，适当用hash存储g可以使转移复杂度与g的状态数（约1300000）同阶

#include<cstdio>
typedef unsigned int u32;
typedef unsigned long long u64;
u64 pp[];
const u64 _eq=;
const u32 P=1e9+;
struct num{
    u64 v0,v1,v2;
    void push(u32 x){
        v0=v0*+x,v1*=,v2*=;
        v1+=v0>>,v0=u32(v0);
        v2+=v1>>,v1=u32(v1);
    }
    bool div(u32 x){
        u64 a0=v0,a1=v1,a2=v2;
        a1+=a2%x<<,a2/=x;
        a0+=a1%x<<,a1/=x;
        if(a0%x)return ;
        v0=a0/x,v1=a1,v2=a2;
        return ;
    }
    bool read(){
        v0=v1=v2=;
        int c=getchar();
        while(c<){
            if(c<)return ;
            c=getchar();
        }
        while(c>)push(c-),c=getchar();
        return ;
    }
};
int _(){
    int x=,c=getchar();
    while(c<)c=getchar();
    while(c>)x=x*+c-,c=getchar();
    return x;
}
const u32 M=<<;
struct hmp{
    u64 hx[M];
    int hy[M],y0;
    int&operator[](u64 x){
        if(!x)return y0;
        int w=x&(M-);
        while(hx[w]){
            if(hx[w]==x)return hy[w];
            w=(w+)&(M-);
        }
        hx[w]=x;
        return hy[w];
    }
}H;
int ps[]={,,,,,,,,,,,,,,,,,,,,};
int ss[];
u32 iv[],va=;
u32 inv(u32 a){
    if(a<=)return iv[a];
    u32 v=;
    for(u32 n=P-;n;n>>=,a=u64(a)*a%P)if(n&)v=u64(v)*a%P;
    return v;
}
void dfs(int w,int d,double s,u64 h){
    if(w){
        u64 h1=h,s0=;
        u32 c=;
        for(int i=;i<w;++i){
            int x=ss[i];
            c*=(x+);
            s0+=H[h1+pp[x-]-pp[x]];
            h1+=(_eq-)*pp[x];
        }
        va+=H[h1]=(s0+c)%P*inv(c-)%P;
        for(int i=w-;i>=;--i){
            int x=ss[i];
            u64 h2=h1+(-_eq)*pp[x];
            H[h2]=(H[h1]+H[h2+pp[x-]-pp[x]])%P;
            h1=h2;
        }
    }
    for(int i=;i<=d;++i){
        s*=ps[w];
        if(s>1.01e24)return;
        ss[w]=i;
        dfs(w+,i,s,h+pp[i]);
    }
}
int main(){
    num x;
    u32 m;
    pp[]=;
    iv[]=;
    for(int i=;i<=;++i)iv[i]=u64(P-P/i)*iv[P%i]%P;
    for(u32 i=;i<=;++i)pp[i]=pp[i-]*;
    dfs(,,,);
    while(x.read()){
        u64 h=;
        for(m=_();m;--m){
            u32 y=_(),t=;
            while(x.div(y))++t;
            h+=pp[t];
        }
        printf("%d\n",H[h*_eq]);
    }
    return ;
}