数论知识学习总结（一）

---

注意：|：为整除符号。

一、质数

质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。

1.试除法判定质数

根据定义可知，我们只需要从$(i=1)$一直枚举到$(i=n-1)$，在循环内判断n % i == 0即可。

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

时间复杂度：$O(n)$
显然这个算法的时间复杂度是非常高的！
OK，下面我们对这个算法进行优化！

---

如果$d|n$，则$\frac{n}{d}|n$。即$n$的所有约数都是成对出现的！
ex：$n=12$，$d=3$；则3是12的约数，$\frac{12}{3}$也是12的约数！
利用这个性质我们只需要枚举$n$最小的那个约数即可：$d\le \frac{n}{d}\Rightarrow d^2\le n\Rightarrow d\le \sqrt{n}$
则我们只需要枚举到$\sqrt{n}$即可！
相关题目：AcWing 866. 试除法判定质数

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

时间复杂度：$O(\sqrt{n})$
我们将$O(n)$的时间复杂度降到了$O(\sqrt{n})$！

2.分解质因数

可以根据上一步所优化的结果进行枚举。$i$从$2$枚举到$\sqrt{n}$即可。
代码如下就不过多赘述！
相关题目：AcWing 867. 分解质因数

void get_divide(int n)
{
    for(int i = 2; i <= n / i; i ++ ) 
    {
        if(n % i == 0)
        {
            int res = 0;
            while(n % i == 0)
            {
                res ++ ;
                n /= i;
            }
            printf("%d %d\n", i, res);
        }
    }
    if(n > 1) printf("%d %d\n", n, 1);
    puts("");
}

3.筛质数

相关题目：AcWing 868. 筛质数

3.1埃氏筛法

由于一个质数只能被本身和1整除：
设$n$是以一个质数，$a,b\in Z^{+}$，$a\ne 1，a\ne n$，$b\ne 1，b\ne n$;
则$n\ne a\ast b$(即一个质数不能被除1和本身外的任何两个数的乘积所表示)，根据这个性质可得，一个质数的倍数一定是合数，我们只需筛掉每个质数的倍数，剩下的就是质数！
时间复杂度：$O(nloglogn)$

//布尔数组st[i] = false代表i这个数为质数否则为合数
void get_prime(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;
        }
    }
}

3.2线性筛法

其实我们还可以进一步的去降低时间复杂度，因为每一个合数有且仅有一个最小质因子，我们用这个最小质因子去筛，则每一个合数肯定只会被筛一次！
分类讨论：
               如果$prime(j)$是$i$的最小质因子，那就筛掉$prime(j)\ast i$，并且跳出循环；
               如果$prime(j)$不是$i$的最小质因子，因为枚举质数的时候是从小->大枚举的，所以$prime(j)$一定小于$i$的最小质因子，而$prime(j)\ast i$的最小质因子就一定是$prime(j)$，也将$prime(j)\ast i$筛掉，继续枚举到$i$的最小质因子。

时间复杂度：$O(n)$

void get_prime(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[i * primes[j]] = true;
            if(i % primes[j] == 0) break;
        }
    }
}

二、约数

约数，又称因数。整数$a$除以整数$b(b\ne 0)$除得的商正好是整数而没有余数，我们就说$a$能被$b$整除，或$b$能整除$a$。$a$称为$b$的倍数，$b$称为$a$的约数。

1.试除法求约数

$a$是一个实数，$d|a$那么$\frac{a}{d}|a$，一个数的约数一定是成对存在的！跟上面类似，只需要枚举到$\sqrt{n}$即可。
相关题目：AcWing 869. 试除法求约数

void get_divisor(int n)
{
    for(int i = 1; i <= n / i; i ++ )
    {
        if(n % i == 0)
        {
            d[cnt ++ ] = i;
            //不能重复加相同的元素
            if(i != n / i) d[cnt ++ ] = n / i;
        }
    }
}

时间复杂度：$O(\sqrt{n})$

2.约数的个数

唯一分解定理：每个大于1的自然数，要么本身就是质数，要么可以写为2个或以上的质数的积，而且这些质因子按大小排列之后，写法仅有一种方式。
设$A\in N^{+}$，$p_i$为质数，${\alpha }_i\in N$，则一定有下面这个等式：
$$A=p_1^{{\alpha }_1}\ast p_2^{{\alpha }_2}\ast \dots \ast p_n^{{\alpha }_n}$$
根据排列组合的知识可知每个$p_i$的幂都可以从$[0,{\alpha }_i]$中任取，其可选择的次数为$1+{\alpha }_i$，由此可以推出约数定理：

$$\mathrm{cnt}(A)=\left(1+{\alpha }_1\right)\ast \left(1+{\alpha }_2\right)\ast \dots \ast \left(1+{\alpha }_n\right)$$
$cnt(A)$为$A$的约数个数。
相关题目链接：acwing 871.约数的个数

#include <iostream>
#include <unordered_map>

typedef long long ULL;

using namespace std;

const int mod = 1e9 + 7;

