2017-07-25 51nod 1189 素数打表 素数筛 质因数分解

阶乘分数(个人觉得这个名字有一点点点点迷)

题目描述:

1/N! = 1/X + 1/Y(0<x<=y),给出N,求满足条件的整数解的数量.

例如：N = 2，1/2 = 1/3 + 1/6，1/2 = 1/4 + 1/4。

由于数量可能很大，输出Mod 10^9 + 7

INPUT:

输入一个数N(1 <= N <= 1000000)

OUTPUT:

输出解的数量Mod 10^9 + 7

样例输入:

2

样例输出:

2

应用之前看过某篇博文的话来说,"思路：通常这种题目,x和y都具有轮换性时,就要特别注意了,通常最后式子能化简成一个具有轮换性的式子"

不过这个我愣是没有化出来,搜了网上的题解才知道.....

例如1/p=1/a+1/b, 就可以化成p*p=(a-p)*(b-p)  (这个你自己去化)

对于此题,就是(N!)^2=(X-N!)*(Y-N!)

分别将(X-N!)变成X``,(Y-N!)变成Y``

然后就变成了(N!)^2=(X``)*(Y``)

那就变成对(N!)^2进行分解,求X``,Y``搭配的对数,需要质因数分解

质因数分解需要给素数打表 自己原来写的和网上的效率差了大概 呃 也就几百毫秒 吧

给N!进行质因数分解,从2到N依次分解(1不用分解),然后每除以一个质数因子就在factor[ ]里面++

但是实际上我们真正要分解的是(N!)^2,所以这个东西到最后还要乘以二再处理,这是后话

其中factor下标是指这个质数从2数起的第几个质数-1,比如质数7是第4个质数,那么它的下标是3,每次让原来的数字n除以一个质数因子7就让factor[3]+=2

这个意义很重要因为后面要用

然后更新(N!)^2的最大质因数的序号下标max_no

这里为了减少时间,有个技巧是一个合数的最大质因数的平方一定小于这个合数

不过这个技巧后面要加个if,具体原因见下面的代码的注释(对 我懒 有问题嘛)

分解到N分解完了会得到一个完整的分解质因数的数组factor[ ]和出现的最大的质因数的序号下标max_no

随手举例:factor[2]=1,max_no=2,就是指这个阶乘分解质因数之后里面只有一个5,而且这个5也是出现的最大的质因数(5是第三个质数,反映到下标就是3-1=2)

然后从(factor[0]*2+1)*(factor[1]*2+1)*......*(factor[max_no]*2+1),这个式子相乘的时候记得取模哦

得到的就是 总结果数取模后的结果

为什么乘以2,往上看几行,对,就"后话"那里

为什么要加一再都乘起来,因为要找(N!)^2=(X``)*(Y``)中X``和Y``的搭配个数的情况,至于为什么自己去想

但是这里是不考虑X,Y的大小情况的

如果这个总方案数是个奇数,那肯定是有一个X=Y的情况的,所以+1然后除以2

如果总方案数是个偶数,直接除以2也行,+1除以二也行,反正小数点之后就被抹掉了

不过题目又要取模对吧哈哈哈哈哈哈

求2关于MOD的逆元就可以,再次利用费马小定理可以知道这个逆元可以用2^(MOD-2)计算

然后又是快速幂,要取的模就是MOD

然后把这个算完的逆元 乘以之前的 总结果数取模后的结果 然后再取模

就是res

代码如下

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MOD 1000000007

long long int prime[1000010];//prime[0]=2,prime[1]=3,prime[2]=5,prime[3]=7,........
bool is_prime[1000010];//自己写的素数打表需要的一个数组,实际上最后跟prime数组和no_prime数组作用重叠了
int factor[1000010];//记录分解质因数之后的结果
int no_prime[1000010];//记录质数的下标,比如no_prime[5]=2,就是说5这个质数的下标是2,对应实际就是是第2+1=3个质数

int maxx(int a,int b)
{
    if(a>b)
        return a;
    else
        return b;
}

long long int quick_mod(long long int a,long long int p)//计算(a^p)%mod即快速幂 用于计算指数p特别大的情况
{
    //计算(a^p)%mod
    long long int res=1;
    while(p)
    {
        if(p&1)
            res=res*a%MOD;//int有可能会冒，视情况换成long long
        p>>=1;//就是 p=p/2
        a=(a*a)%MOD;
    }
    return res;
}

/*int work_prime()
{
    int i,j;
    for(i=0; i<1000010; i++)
    {
        is_prime[i]=true;
    }
    memset(prime,0,sizeof(prime));
    is_prime[0]=is_prime[1]=false;
    for(i=2; i<1000010; i++)
    {
        while(is_prime[i]!=true)
            i++;
        for(j=2; i*j<1000010; j++)
        {
            is_prime[i*j]=false;
        }
    }
    j=0;
    for(i=2; i<1000010; i++)
    {
        if(is_prime[i]==true)
        {
            prime[j]=i;
            no_prime[i]=j;
            j++;
        }
    }
    return j;
}*///自己写的可能超时的版本,先筛再记录会浪费时间

int work_prime()
{//来自网上某博文,忘记网址了你打我啊
//感觉很精妙,实话
//不用先筛再遍历记录,时间快了不少
    int res;
    res=0;
    memset(prime,0,sizeof(prime));
    for (int i = 2; i <= 1000010; i++)
    {
        if (!prime[i])
        {
            prime[(++res)-1] = i;
            no_prime[i]=res-1;
        }
        for (int j = 1; j <= res && prime[j-1] <= 1000010 / i; j++)
        {
            prime[prime[j-1] * i] = 1;
            if (i % prime[j-1] == 0)
            {
                break;
            }
        }
    }
    return res;
}


int work_factor(int fac[1000010],int n,int n_prime)
{
    int i,max_no;
    for(i=0; i<n_prime&&prime[i]*prime[i]<=n; i++)//中间的平方是减少时间的附加条件
    {
        while(n%prime[i]==0)
        {
            n=n/prime[i];
            fac[i]++;
            max_no=i;
        }
    }
    if(n!=1)//这一段判断条件是用来防止n最后自己就是一个质数的,比如当n为2的时候跳出的时候,实际上fac数组并没有记录完实际的分解质因数的情况
    {
        fac[no_prime[n]]++;
    }
    max_no=maxx(max_no,no_prime[n]);//更新max_no
    return max_no;
}

int main()
{
    int i,n_prime,max_no,n;
    long long int res,ni;
    n_prime=work_prime();//打表
    ni=quick_mod(2,MOD-2);//实际上这个还不如提前算好了放进去.......
    while(scanf("%d",&n)!=EOF)
    {
        memset(factor,0,sizeof(factor));
        res=1;
        for(i=2; i<=n; i++)
        {
            max_no=maxx(max_no,work_factor(factor,i,n_prime));//更新max_no
        }
        for(i=0; i<n; i++)
        {
            res=(res*(factor[i]*2+1))%MOD;
        }
        res=((res+1)*ni)%MOD;
        printf("%lld\n",res);
    }
    return 0;
}