本文介绍了在编程中如何运用唯一性定理解决数论问题，如判断完数和计算阶乘正约数，以及使用埃氏筛法进行质因数分解。通过实例演示和代码优化技巧，帮助读者掌握相关算法并进行实践。
前言：
上节课我们初步学习了唯一性定理，这节课我们将深入研究并学习埃氏筛
上节课网址：数论：唯一性定理（上）-CSDN博客
接下来，进入正题。
1. 数论：唯一性定理（下）
例题精讲：
1. 4951 - 数论：唯一性定理 超级完全数
真因子之和等于它本身的数称为完数（或称完全数），例如28的真因子有:1,2,4,7,14并且1+2+4+7+14=28，所以28是完数。 乐乐得到了一些数字n，这些数有的比较大(1<=n<=1e9),他想知道这些数是不是完数
输入
一个正整数N （1<=n<=1e9）
输出
如果是完数，输出Y，否则输出N
样例
输入
28
输出
Y
分析：
由于这是上节课的练习，所以我就不多讲了。
这道题其实就是求约数之和，最后加个判断（sum是否等于2*n）即可。
OK上代码：
#include<bits/stdc++.h>
#define long long int
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
signed qpow(int a,int b){
int ans=1;
while(b){
if(b&1){
ans=(ans*a);
}
a=(a*a);
b>>=1;
}
return ans;
}
signed main(){
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
map<int,int> sum;
int n,m,k=0,l=1,h;
cin>>n;
h=n;
for(int i=2;n>1;++i){
while(n%i==0){
n/=i;
sum[i]++;
}
}
auto it = sum.begin();
for(;it!=sum.end();it++){
m=it->second;
k=0;
for(int i=0;i<=m;i++){
k+=qpow(it->first,i);
}
l*=k;
}
if(l==h*2){
cout<<'Y'<<endl;
}else{
cout<<'N'<<endl;
}
return 0;
}AC了，那么下一题。
2. 4953 - 数论：唯一性定理 阶层约数
输入一个数字，计算出这个数字的阶乘有多少个正约数
输入
输入一行，比如3，表示3！
输出
输出1个数字，表示正约数的数量
样例
输入
3
输出
4
提示
输入数字<=100
审题：
这道题看起来简单，但事实与否。
第一个问题：虽然n<=100，但是最高上限 100！是多少呢？
我用python算了一下，结果如下：
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
这一看就超过了unsigned long long的储存长度（2^64-1），那么就要用高精度了？
错，这样会面临第二个问题：
计算麻烦，搞不好要超时
那么该怎么办？
分析：
根据唯一性定理，任何一个大于1的自然数 ，都可以唯一分解成有限个质数的乘积。
所以，我们可以将阶乘的每一个数分解质因数，再用求和公式来计算。
那么储存呢？其实，数组就绰绰有余了。
好，那么上代码：
#include<bits/stdc++.h>
using namespace std;
unsigned long long arr[1000007]= {0},n;
inline unsigned long long read() {
unsigned long long x=0,f=1;
char ch=getchar();
while(ch<'0'||ch>'9') {
if(ch=='-')
f=-1;
ch=getchar();
}
while(ch>='0' && ch<='9')
x=x*10+ch-'0',ch=getchar();
return x*f;
}
inline void work(unsigned long long n) {
for(unsigned long long i=1; i<=n; ++i) {
unsigned long long x=i;
for(unsigned long long j=2; j*j<=i; ++j) {
while(x%j==0) {
x/=j;
arr[j]++;
}
}
if(x>1) arr[x]++;
}
}
inline unsigned long long find(unsigned long long n,unsigned long long sum=1) {
for(unsigned long long i=1; i<=n; ++i) {
if(arr[i]!=0) {
sum*=(arr[i]+1);
}
}
return sum;
}
signed main() {
n=read();
work(n);
cout<<find(n)<<endl;
return 0;
}这里我用了快读和埃筛，快读我们讲贝祖定理会提到，而埃筛等会儿我们就会接触到。
提交一下，AC了。
课后练习：
3. 4954 - 数论：唯一性定理 组合数
已知C(m,n)=m!/(n!(m−n)!), 输入整数p, q, r, s(p≥q, r≥s, p, q, r, s≤10000), 计算C(p,q)/C(r,s)。输出保证不超过10^8, 保留5位小数
输入
一行4个数字分别为p q r s
输出
输出1个数字，保留5位小数
样例
输入
4 2 5 4
输出
1.20000
提示：一个个分解即可，思路与上一题一致。
好，接下来，埃筛。
埃氏筛
引入：
其实埃筛的实质就是围绕这一句话：素数的倍数不是素数
那么，我们只要判定 a [ i ] 是质数后，把他的倍数筛掉即可。
OK，讲例题。
例题精讲：
4. 4981 - 数论：质数：Goldbach’s Conjecture
哥德巴赫猜想：任何大于 4 的偶数都可以拆成两个奇素数之和。 比如： 8=3+5 20=3+17=7+13 42=5+37=11+31=13+29=19+23 你的任务是：验证小于 10^6 的数满足哥德巴赫猜想。
输入
多组数据，每组数据一个 n。
读入以 0 结束。
输出
对于每组数据，输出形如 n=a+b，其中 a,b 是奇素数。若有多组满足条件的 a,b，输出 b−a 最大的一组。
若无解，输出 "Goldbach’s conjecture is wrong."。
样例
输入
8 20 42 0
输出
8 = 3 + 5 20 = 3 + 17 42 = 5 + 37
提示
数据范围与提示：
对于全部数据，6≤n≤10^6 。
分析
很简单，先将1~n之间的素数找到，再暴力枚举即可。
OK上代码：
#include<bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize(1)
#define long long int
using namespace std;
const int N = 1000002;
int a[N];
int main() {
for(int i=1;i<=N;i++){
a[i]=1;
}
for (int i = 2; i * i <= N; i++) {
if (a[i] == 1) {
for (int j = i * i; j <= N; j += i) {
a[j] = 0;
}
}
}//埃筛
int n;
for (;;) {
cin >> n;
if (n==0) {
return 0;
}
for (int i = 3; i <= n - 3; i++) {
if (a[i] == 1 && a[n - i] == 1) {
printf("%d = %d + %d\n", n, i, n - i);
break;
}
}
}
return 0;
}OK直接ACl了。
由于埃筛不是今天的重点，我们就不深入了。
课后练习：
5. 4982 - 数论：质数：Sherlock and His Girlfriend
Sherlock 有了一个新女友（这太不像他了！）。情人节到了，他想送给女友一些珠宝当做礼物。
他买了 n 件珠宝。第 i 件的价值是 i+1。那就是说，珠宝的价值分别为 2,3,4,⋯,n+1。
Watson 挑战 Sherlock，让他给这些珠宝染色，使得一件珠宝的价格是另一件的质因子时，两件珠宝的颜色不同。并且，Watson 要求他最小化颜色的使用数。
请帮助 Sherlock 完成这个简单的任务。
输入
只有一行一个整数 n，表示珠宝件数。
输出
第一行一个整数 k，表示最少的染色数；
第二行 n 个整数，表示第 1 到第 n 件珠宝被染成的颜色。若有多种答案，输出任意一种。
样例
输入
复制
3
输出
复制
2 1 1 2
输入
复制
4
输出
复制
2 1 1 2 1
提示
样例说明
因为 2 是 4 的一个质因子，因此第一件珠宝与第三件珠宝的颜色必须不同。
数据范围与提示：
对于全部数据，1≤n≤10^5 。
注：答案详解见网址：质数：Sherlock and His Girlfriend-CSDN博客
总结：
今天我们深入了唯一性定理，并初步了解了埃筛，希望大家能认真做练习，取得更大的进步。
491
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
