前言:
上节课我们初步学习了唯一性定理,这节课我们将深入研究并学习埃氏筛
上节课网址:数论:唯一性定理(上)-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博客
总结:
今天我们深入了唯一性定理,并初步了解了埃筛,希望大家能认真做练习,取得更大的进步。