[AcWing]，数学知识（一）质数与约数_质数和约数

https://www.acwing.com/activity/content/punch_the_clock/11/

质数

质数，在大于1的整数中，有且只有1和他本身两个因数的数，也叫做素数

试除法判定质数

三种写法 $O(sqrt(n))$

1. $sqrt(x)$，函数计算的时间比较高

bool is_prime(int x) {
    // 质数大于1
    if(x < 2) return false;
    for(int i = 2; i <= sqrt(x); i++) {
        if(x % i == 0) return false;
    }
    return true;
}
1
2
3
4
5
6
7
8

2. $i\times i\le x$

bool is_prime(int x) {
    // 质数大于1
    if(x < 2) return false;
    for(int i = 2; i * i <= x; i++) {
        if(x % i == 0) return false;
    }
    return true;
}
1
2
3
4
5
6
7
8

可能会出现TLE情况

3. $i\le n/i$

$i\le \sqrt{x}$
$\Rightarrow i^2\le x$
$\Rightarrow i\le \frac{x}{i}$

bool is_prime(int x) {
    // 质数大于1
    if(x < 2) return false;
    for(int i = 2; i <= x / i; i++) {
        if(x % i == 0) return false;
    }
    return true;
}
1
2
3
4
5
6
7
8

分解质因数

时间复杂度$O(sqrt(n))$
最坏情况：$n=2^k$，此时时间复杂度为：$O(lo{g}_{2}n)$
最快情况：时间复杂度为：$O(\sqrt{n})$

做法就是，从$i=2$开始，如果当前数存在$i$这个因子，那么就记录当前数中存在多少个$i$的因子，最后整除掉。

可以证明，$n$中最多包含$1$个大于$sqrt(n)$的质因子$x$；
如果有两个，那么 $x\times x>n$，所以说最多含有一个大于$sqrt(n)$的质因子，那就是最后无法整除的一个质因数

如果对于一个数$p$而言，当for循环遍历到$i=p$时，就说明$p$在$2\to p-1$中，没有一个因子，所以说$p$是一个质数

