【数学知识】—— 质数/约数

最新推荐文章于 2023-02-04 14:00:09 发布

玄澈_

最新推荐文章于 2023-02-04 14:00:09 发布

阅读量907

点赞数 16

分类专栏： # ACM算法 - 数学知识 ACM算法笔记文章标签：算法 c++ 数据结构数论蓝桥杯

本文链接：https://blog.csdn.net/forever_bryant/article/details/126206812

版权

ACM算法笔记同时被 2 个专栏收录

31 篇文章 8 订阅

订阅专栏

ACM算法 - 数学知识

2 篇文章 0 订阅

订阅专栏

质数

若一个正整数无法被1和它自身之外的任何自然数整除，则称该数为质数（或者素数），否则则称该正整数为合数。

在整个自然数集合中，质数的数量不是很多，分布比较稀疏，对于一个足够大的整数 N ，不超过 N 的质数大约有 N/lnN 个，即每 lnN 个数中大约有 1 个质数。

质数的判断

试除法

若一个正整数 N 为合数，则存在一个能整除 N 的数 T，其中 $\small 2\leq T\leq \sqrt{N}$

证明：

由定义可得，N 是合数，所以存在一个能整除 N 的整数 M，其中 $\small 2\leq M\leq N-1$ .

反证法。假设命题不成立，那么这样的数 M 一点满足 $\small \sqrt{N}+1\leq M\leq N-1$ 。因为 M 能整除 N，所以他们的商 N/M 也能整除 N。而 $\small 2\leq N/M\leq \sqrt{N}$ ，令 T=N/M, 这与假设矛盾。故假设不成立，原命题成立。

证毕

根据上述命题，我们只需要扫描 $\small 2\sim \sqrt{N}$ 之间的所有整数，依次检查他们能否整除 N，若都不能整除，则 N 是质数，否则 N 是合数。试除法的时间复杂度是 $\small O(\sqrt(N))$ 。

当然，我们要特判 0 和 1 两个整数，他们既不是质数，也不是合数。

AcWing 866. 试除法判定质数

输入样例：
2
2
6
输出样例：
Yes
No

#include <iostream>
#include <algorithm>

using namespace std;

bool is_prime(int n)
{
    if(n < 2) return false;
    for(int i = 2; i <= n / i; i ++ )
        if(n % i == 0)
             return false;
    return true;
}

int main()
{
    int T; cin >> T;
    while(T -- )
    {
        int x; cin >> x;
        if(is_prime(x)) puts("Yes");
        else puts("No");
    }
    
    return 0;
}

分解质因数——试除法

算术基本定理

任何一个大于1的正整数都能分解成有限个质数的乘积，可写作：

$N=p_1^{c_1}p_2^{c_2}...p_m^{c_m}$

其中，ci 都是正整数， pi 都是质数，且满足 $p_1<p_2<...<p_m$

试除法

结合质数判定的“试除法”，我们可以扫描 $\small 2\sim[\sqrt{N}]$ 的每个数 d，若 d 能整除 N，则从 N 中除掉所有的因子 d，同时计算累计除去 d 的个数。

因为一个合数的因子一定在扫描到这个合数之前就从 N 中被除掉了，所以在上述过程中能被整除 N 的一定都是质数。最终就得到了分解质因数的结果，时间复杂度是 $\small O(\sqrt{N})$ 。

特别的，如果 N 没有被任何 $\small 2\sim[\sqrt{N}]$ 的数整除，则 N 是质数，无需分解。

AcWing 867. 分解质因数

输入样例：
2
6
8
输出样例：
2 1
3 1

2 3

#include <iostream>
#include <algorithm>

using namespace std;

void divide(int n)
{
    for(int i = 2; i <= n / i; i ++ )
        if(n % i == 0)  //i一定是质数
        {
            int s = 0;
            while(n % i == 0)
            {
                n /= i;
                s ++;
            }
            printf("%d %d\n",i,s);
        }
    if(n > 1) printf("%d %d\n",n,1);
    puts("");
}

int main()
{
    int n;
    cin >> n;
    while(n --)
    {
        int x;
        scanf("%d",&x);
        divide(x);
    }
    return 0;
}

埃氏筛（质数）

埃氏筛是基于这样的想法：任意整数 x 的倍数 2x, 3x, ... 都不是质数，根据质数的定义，上述想法显然成立。时间复杂度是 O(NloglogN)

要得到自然数n以内的全部素数，必须把不大于根号n的所有素数的倍数剔除，剩下的就是素数。

TIP：我们不是去找某个数的素数因子，而是通过素数因子来判断一堆数是不是合数

优化原因：因为合数的倍数也是素数的倍数，所以我们只需要找到所有的素数来进行排除即可，不用利用所有的数来进行排除。

void get_primes(int n)
{
    for(int i = 2; i <= n; i ++ )
    {
        if(!st[i])
        {
            primes[cnt ++ ] = i;
            for(int j = i + i; j <= n; j += i ) st[j] = true;
        }
    }
}

线性筛

对于埃氏筛，即使是在优化后，仍然会重复标记合数，例如：12既会被2标记也会被3标记，在标记2的时候，12=6*2；在标记3的时候，12=4*3。

其根本原因是我们没有确定出唯一的产生12的方式。

线性筛法通过“从小到大累计质因子”的方式标记每个合数，即让12只有3*2*2一种产生方式。

① i % pj == 0

pj 一定是 i 的最小质因子，pj 也一定是 pj * i 的最小质因子

② i % pj != 0

pj 一定小于 i 的所有质因子，pj 也一定是 pj * i 的最小质因子

