算法基础9 —— 数论 (倍数 + 约数 + 素数(埃氏筛法) + 欧几里得与拓展欧几里得算法 + 快速幂)

数论 - 倍数

定义： 对于自然数a和b，如果存在自然数k，使得k * a = b，那么称b是a的倍数

性质：

• 一个数有无穷多个倍数
• 所有数都是其自身和1的倍数(任意一个整数x，一定有 1 * x = x)
• [1,n]范围内的x的倍数一共有n/x(向下取整)个

举例说明第三条性质：
例1： 取n = 12，x = 2,设在区间[1,12]内2的倍数最多有k个，则2 * k <= 12，即k <= 6。[1,12]内2的倍数一共有6个，分别为2( 1 * 2 )，4( 2 * 2 )，6( 3 * 2 )，8( 4 * 2 )，10( 5 * 2 )，12( 6 * 2 )

例2： 取n = 12，x = 5,设在区间[1,12]内5的倍数最多有k个，则5 * k <= 12，即k <= 2.4。[1,12]内5的倍数一共有2个，分别为5，10

---

数论 - 约数

定义： 对于自然数a和b，如果b是a的倍数，那么a是b的约数（因数）
如，对于自然数18和3，18是3的倍数，3是18的约数

性质：

• 所有数的约数都包含自身和1
• 一个自然数n的约数为有限个，记为d(n)
• 1的约数有1个 —— 1
  2的约数有2个 —— 1、2
  3的约数有2个 —— 1、3
  4的约数有3个 —— 1、2、4
  5的约数有2个 —— 1、5
  6的约数有4个 —— 1、2、3、6
  7的约数有2个 —— 1、7
  8的约数有4个 —— 1、2、4、8
  9的约数有3个 —— 1、3、9
  10的约数有4个 —— 1、2、5、10
  综上，n与d(n)的关系如下表(n <= 10)

算法设计以及图解：

• 用一个数组d[N]来存储结果，d[i]表示元素i的约数的个数
• 设置两个变量i和j，初始时i = 1，变量i每次自增1。此时令j = 1，然后执行d[j]++，执行完之后令j += 1。可以得到如下结果：
  
• 执行完上步之后i = 2，此时令j = 2，然后执行d[j]++，执行完之后令j += 2。可以得到如下结果：
  
• 执行完上步之后i = 3，此时令j = 3，然后执行d[j]++，执行完之后令j += 3。可以得到如下结果：
  
• 执行完上步之后i = 4，此时令j = 4，然后执行d[j]++，执行完之后令j += 4。可以得到如下结果：
  
• 执行完上步之后i = 5，此时令j = 5，然后执行d[j]++，执行完之后令j += 5。可以得到如下结果：
  
• 执行完上步之后i = 6，此时令j = 6，然后执行d[j]++，执行完之后令j += 6。可以得到如下结果：
  
• 执行完上步之后i = 7，此时令j = 7，然后执行d[j]++，执行完之后令j += 7。可以得到如下结果：
  
• 执行完上步之后i = 8，此时令j = 8，然后执行d[j]++，执行完之后令j += 8。可以得到如下结果：
  
• 依次类推，接着执行i = 9，i = 10，最终得到下表
  

代码实现：

#include <iostream>

using namespace std;

const int N = 50;
int d[N];

//打表,时间复杂度O(nlogn)
void cal_div(int u)//计算u的约数的个数
{
    for (int i = 1;i <= u;i++)//用i'指针'来枚举1 ~ n
        for (int j = i;j <= u;j += i)//用j'指针'来计算结果
            d[j]++;
}

int main()
{
    int n;
    cin >> n;
    cal_div(n);
    for (int i = 1;i <= n;i++) cout << d[i] << endl;
    return 0;
}

---

数论 - 素数、合数

定义： 如果一个数的约数只有两个（1和其自身），那么称它为素数（质数）

思考？如何判断一个数x是不是素数？
通过定义得知，如果在[2，x - 1]中存在一个数i，使得x % i == 0 ，那么x不是素数(最暴力的方法)

定义 ： 如果一个数有非平凡（除了1和自身以外）的约数，那么称它为合数

性质：

• 1既不是素数也不是合数
• 判断一个数x是否为素数，只需要枚举[2,sqrt(x)]中是否有它的约数。若没有，则为素数；若有，则不为素数

素数？素素？我跑偏了~

直男福利来喽 ~ (你们小时候喜欢玉漱呢还是喜欢素素呢？)
答应我，等会去听神话。下面言归正传

代码实现判断一个数是否为质(素)数:

#include <iostream>

using namespace std;

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

int main()
{
    int n;
    cin >> n;
    if (is_prime(n)) cout  << n << " is prime" << endl;
    else cout << n << " is not prime";
    return 0;
}

