【NOIP入门数论】分解质因数

自创题目详解

数据包

【数据资源】链接：http://pan.baidu.com/s/1eRHCMwq 密码：9laz

题面

【题目名称】分解质因数
【时间限制】1000ms
【空间限制】128M
【题目描述】
$记P_i表示正整数i的质因数集合.$
$已知正整数n，求满足下列条件的有序正整数对(a,b)的数目：$
$(1)1\leq a\leq b\leq n;$
$(2)t为a,b的最大公约数,P_t是P_n的子集.$
【输入格式】
一个正整数n.
【输出格式】
一个正整数，表示合题意的有序正整数对的数目.

样例输入1	样例说明1
6	在满足1<=a<=b<=6的条件下，共有21对；除开(5,5)不合题意，其余均满足条件。
样例输出1
20
样例输入2	样例说明2
7	在满足1<=a<=b<=7的条件下，共有28对；其中(2,2),(2,4),(2,6),(3,3),(3,6),
样例输出2	(4,4),(4,6),(5,5),(6,6)不合题意.
19

【数据范围】
$50\%的数据1\leq n\leq 1000;$
$100\%的数据1\leq n\leq1000000.$
————————————————————————————————————————————————
【题解】
50分算法：
只要听话，就一定可以拿全50分！我们只需要先将n分解质因数，并将这些质因数都记录下来。
之后老老实实枚举a,b再用欧几里得求出最大公约数，直接分解质因数验证即可。
时间复杂度$O((n^2)\cdot log\ n)$其实这个log n相当的小，1000ms的时限是可以过完50分的数据的。
下面给出50分的暴力代码：

#include<cstdio>  
#define MAXN 101000  
int gcd(int a,int b)  
{  
    int t;  
    while(b>0)  
    {  
        t=a;  
        a=b;  
        b=t%b;  
    }  
    return a;  
}//非递归辗转相除法；  
bool P[MAXN];  
int n;  
bool ok(int x)  
{  
    for(int i=2;i*i<=x;i++)  
    {  
        if(x%i==0)  
        {  
            if(!P[i])  
            {  
                return false;  
            }  
        }  
        while(x%i==0)  
        {  
            x/=i;  
        }  
    }  
    if(x>1&&P[x]==0)//如果x仍大于1，说明x自身是个质数，以至于在x^0.5范围内找不到x的因数；  
    {  
        return false;  
    }  
    return true;  
}//判断是否为子集  
int main()  
{  
    freopen("prime.in","r",stdin);  
    freopen("prime.out","w",stdout);   
    scanf("%d",&n);  
    int k=n;  
    for(int i=2;i*i<=n;i++)  
    {  
        if(k%i==0)  
        {  
            P[i]=1;  
        }  
        while(k%i==0)  
        {  
            k/=i;  
        }  
    }//分解n;  
    if(k>1)  
    {  
        P[k]=1;  
    } //原理见ok函数  
    long long cnt=0LL;  
    for(int i=1;i<=n;i++)  
    {  
        for(int j=i;j<=n;j++)  
        {  
            if(ok(gcd(i,j)))  
            {  
                cnt+=1LL;  
            }  
        }  
    }  
    printf("%I64d",cnt);  
    return 0;  
}  

100分算法：
可以看出数据范围是相当的大，枚举a,b是不可行的。我们不妨思考一下一个比较基础的问题：
如何求解1~n中有多少个数与n互质？答案是用欧拉函数。而欧拉函数的原理即是将n含有的质因数逐一筛去。
因为我们要求解的数是一定不含这些质因数的，所以将这些质数筛去是合理的。
而现在的问题是，我们要求解有多少个小于i的数，与i的公共质因数落在一个确定的集合中。
在求欧拉函数时，由于不能有质数，所以我们筛去质数；而这里，P_n 中的质数是可以出现的，于是我们就没有必要将它们筛去。也就是说，计算$phi[i]=i(1-\frac{1}{p_1})(1-\frac{1}{p_2})……(1-\frac{1}{p_k})$时，凡是在集合P_n中的质数，就不乘以$(1-\frac{1}{p})$,只将那些不在集合$P_i$中的质数筛掉即可。
甚至，我们可以有一个更大胆的想法：对于P_n中的质数，我们并不将其视为质数。这样题设条件就是一种变相的互质了！！！
于是当我们求出做了手脚的欧拉函数phi[i]后,$\sum_{i=1}^{n}{phi[i]}$就是最终答案！
phi[i]的求法，最优秀的是用线性筛，但是没有这个必要。标程采用的O(n*log n)的算法，跑得飞快！
为了方便，标程的做法是并不在求欧拉函数时做判断，而是照常求出欧拉函数，但在求和时，将原本不该筛而现在多筛了的部分补偿回来。
下面放100分代码：老实说，比暴力要短。

