【数学】【基础数论】——整除数论1

0.前言

    【大部分内容和定理摘自《深基》教材】基本都是现成的定理、定义和模版，较难内容会搭配讲解。

1.整除相关概念

1.1.定义

    设$a$和$b$为两个整数，且$a\ne 0$，如果存在另一个整数$q$，使得$b=aq$，那么就可以说b可以被a整除，记做a|b，切称$a$是$b$的因数，$b$是$a$的倍数。

    在C++中，用a%b==0表示$b$能够整除$a$。

1.2.定理

1. 若a|b且b|c，那么a|c。
2. 若a|b且b|c，那么对任意的整数$x,y$，有a|bx+cy。
3. 设$m\ne 0$，那么a|b等价于ma|mb。

2.质数与合数

2.1.定义

    设正整数$p\ne 0,1$如果它除了$1$和$p$以外没有其它的约数，那么就称$p$是质数。反之，若$a\ne 0,1$且$a$不是质数，则就称$a$是合数。

2.2.推论

    若$a=pq$，其中$p，q>1$。易证$p$、$q$中一定有一个不超过$\sqrt{a}$。

2.3.判断质数和质数筛法

2.3.1.判断质数

    设需要判断x是否是质数。枚举所有可能被x整除的数i（即$2\le i<x$）。如果x%i==0，那么就代表$x$是一个合数，直接返回假。如果直到最后都没有返回，那么它就是一个质数，直接返回真。

    当然，这个算法还有优化的方法。根据上面的$2.2$推论，我们枚举的上限只需要到$\sqrt{x}$就行了,也就是$i\le \sqrt{x}$。这里还有一个优化的办法：在计算机的四则运算中，加乘，乘方的速度要远比减除，开方要快。这里可以把i<=sqrt(x)替换成i*i<=x，以节省时间。

    证明也很简单，假设$x$是合数，则$x$必定有一对因数$x=pq$，根据性质$2$，$p$、$q$中一定有一个不超过$\sqrt{a}$。证毕。

    还有一点要注意：最小的质数是$2$，因此若x<2，则x一定不是质数。完整代码如下：

bool IsPrime(int x){
    if (x < 2) return 0; // 最小的质数是2
    for (int i = 2; i * i <= x; i++) // 注意：一定要从2开始枚举
        if (x % i == 0) // 有因数，是合数
            return 0;
    return 1; // 没有返回，是质数
}

2.3.2.埃氏筛

    埃拉托斯特尼筛法，简称埃氏筛，是一种由希腊数学家埃拉托斯特尼所提出的一种简单检定素数的算法。要得到自然数$n$以内的全部素数，必须把不大于$\sqrt{n}$的所有素数的倍数剔除，剩下的就是素数。

    回忆一下小学时的质数表。在这张表上，先将0,1这两个数划掉。然后划掉$2$的所有倍数，$3$的所有倍数，$5$的所有倍数……直到我们运用现有的质数（很好证明要筛掉质数的倍数）一直筛下去，知道筛完为止。这就是两大筛法的基础思想。

1	2	3	4	5	6	7	8	9	10
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	38	39
40	41	42	43	44	45	46	47	48	49
50	51	52	53	54	55	56	57	58	59
60	61	62	63	64	65	66	67	68	69
70	71	72	73	74	75	76	77	78	79
80	81	82	83	84	85	86	87	88	89
90	91	92	93	94	95	96	97	98	99

    代码很简单，根据上面的思路模拟再做一点小优化就行，如下：

void Eratosthenes_Sieve(vector<int>& primes, const int& n) { // 埃氏筛
	// 建立一个质数表,用is_prime[i]代表i是否是质数,先假设全部是质数 
	static vector<bool> is_prime(n + 1, 1);
	is_prime[0] = is_prime[1] = 0; // 0和1做特殊处理
	for (int i = 2; i * i <= n; i++) // 枚举每一个数
	    if (is_prime[i]) // 如果这个数是质数
    	    for (int j = i * i; j <= n; j += i) // 枚举它的倍数
    	        is_prime[j] = 0; // 将他的倍数划掉
    for (int i = 2; i <= n; i++) // 从2开始枚举 
        if(is_prime[i]) // i是质数
            primes.push_back(i);
}

    注意：在编写代码时，由于质数分布比较稀疏，所以在筛选质数时只需要筛选到sqrt(n)（记不住可以直接筛选到n，后同），后面的合数就都会筛出来。缺点是时间复杂度为$O(n\log \log n)$（详细证明较为冗长，这里就先不管）。

    埃氏筛不仅仅可以大量生成质数，而且可以找出一个数的因数的个数。请读者自行举一反三。

2.3.3.线性筛

    “线性筛”（又称“欧拉筛”）是一种高效的筛法，通常用于生成$\le n$的所有素数。相比于埃拉托斯特尼筛法（也称简单筛法），线性筛在处理大量数据时更加高效，特别是在需要生成大量素数的情况下。

    线性筛实际上也是上面提到的基本思想的优化。埃氏筛是通过质数的倍数筛取，而线性筛是通过数的质数倍筛取。设置当目前筛取的i和它的primes[j]时，i%primes[j]==0时停止，保证每个数只被它的“最大真因子”筛除。原理如下：

    当i%primes[j]==0，则$i=a\ast primes[j]$。对于下一个质数倍$primes[j+1]$，要筛去的数可以写成$i\ast primes[j+1]=a\ast primes[j]\ast primes[j+1]$。显然，a*primes[j+1]>a*primes[j]，即a*primes[j+1]>i，i*primes[j+1]可以被更大的质数筛除。因此，以i为因数的筛除停止。