---

素数筛法(朴素筛法以及埃氏筛法)

通过一个例题来引入素数筛法：打印质数表

输入一个自然数N，按质数定义从小到大输出1 ~ N（包含N）中所有的质数

在朴素筛法中，将2的倍数去掉时，会去掉4、6、8；之后，将4的倍数去掉时，又会去掉8；将3的倍数去掉时，又会去掉6… … 故朴素筛法中存在多个重复操作，可以优化，后来诞生了埃氏筛法。

埃氏筛法代码模板：时间复杂度：O(nloglogn)

#include <iostream>
using namespace std;
int prime[2010];
int main()
{
    int n;
    cin >> n;
    for (int i = 2;i <= n;i++)//从2开始判断
    {
        if (prime[i] == 0)//为0：是素数 
        {
            cout << i << " ";
            for (int j = i + i;j <= n;j += i)
                prime[j] = 1;//不为0：不是素数
        }
    }
    return 0;
}

---

欧几里得算法(辗转相除法)

引言：有两个整数 a，b，求 a，b 的最大公约数

欧几里得定理： gcd(a, b) = gcd(b , a % b)

//欧几里得算法模板
int gcd(int a,int b)
{
    if (b == 0) return a;
    return gcd(b,a % b);
}

---

扩展欧几里得算法

裴蜀定理(又叫贝祖定理)：

已知整数a、b，能找到整数x、y(其中一个很可能是负数)，使它们满足等式ax + by = gcd(a, b)
特别的，当ax + by = 1有解时，则a与b互质(约数只有1)

例如，gcd(2,3) = 1，当a = 2,b = 3(a、b互质)的时候，存在x = -1,y = 1，使得ax + by = gcd(2，3) = 1

127X + 97Y = 1，此不定方程有无数解，我们只要找到一对解（x0,y0），那么就可以求解出他们的通解。

总结扩展欧几里德算法应用

• 求解不定方程48X + 36Y = 12(拓展欧几里得算法不仅会返回最大公约数，还会返回一个线性方程的一对特解)
• 求解模线性方程(线性同余方程)
• 求解模的逆元

求解不定方程

A * x + B * y = gcd(A,B)

例1： 取A = 48，B = 36，则gcd(A，B) = 12。对于方程48 * x + 36 * y = 12，判断这个方程是否有解

例2： 取A = 127，B = 97，则gcd(A，B) = 1。对于方程127 * x + 97 * y = 1，此不定方程有无数解，只要找到一对解(x0,y0),那么就可以求解出他们的通解

分析：

给定两个整数a和b，可以使用欧几里得算法求出他们的最大公约数gcd(a，b)。现在还希望找到一对x和y，使得ax + by = gcd(a, b)成立

首先，整数a和0的最大公约数一定是a

• a / a = 1
• 0 / a = 0

也就是说

当b = 0时，gcd(a，b) = gcd(a，0) = a;此时x = 1,y = 0(A * 1 + B * 0 = A)

设方程

A * x1 + B * y1 = gcd(A,B)

有方程

B * x2 + (A % B) * y2 = gcd(B，A % B)

由于

gcd(A,B) = gcd(B,A % B)

因此

A * x1 + B * y1 = B * x2 + (A % B) * y2

又因为

B * x2 + (A % B) * y2 
= B * x2 + (A - A / B * B ) * y2 
= A * y2 + B * x2 - A / B * B * y2
= A * y2 + B * (X2 - A / B * y2)

补充：为什么A % B = A - A / B * B ？？

• 以A = 127，B = 97为例
• 127 % 97 = 30
• 127 - 127 / 97 * 97 = 127 - 1 * 97 = 127 - 97 = 30

所以

A * x1 + B * y1 = A * y2 + B * (X2 - A / B * y2)

比较系数可以得到

x1 = y2;
y1 = X2 - A / B * y2;

这也就得到了x1和y1的值。以上思想以递归定义，函数gcd不断递归求解，一定会有个时候b = 0，此时递归结束

#include <iostream>

using namespace std;

//拓展欧几里得算法求解不定方程的解
//例如127 * x + 97 * y = 1一定有解(取x等于某个值可以解得一个唯一对应的y)
int exgcd(int a,int b,int &x,int &y)
{
    if (b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
    
    int ans = exgcd(b,a % b,x,y);
    int temp = x;
    x = y;
    y = temp - a / b * y;
    return ans;
}

int main()
{
    int a,b,x,y;
    cin >> a >> b; 
    cout << exgcd(a,b,x,y) << endl;
    cout << x << " " << y << endl;
    return 0;
}

---

快速幂见另一篇博客