#include<cstdio>  
#define MAXN 2000100  
int P[MAXN],tot=0;  
int n,f[MAXN];  
int main()  
{  
    freopen("prime.in","r",stdin);  
    freopen("prime.out","w",stdout);  
    scanf("%d",&n);  
    int k=n;  
    for(int i=2;i*i<=k;i++)  
    {  
        if(k%i==0)  
        {  
            P[++tot]=i;  
        }  
        while(k%i==0)  
        {  
            k/=i;  
        }  
    }  
    if(k>1)  
    {  
        P[++tot]=k;  
    }  
    for(int i=1;i<=n;i++)  
    {  
        f[i]=i;  
    }  
    for(int i=2,j;i<=n;i++)  
    {  
        if(f[i]==i)  
        {  
            for(j=i;j<=n;j+=i)  
            {  
                f[j]-=f[j]/i;  
            }  
        }  
    }//O(n*log n)  
    long long ans=0;  
    for(int i=1;i<=n;i++)  
    {  
        for(int p=1;p<=tot;p++)  
        {  
            if(i%P[p]==0)  
            {  
                f[i]+=f[i]/(P[p]-1);  
            }  
        }//tot不会超过7，所以效率相当高！  
        ans+=(long long)f[i];  
    }  
    printf("%I64d",ans);  
    fclose(stdin);  
    fclose(stdout);  
    return 0;  
}  

此题还有其他100分解法，这里简要提一下：(下面用gcd(a,b)表示a,b的最大公约数)
对于gcd(a,b)=t,有gcd(a/t,b/t)=1,于是(a,b)的数目可以借助phi[b/t]来求解。但是要预处理出所有合题意的t.
此解法比标程解法要麻烦许多！！！
【总结】
此题的关键是要对欧拉函数的原理和本质有清楚的认识，这样才可能用改造后的欧拉函数来求解问题。

---

以上是本人NOIP前发的题解，现在看来相当的naive.
之前提到线性筛欧拉函数，但是后面的补偿部分仍然不是线性的。或者说是一个有常数的线性算法，常数取决于n的质因数集合的size.
其实这样的算法效率上已经很接近线性了，不过这里我提一下正经的线性做法：
考虑改造后的欧拉函数，记作g(x).它仍然是一个积性函数.于是就可以用线性筛直接处理出g(x).
具体来说，先用$O(\sqrt n)$的算法分解n的质因数，(当然你会用$O(n^\frac{1}{4})$的算法更好)，然后线性筛.
凡是遇到质数x,如果在P_n集合中,g(x)=x;否则,g(x)=x-1;对于合数，利用积性函数的性质求解就好.
还是放一段代码吧：

#include<cstdio>  
#define MAXN 2000100  
int P[MAXN],tot=0;  
int n,f[MAXN];  
int main()  
{  
    freopen("prime.in","r",stdin);  
    freopen("prime.out","w",stdout);  
    scanf("%d",&n);  
    int k=n;  
    for(int i=2;i*i<=k;i++)  
    {  
        if(k%i==0)  
        {  
            P[++tot]=i;  
        }  
        while(k%i==0)  
        {  
            k/=i;  
        }  
    }  
    if(k>1)  
    {  
        P[++tot]=k;  
    }  
    for(int i=1;i<=n;i++)  
    {  
        f[i]=i;  
    }  
    for(int i=2,j;i<=n;i++)  
    {  
        if(f[i]==i)  
        {  
            for(j=i;j<=n;j+=i)  
            {  
                f[j]-=f[j]/i;  
            }  
        }  
    }//O(n*log n)  
    long long ans=0;  
    for(int i=1;i<=n;i++)  
    {  
        for(int p=1;p<=tot;p++)  
        {  
            if(i%P[p]==0)  
            {  
                f[i]+=f[i]/(P[p]-1);  
            }  
        }//tot不会超过7，所以效率相当高！  
        ans+=(long long)f[i];  
    }  
    printf("%I64d",ans);  
    fclose(stdin);  
    fclose(stdout);  
    return 0;  
}