目录
一、什么是质数
质数是指在大于1的自然数中,除了1和它本身以外不再有其他因数的自然数。
算数基本定理,也叫唯一分解定理。任何一个大于1的自然数 N,如果N不为质数,那么N可以唯一分解成有限个质数的乘积N=P1a1P2a2P3a3......Pnan,这里P1<P2<P3......<Pn均为z质数,其中指数ai是正整数。
二、如何判断质数
1.朴素法(暴力枚举)
暴力遍历[2,x)之间的所有数字,判断能否整除, 时间复杂度O(n)
bool is_prime(int x) {
if (x < 2) return false;
for (int i = 2; i < x; i++) {
if (x % i == 0) return false;
}
return true;
}
2.优化
对于一个整数n, 如果n整除p, 那么n也整除 n /p, 因此可以将枚举的范围从[0, n]降到[0, ];时间复杂度O(
)
bool is_prime(int x) {
if (x < 2) return false;
for (int i = 2; i <= x / i; i++) {
if (x % i == 0) return false;
}
return true;
}
三、分解质因数
问题:获取给定的数字n的所有质因数以及质因数的数量;即分解定理中的p和正整数a
void divide(int x) {
for (int i = 2; i <= x; i++) {
if (x % i == 0) { // i一定是一个质数
int res = 0;
while (x % i == 0) {
x /= i;
res ++;
}
cout << i << " " << res << endl;
}
}
cout << endl;
}
对于 x % i == 0此时的i一定是质数;当处理这段话的时候,x此时一定处理了[2, i - 1]之间的所有质数,即当前x不能被[2, i - 1]中的质数整除;假设i不是质数,那么肯定[2, i - 1]中的某个质数,假设不成立;所以此时 i 一定是一个质数
时间复杂度O(n)
- 如何优化?考虑将范围降到[2, ], 更改循环条件: i <= x / i
存在结论:至少存在一个质数i >=
; 假设存在两个大于
的质数的情况,那么这两个数的乘积一定大于n,假设不成立。
void divide(int x) { // logn ~ 根号n之间的时间复杂度
for (int i = 2; i <= x / i; i++) {
if (x % i == 0) { // i一定是一个质数
int res = 0;
while (x % i == 0) {
x /= i;
res ++;
}
cout << i << " " << res << endl;
}
}
if (x > 1) cout << x << " 1" << endl;
cout << endl;
}
时间复杂度O(), 但是实际上时间复杂度并不会这么高,如果n是2的整数次幂,那么在2的时候n就可以被整除,所以时间复杂度降为O(logn);因此实现的时候,只需要在最后额外判断一次就可以
四、质数筛法
1.朴素筛法
循环[2, n], 每次将i的整数倍直接筛掉
void attainPrime(int n) {
// 朴素版
for (int i = 2; i <= n; i++) {
if (!vis[i]) primes[res ++] = i; // primes用来记录质数
// 删掉i的倍数
for (int j = i + i; j <= n; j += i) vis[j] = true;
}
}
当
时,筛选次数为
, 调和级数发散,趋近于O(logn)
2. 埃式筛法
思想:相比于朴素筛,埃式筛法并不是筛掉所有[2, n]数字的倍数,而是仅仅筛掉质数的倍数
将2到n范围内的所有整数写下来。其中最小的数字2是素数。将表中所有2的倍数都划去。表中剩余的最小数字是3,它不能被更小的数整除,所以是素数。再将表中所有3的倍数都划去。依此类推
void attainPrime(int n) {
// 埃式筛法
for (int i = 2; i <= n; i++) {
if (!vis[i]) {
primes[res ++] = i;
// 只删除质数的倍数
for (int j = i + i; j <= n; j += i) vis[j] = true;
}
}
}
时间复杂度O(nlognlogn)
3.线性筛
在埃式筛法的思想基础上,每次只用最小质因子删除,保证每个数只被删除一次,这样就将时间复杂度降到了O(n)
void attainPrime(int n) {
// 埃式筛法
for (int i = 2; i <= n; i++) {
if (!vis[i]) {
primes[res ++] = i;
}
// 用最小质因子筛
for (int j = 0; primes[j] <= n / i; j++) {
vis[primes[j] * i] = true;
if (i % primes[j] == 0) break;
}
}
}
算法正确性在于:i % primes[j] (后面使用pj)
由于pj是从小到大排序的,所以pj一定是当前数的最小质因子
五、试除法求解约数
如果 d | a, 那么 d / i | a, 因此可以缩小范围
stack<int> st;
for (int i = 1; i <= x / i; i++) {
if (x % i == 0) {
cout << i << " ";
if (x / i != i) st.push(x / i);
}
}
// i 是从小到大枚举的,所以通过stack将 x / i 逆序
while (st.size()) {
cout << st.top() << " ";
st.pop();
}
六、约数的个数以及约数之和
约数个数: 根据唯一分解定理,每一个x都可以分解成质因子的整数次幂的乘积。相应的每一个质因子的整数次幂就是个数,乘积的约数个数就是(a1 + 1)* (a2 + 1) * ... * (an + 1)
LL res = 1;
unordered_map<int, int> um;
while (n --) {
int x;
cin >> x;
for (int i = 2; i <= x / i; i++) {
while (x % i == 0) {
x /= i;
um[i] ++;
}
}
if (x > 1) um[x] ++;
}
for (auto m : um) {
res = res * (m.second + 1) % MOD;
}
约数之和:根据唯一分解定理,每一个x都可以分解成质因子的整数次幂的乘积。相应的每一个质因子的整数次幂就是个数,乘积的约数之和就是(a1^0 + a1 ^ 1 + ... + a1 ^ n)* (a2^0 + a2 ^ 1 + ... + a2 ^ n)* (an^0 + an ^ 1 + ... + an ^ n)
LL res = 1;
unordered_map<int, int> um;
while (n --) {
int x;
cin >> x;
for (int i = 2; i <= x / i; i++) {
while (x % i == 0) {
x /= i;
um[i] ++;
}
}
if (x > 1) um[x] ++;
}
for (auto m : um) {
int p = m.first, number = m.second;
LL res1 = 1;
while (number --) res1 = (p * res1 + 1) % MOD;
res = res * res1 % MOD;
}
七、欧几里得算法(辗转相除法)
关键公式:gcd(a, b) = gcd(b, a % b)
int gcd(int a, int b) {
return b ? gcd(b, a % b) : a;
}
总结
emmm,简单整理下质数的学习,判断质数,分解质因子以及几种筛法,数学证明自己也并没完全掌握,希望在整理过程中能够加深理解。书写中还会存在不严谨的地方,还望指正。
描述的都是一些模板题,我还在初学当中
题目均来自Acwing官网,可以参考学习 AcWing一个专属于程序员的平台,为大家在漫漫的刷题之旅中,提供最优质的解答https://www.acwing.com/about/