void Leaner_Sieve(vector<int>& primes, const int& n) { // 欧拉筛
	// 建立一个质数表，用is_prime[i]代表i是否是质数，先假设全部是质数 
	static vector<bool> is_prime(n + 1, 1);
	is_prime[0] = is_prime[1] = 0;
	// 枚举每一个数，由于质数的分布较为稀疏，先对n/2内的因数处理就行了 
	for (int i = 2; i <= n / 2; i++) {
		if (is_prime[i]) primes.push_back(i); // i是质数
		for (int j = 0; j < primes.size() && i * primes[j] <= n; j++) { // 枚举它的质数倍 
			is_prime[i * primes[j]] = 0; // 将它的质数倍划掉
			if (i % primes[j] == 0) break;
		}
	}
	for (int i = n / 2 + 1; i <= n; i++) // 把n/2后面的质数统计下来 
	    if (is_prime[i])
		    primes.push_back(i);
}

    埃氏筛保证每一个数只被筛掉一次，因此时间复杂度为$O(n)$。

    注意：上面的埃氏筛，由于每一个数会被筛到很多次，所以可以筛到sqrt(n)就停止。但是由于线性筛的特性，要筛到n/2才能停止。

3.最大公约数与最小公倍数

3.1.定义

    设$a_1$，$a_2$是两个整数，如果$d|a_1,d|a_2$，那么$d$就称为$a_1$和$a_2$的公约数（也称作公因数），其中最大的称为$a_1$，$a_2$的最大公约数（也称作最大公因数），记作$(a_1,a_2)$。一般地，可以类似地定义$k$个整数$a_{!},a_2,...,a_k$的公约数和最大公约数，后者记作$(a_1,...,a_k)$。

    设$a_1$，$a_2$是两个整数，如果$a_1|l,a_2|l$，那么$l$就称为$a_1$和$a_2$的公倍数，其中最小的称为$a_1$，$a_2$的最小公倍数，记作$[a_1,a_2]$。一般地，可以类似地定义$k$个整数$a_1,a_2,...,a_k$的公倍数和最大公倍数，后者记作$[a_1,...,a_k]$。

3.2.定理

1. 对任意整数$m$，$(m{a}_1,...,m{a}_k)=m(a_1,...,a_k)$，即整数同时成倍放大，最大公约数也放大相同倍数。（该性质同样适用于最小公倍数情况）
2. 对任意整数$x$，$(a_1,a_2)=(a_1,a_2+x{a}_1)$，即一个整数加上另一整数的任意倍数，它们的最大公约数不变。注意：这里定义(a,0)=a。（该性质不适用于最小公倍数情况）
3. $(a_1,a_2,a_3,...a_k)=((a_1,a_2),a_3,...,a_k)$，以及一个显然的推论$(a_1,a_2,a_3,...a_{k+r})=((a_1,...,a_k),(a_{k+1},...,a_{k+r}))$。这是计算多元最大公约数的主要手段。（该性质同样适用于最小公倍数情况）
4. $(a_1,a_2)[a_1,a_2]=a_1{a}_2$，即两数的最大公因数和最小公倍数乘积等于两数乘积。

3.3.求两个数的最大公因数和最小公倍数

    借助性质$2$可以给出一个高效的求两数最大公约数的算法：每次让较大的数对较小的数取模。

（相当于较大数减了若干倍小数，最高效地利用了性质$2$，而且运用模运算时不必区分两数的大小）

    可以缩小问题规模而保持最大公约数不变，然后重复（递归）这个步骤。递归边界使某数变成了$0$，而此时另一个数即为所求答案（(a,0)=a）。代码如下：

int gcd(int x, int y){ // 求两数的最大公约数，x为较大数
    if (y == 0) return x;
    return gcd(y, x % y);
}

    非递归版本如下：

int gcd(int x, int y){// 求两数的最大公约数
    while(y){ // y=0时跳出，迭代计算
        int tmpx = x;
        x = y;
        y = tmpx % y;
    }
    return x;
}

    这种利用两数相除（取模）求最大公约数的算法叫做辗转相除法或者Eucliud算法，最坏情况下的时间复杂度为$\log max(x,y)$。绝大多数情况下，辗转相除法的时间都可以忽略不计。

    经过压行后，可以得到单行辗转相除法，代码如下：

int gcd(int x, int y){return y ? gcd(y, x % y) : x;}

    很简单，利用性质$4$，两数之积除以两数的最大公约数就可以得到两数的最小公倍数。即x*y/gcd(x,y)。

    这里还有一个优化的办法，原式中x*y有可能会溢出。因此，可以将原式变形成x/gcd(x,y)*y。这样先作除法，再作乘法，可以有效的避免数据溢出，而且因为gcd(x,y)必定是$x$的因数，所以也不用担心浮点数精度误差问题。代码如下：

int lcm(int x, int y){return x / gcd(x, y) * y;}

最后，制作不易，希望大家多多点赞收藏，关注下微信公众号，谢谢大家的关注，您的支持就是我更新的最大动力！
公众号上会及时提供信息学奥赛的相关资讯、各地科技特长生升学动态、还会提供相关比赛的备赛资料、信息学学习攻略等。