【NOIP入门数论】分解质因数
自创题目详解
数据包
【数据资源】链接：http://pan.baidu.com/s/1eRHCMwq 密码：9laz
题面
【题目名称】分解质因数
【时间限制】1000ms
【空间限制】128M
【题目描述】
记Pi表示正整数i的质因数集合.
已知正整数n，求满足下列条件的有序正整数对(a,b)的数目：
(1)1≤a≤b≤n;
(2)t为a,b的最大公约数,Pt是Pn的子集.
【输入格式】
一个正整数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≤n≤1000;
100%的数据1≤n≤1000000.
————————————————————————————————————————————————
【题解】
50分算法：
只要听话，就一定可以拿全50分！我们只需要先将n分解质因数，并将这些质因数都记录下来。
之后老老实实枚举a,b再用欧几里得求出最大公约数，直接分解质因数验证即可。
时间复杂度 O((n2)⋅log n) 其实这个log n相当的小，1000ms的时限是可以过完50分的数据的。
下面给出50分的暴力代码：
#include
#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−1p1)(1−1p2)……(1−1pk) 时，凡是在集合P_n中的质数，就不乘以 (1−1p) ,只将那些不在集合 Pi 中的质数筛掉即可。
甚至，我们可以有一个更大胆的想法：对于P_n中的质数，我们并不将其视为质数。这样题设条件就是一种变相的互质了！！！
于是当我们求出做了手脚的欧拉函数phi[i]后, ∑ni=1phi[i] 就是最终答案！
phi[i]的求法，最优秀的是用线性筛，但是没有这个必要。标程采用的O(n*log n)的算法，跑得飞快！
为了方便，标程的做法是并不在求欧拉函数时做判断，而是照常求出欧拉函数，但在求和时，将原本不该筛而现在多筛了的部分补偿回来。
下面放100分代码：老实说，比暴力要短。
#include
#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(n√) 的算法分解n的质因数，(当然你会用 O(n14) 的算法更好)，然后线性筛.
凡是遇到质数x,如果在P_n集合中,g(x)=x;否则,g(x)=x-1;对于合数，利用积性函数的性质求解就好.
还是放一段代码吧：
#include
#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;
}