void divide(int x) {
    
    for(int i = 2; i <= x / i; i ++) {
        if(x % i == 0) {
            int cnt = 0;
            while(x % i == 0) {
                cnt ++;
                x /= i;
            }
            printf("%d %d\n",i,cnt);
        }
    }
    
    if(x > 1) printf("%d 1\n",x);
    puts("");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

筛质数

时间复杂度$O(n\log n)$

$\frac{n}{2}+\frac{n}{3}+...+\frac{n}{n}$
$\Rightarrow$ $n\times (\frac{1}{2}+\frac{1}{3}+...+\frac{1}{n})$（调和级数）
$\Rightarrow$ $n\times (\ln n+C)$
$\Rightarrow$ $n\times \ln n$
$\Rightarrow$ $n\times {\log }_{e}n$ $<n\times {\log }_{2}n$

void get_prime() {
    int cnt = 0;
    for(int i = 2; i <= n; i++) {
        if(f[i] == 0) 
            cnt ++;
        // 标记 i 的倍数
        for(int j = i; j <= n; j += i)
            f[j] = 1;
    }
    
    printf("%d\n",cnt);
}
1
2
3
4
5
6
7
8
9
10
11
12

但实际上，对于不是质数的数，我们没有必要进入循环判断，所以可以优化一下

这样的时间复杂度为$O(n\log \log n)$（埃拉托斯特尼筛法）
用质数就把所有的合数都筛掉

$1\to n$有$\frac{n}{lnn}$个质数，时间复杂度近似为$O(n\log \log n)$

什么概念呢，当$n=2^{32}$时，$O(n\log \log n)=5$

void get_prime() {
    int cnt = 0;
    for(int i = 2; i <= n; i++) {
        if(f[i]) continue;
        cnt ++;
        // 标记 i 的倍数
        for(int j = i; j <= n; j += i)
            f[j] = 1;
    }
    
    printf("%d\n",cnt);
}
1
2
3
4
5
6
7
8
9
10
11
12

线性筛选

$n$只会被自己的最小质因子筛选掉

1. i % prime[j] == 0，$prime[j]$定为$i$最小质因子，$prime[j]$也定为$prime[j]\times i$最小质因子
2. i % prime[j] != 0，$prime[j]$定小于$i$的所有质因子，所以$prime[j]$也为$prime[j]\times i$最小质因子

每一次向前标记的过程中，都是只遍历到自己的第一个质因子为止，因为标记的过程是在判断之前，所以保证了一定使用了最小质因子对下一个合数进行了标记。

极大减少了重复标记的次数

比如说在埃氏筛选中，$6$会被 2 和 3进行标记，这就发生了重复标记。
而线性筛选就避免了这一情况

void get_prime() {
    int cnt = 0;
    for(int i = 2; i <= n; i++) {
        if(!f[i]) prime[cnt ++] = i;
        // 线性筛选，枚举所有的质数
        for(int j = 0; prime[j] <= n / i; j++) {
            f[prime[j] * i] = 1;
            if(i % prime[j] == 0) 	//prime[j]一定是i的最小质因子
            	break; 
        }
    }
    
    printf("%d\n",cnt);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在$n=10^7$时，线性筛选法大概会比埃氏筛选法快一倍

约数

试除法求约数

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

void get_divisors(int x) {
    vector<int> f;
    for(int i = 1; i <= x / i; i++)
        if(x % i == 0) {
            f.push_back(i);
            if(i != x / i) f.push_back(x / i);
        }
    sort(f.begin(),f.end());
    
    for(auto& e : f) {
        cout << e << " ";
    }
    puts("");
}

int main() {
    int n, x;
    cin >> n;
    
    while (n --) {
        cin >> x;
        get_divisors(x);
    }
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

约数的个数

对于每一个数$N$，都可以分解为$N=p_1^{{\alpha }_1}\times p_2^{{\alpha }_2}\times \cdots \times p_k^{{\alpha }_k}$
其中，$p_1{p}_2\cdots p_k$为质数，${\alpha }_1{\alpha }_2\cdots {\alpha }_k$为对应的质数的出现次数

所以说，最终的结果可以表示为 $ans=({\alpha }_1+1)\times ({\alpha }_2+1)\times \cdots \times ({\alpha }_k+1)$

为什么要$+1$，因为对于每一项$p$，他对于最终的数$n$的贡献度来说，一共贡献了$\alpha +1$次，包括他出现的$\alpha$次与不出现的$1$次

#include <iostream>
#include <algorithm>
#include <unordered_map>

using namespace std;

typedef long long LL;
const int mod = 1e9 + 7;

int n;

int main() {
    cin >> n;
    
    unordered_map<int,int> primes;
    while ( n -- ) {
        int x;
        cin >> x;
        
        for(int i = 2; i <= x / i; i++) 
            while(x % i == 0) {
                primes[i] ++;
                x /= i;
            }
        if(x != 1) primes[x] ++;
    }
    
    LL res = 1;
    for(auto& e : primes) 
        res = (res * (e.second + 1) ) % mod;
        
    cout << res << endl;
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

约数之和

同理，对于每一个数$N$，都可以分解为$N=p_1^{{\alpha }_1}\times p_2^{{\alpha }_2}\times \cdots \times p_k^{{\alpha }_k}$，他的约数的个数可以分解为$ans=({\alpha }_1+1)\times ({\alpha }_2+1)\times \cdots \times ({\alpha }_k+1)$

那么约数之和，可以分解为：$(p_1^0+p_1^1+p_1^2+\cdots +p_1^{{\alpha }_1})\times (p_2^0+p_2^1+p_2^2+\cdots +p_2^{{\alpha }_2})\times \cdots \times (p_k^0+p_k^1+p_k^2+\cdots +p_k^{{\alpha }_k})$

对于求约数之和，我们可以使用秦九昭算法来做：

对于约数：$p_k^0+p_k^1+p_k^2+\cdots +p_k^{{\alpha }_k}$
可以化简为：$1+p_k\times (1+p_k^1+p_k^2+\cdots +p_k^{k-1})$
$\Rightarrow 1+p_k\times (1+p_k\times (1+p_k^1+p_k^2+\cdots +p_k^{k-2}))$
$\Rightarrow 1+p_k\times (\cdots \times (1+p_k\times (1+p_k))\cdots )$

其中，一共累乘的$p_k$的数量为$k$个

#include <iostream>
#include <algorithm>
#include <unordered_map>

using namespace std;

typedef long long LL;
const int mod = 1e9 + 7;

int main() {
    int n;
    cin >> n;
    unordered_map<int,int> primes;
    while ( n -- ) {
        int x;
        cin >> x;
        for(int i = 2; i <= x / i; i++)
            while(x % i == 0) {
                primes[i] ++;
                x /= i;
            }
        if(x != 1) primes[x] ++;
    }
    
    LL res = 1;
    for(auto& e : primes) {
        int cnt = e.second, p = e.first;
        LL t = 1;
        while ( cnt -- ) {
            t = (1 + t * p) % mod;
        }
        res = (res * t) % mod;
    }
    
    cout << res << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

最大公约数

$d/a，d/b$，那么$d/(a+b)$，同理，$d/(a\times x+b\times y)$

$\Rightarrow d/(a，b)\to d/(b，a-c\times b)$

#include <iostream>

using namespace std;

int gcd(int a,int b) {
    if(a < b) 
        return gcd(b,a);

    if(b == 0) return a;
    
    return gcd(b,a % b);
}

int main() {
    int n;
    cin >> n;
    while(n --) {
        int a,b;
        cin >> a >> b;
  
        cout << gcd(a,b) << endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24