void get_primes(int n)
{
    for(int i = 2; i <= n; i ++ )
    {
        if(!st[i]) primes[cnt ++ ] = i;
        for(int j = 0; primes[j] <= n / i; j ++ )
        {
            st[primes[j] * i] = true;
            if(i % primes[j] == 0) break; // primes[j] 一定是i的最小质因子
        }
    }
}

约数

若整数 n 满足除以整数d 的余数为 0，即 d 能整除 n ，则称 d 是 n 的约数， n 是 d 的倍数，记为 d | n。

AcWing 869. 试除法求约数

输入样例：
2
6
8
输出样例：
1 2 3 6 
1 2 4 8 

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

using namespace std;

vector<int> get_divisors(int n)
{
    vector<int> res;
    
    for(int i = 1; i <= n / i; i ++ )
        if(n % i == 0)
        {
            res.push_back(i);
            // 特判平方根的条件
            if(i != n / i) res.push_back(n / i);
        }
    sort(res.begin(), res.end());
    return res;
}

int main()
{
    int n; cin >> n;
    while(n -- )
    {
        int x; cin >> x;
        auto res = get_divisors(x);
        for(auto t : res) cout << t << ' ';
        cout << endl;
    }
    return 0;
}

（约数）算数基本定理的推论

在算数基本定理中，若正整数 N 被唯一分解为 $N=p_1^{c_1}p_2^{c_3}...p_m^{c_m}$ ，其中，ci 都是正整数， pi 都是质数，且满足 $p_1<p_2<...<p_m$ ，则 N 的正约数集合可写作：

{ $p_1^{b_1}p_2^{b_2}...p_m^{c_m}$ }，其中 $0\leq b_i\leq c_i$

N 的正约数个数是

$\large (c_1+1)*(c_2+1)*...*(c_m+1)=\prod_{m}^{i=1}(c_i+1)$

N 的所有正约数的和是：

$\large (1+p_1 + p_1^2+...+p_1^{c_1})*...*(1+p_m + p_m^2+...+p_1^{c_m})=\prod_{m}^{i=1}(\sum_{j=0}^{c_i}(p_i)^j)$

理解：从每个质因数中依次选择一个项数，根据乘法原理，凑成所有的数然后相加

AcWing 870. 约数个数

输入样例：
3
2
6
8
输出样例：
12

#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)
            {
                x /= i;
                primes[i] ++ ;
            }
        if(x > 1) primes[x] ++ ;
    }
    
    LL res = 1;
    for(auto prime : primes) res = res * (prime.second + 1) % mod;
    
    cout << res << endl;
    return 0;
}

AcWing 871. 约数之和

输入样例：
3
2
6
8
输出样例：
252

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

using namespace std;

typedef long long LL;

const int N = 110, 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)
            {
                x /= i;
                primes[i] ++ ;
            }

        if (x > 1) primes[x] ++ ;
    }

    LL res = 1;
    for (auto p : primes)
    {
        LL a = p.first, b = p.second;
        LL t = 1;
        while(b -- ) t = (t * a  + 1) % mod;
        res = res * t % mod;
    }

    cout << res << endl;

    return 0;
}

最大公约数

定义

若自然数 d 同时是自然数 a 和 b 的约数，则称 d 是 a 和 b 的公约数。在所有的 a 和 b 的公约数中最大的一个，称为 a 和 b 的最大公约数，记为 gcd(a, b).

若自然数 m 同时是 a 和 b 的倍数，则称 m 是 a 和 b 的公倍数。在所有的 a 和 b 的公约数中最小的一个，称为 a 和 b 的最大公约数，记为 lcm(a, b).

同理，我们可以定义三个数以及更多个数的最大公约数，最小公倍数。

定理

$\large \forall a,b \epsilon \mathbb{N}$ $\large gdc(a,b)*cm(a,b)=a*b$

证明：

设 $\small d=gcd(a,b),a_0=a/d,b_0=b/d$ 。根据最大公约数的定义，有 $\small gcd(a_0,b_0)=1$ ，再根据最小公倍数的定义，有 $\small lcm(a_0,b_0)=a_0*b_0$

于是 $lcm(a,b)=lcm(a_0*d,b_0*d)=lcm(a_0,b_0)*d=a_0*b_0*d=a*b/d$

证毕

九章算术·更相减损术

$\small \forall a,b\epsilon \mathbb{N},a\geq b$ 有 $\small gcd(a,b)=gcd(b,a-b)=gcd(a,a-b)$

$\small \forall a,b\mathbb{N}$ 有 $\small gcd(2a,2b)=2gcd(a,b)$

证明：

根据最大公约数的定义，后者显然成立，我们主要证明前者。

对于 a，b 的任意公约数 d ，因为 d|a, d|b，所以 d|(a - b) 。因此 d 也是 b , a - b 的公约数。反之亦成立。故 a，b 的公约数集合和 b, a - b 的公约数集合相同。于是他们的最大公约数也相同，对于 a， a - b 同理。

证毕。

欧几里得算法

$\large \forall a,b\epsilon \mathbb{N},b\neq 0,gcd(a,b)=gcd(b,a \; mod\; b)$

证明：

若 a < b， $gcd(b,a \;mod\;b)=gcd(b,a)=gcd(a,b)$ ，命题成立。

若 a >= b，不妨设 a = q * b + r，其中 0 <= r < b。显然 r = a mod b。对于 a, b 的任意公约数 d，因为 d | a. d | b, 故 d | (a - qb)，即 d | r，因此 d 也是 b, r 的公约数。反之亦成立。故 a，b 的公约数集合与 a , a mod b 的公约数集合相等。于是他们的最大公约数也相等。

证毕。

AcWing 872. 最大公约数

输入样例：
2
3 6
4 6
输出样例：
3
2

#include <iostream>

using namespace std;

int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

int main()
{
    int n;
    cin >> n;
    while(n --)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        printf("%d\n",gcd(a,b));
    }
}