int main()
{
    int n;
    scanf("%d", &n);
    unordered_map<int, int> primes;
    while(n -- )
    {
        int x;
        scanf("%d", &x);
        for(int i = 2; i <= x / i; i ++ )
        {
            while(x % i == 0)
            {
                primes[i] ++ ;
                x /= i;
            }
        }
        if(x > 1) primes[x] ++ ;
    }
    
    ULL res = 1;
    for(auto prim : primes) res = res * (prim.second + 1) % mod;
    
    printf("%d", res);
    
    return 0;
}

3.约数之和

约数和定理：
$$\mathrm{Sum}(A)=\left(1+p_1^1+p_1^2+\dots +p_1^{{\alpha }_1}\right)\ast \left(1+p_2^1+p_2^2+\dots +p_2^{{\alpha }_2}\right)\ast \dots \ast \left(1+p_n^1+p_n^2+\dots +p_n^{{\alpha }_n}\right)$$
其中$Sum(A)$为实数$A$的约数之和，$p_i$为质数，${\alpha }_i\in N$。
证明过程如下：

由唯一分解定理可得
$$A=p_1^{{\alpha }_1}\ast p_2^{{\alpha }_2}\ast \dots \ast p_n^{{\alpha }_n}$$
其中$A\in N^{+}$，$p_i$为质数，${\alpha }_i\in N$。

可知$p_1^{{\alpha }_1}$的约数有：$p_1^0$，$p_1^1$，$p_1^2$…$p_1^{{\alpha }_1}$
同理可得$p_k^{{\alpha }_k}$的约数有：$p_k^0$，$p_k^1$，$p_k^2$…$p_k^{{\alpha }_k}$
我们把$p_1^{{\alpha }_1}$~$p_n^{{\alpha }_n}$的所有约数都加起来，得到约数和定理
$$\mathrm{Sum}(A)=\left(1+p_1^1+p_1^2+\dots +p_1^{{\alpha }_1}\right)\ast \left(1+p_2^1+p_2^2+\dots +p_2^{{\alpha }_2}\right)\ast \dots \ast \left(1+p_n^1+p_n^2+\dots +p_n^{{\alpha }_n}\right)$$
下面我们介绍代码中所用到的秦九韶算法
设一个$n$次多项式
$$f(x)=a_n{x}^n+a_{n-1}{x}^{n-1}+\cdots +a_{1}x+a_0$$
我们可以提取公共因子$x$，改写成如下
$$\begin{array}{c}f(x)=\left(\left(a_n{x}^{n-2}+a_{n-1}{x}^{n-3}+\cdots a_{3}x+a_2\right)x+a_1\right)x+a_0\end{array}$$
一直提取$x$，改写成如下
$$\begin{array}{c}f(x)=\left(\dots \left(\left(a_{n}x+a_{n-1}\right)x+a_{n-2}\right)x+\cdots +a_1\right)x+a_0\end{array}$$
求多项式的值时，首先计算最内层括号内一次多项式的值，即
$$\begin{array}{c}{v}_2=v_{1}x+a_{n-2}\\ v_3=v_{2}x+a_{n-3}\\ ⋮\\ v_n=v_{n-1}x+a_0\end{array}$$
结论：对于一个n次多项式，至多做n次乘法和n次加法。
相关题目链接：acwing 871.约数之和

#include <iostream>
#include <unordered_map>

using namespace std;

typedef long long ULL;

const int mod = 1e9 + 7;

int main()
{
    int n;
    scanf("%d", &n);
    unordered_map<int, int> primes;
    while(n -- )
    {
        int x;
        scanf("%d", &x);
        for(int i = 2; i <= x / i; i ++ )
        {
            while(x % i == 0)
            {
                x /= i;
                primes[i] ++ ;
            }
        }
        if(x > 1) primes[x] ++ ;
    }
    
    ULL res = 1;
    for(auto prim : primes)
    {
        int p = prim.first, k = prim.second;
        ULL t = 1;
        //秦九韶算法
        while(k -- ) t = (t * p + 1) % mod;
        res = (res * t) % mod;
    }
    
    printf("%d", res);
    
    return 0;
}

4.最大公约数

设$d|ax$，$d|by$(即$d$是$ax$和$by$的因子)，那么我可以改写成$ax=td$，$by=pd$，其中$t$与$p$均为因子！
$$ax=td\text{\hspace{1em}(1)}$$
$$by=pd\text{\hspace{1em}(2)}$$
我们将(1) + (2)可得：
$$ax+by=d(t+p)\text{\hspace{1em}(3)}$$
由此我们可以得出$d|ax+by$，因为$(t+p)$是因子，所以$d$是$ax+by$的因子。（这个性质我们一会再用）
欧几里得算法：gcd(a, b) = gcd(b, a % b)
证明如下：
假设$d$是$a$，$b$的公约数那么则有$d|a$，$d|b$。
a % b实际上是$a-\frac{a}{b}\ast b$，令$\frac{a}{b}=c$，则原式可以改写成$a-c\ast b$，根据我们刚开始推到出来的性质，可以得到$d|a-c\ast b$，所以gcd(a, b) = gcd(b, a % b)。
相关题目：acwing 872.最大公约数

#include <iostream>

using namespace std;

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

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