第八节 数论

最大公约数

1、求最大公约数
欧几里得算法——辗转相除法
（a, b) 最大公约数gcd(a, b) 最小公约数lcm(a, b)
理论基础：gcd(a, b) = gcd(b, a mod b)

//核心代码
int gcd(int a, int b)
{	
	return b > 0 ? gcd(b, a % b) : a;
}

AcWing 1246. 等差数列

数学老师给小明出了一道等差数列求和的题目。

但是粗心的小明忘记了一部分的数列，只记得其中 N 个整数。

现在给出这 N 个整数，小明想知道包含这 N 个整数的最短的等差数列有几项？

输入格式
输入的第一行包含一个整数 N。

第二行包含 N 个整数 A1,A2,⋅⋅⋅,AN。(注意 A1∼AN 并不一定是按等差数
列中的顺序给出)

输出格式
输出一个整数表示答案。

数据范围
2≤N≤100000,
0≤Ai≤109
输入样例：
5
2 6 4 10 20
输出样例：
10
样例解释
包含 2、6、4、10、20 的最短的等差数列是 2、4、6、8、10、12、14、16、18、20。

思路

等差数列：a1 , a1 + d, a1 + 2d, … ,a1 + nd;
找到最大公差是多少，

代码

import java.util.*;

public class Main {
    static final int N = 100010;
    static int n;
    static int[] a = new int[N];
    
    static int gcd(int a, int b) {
        return b > 0 ? gcd(b, a % b) : a;
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        for (int i = 0; i < n; i ++ ) {
            a[i] = in.nextInt();
        }
        Arrays.sort(a, 0, n);
        int d = 0;
        for (int i = 1; i < n; i ++ ) {
            d = gcd(d, a[i] - a[0]);
        }
        
        if (d == 0) System.out.print(n);
        else {
            n = (a[n - 1] - a[0]) / d + 1;
            System.out.print(n);
        }
    }
}

算术基本定理

质因数分解：

AcWing 1295. X的因子链(需要加深理解)

输入正整数 X，求 X 的大于 1 的因子组成的满足任意前一项都能整除后一项的严格递增序列的最大长度，以及满足最大长度的序列的个数。

输入格式
输入包含多组数据，每组数据占一行，包含一个正整数表示 X。

输出格式
对于每组数据，输出序列的最大长度以及满足最大长度的序列的个数。

每个结果占一行。

数据范围
1≤X≤220
输入样例：
2
3
4
10
100
输出样例：
1 1
1 1
2 1
2 2
4 6

思路

类似等比数列: a1, a2, a3,…,an;
设质因数为pi，
a1, a1 * p1, a1 * p1 * p2, … , a1* p1* … * pn

例如 2² X 3³ X 5,
共有6！种排列方式
但有部分是重复的，例如2有两个，这个两个数的位置可以交换，所以我们把相同的组归为一类，然后每一类共有：2! X 3! 个，共有6! / 2!X3! 个类

上面如何理解呢？
对于原序列 a1, a2, a3, … , an
都有一个类似差分序列的序列（暂且称为除分数组）：a1, a2/a1, a3/a1,… , an/ an - 1,这个序列的每个数对应的是X的质因子；为了保证后一项能整除前面任意一项，所以后面的每一项，都要乘与它前面的所有项，这样既保证了能整除，也保证了序列是递增的，然后我们最长序列就等于质因数之和，而如何求有多少个满足最长序列的不同序列呢？从除分数组转为原数组，例如第2项a2/a1要变回a2，需要乘上a1,所以，对于这些除分数组，不论他们的位置如何交换，后一项都会比前一项大an-1倍，所以我们求不同的最长序列就是求除分数组的全排列，注意要去重。举个例子：
对于 10 这个数：
它有三个因数 2， 5， 10，其中有2个质因数，然后我们对质因数进行排列
2， 5
5， 2
以上序列属于除分序列（除分数组）
变回原数列为：
2, 2 * 5（10）
5, 5 * 2 (10)
所以答案为：
最长序列为：2；
最长序列有2种；

直接分解质因数的话会很大，不好分解
知识点：
筛法求质数——线性筛法，


代码模板

public class Main {
    static final int N = 1000010;
    static int[] primes = new int[N]; //存所有的质数
    static int cnt; // 质数的数量
    static boolean[] st = new boolean[N]; // 是否被筛过
    
    static void get_primes(int n){ // O(n)
        for (int i = 2; i <= n; i ++ ) {
            if (!st[i]) primes[cnt ++ ] = i;
            for (int j = 0; primes[j] * i <= n; j ++ ) {
                st[primes[j] * i] = true; // 就是让i前的质数一个个乘i，得出的都是合数，然后true筛掉(原理：算术基本定理：任何一个整数都可以分解成质因数)
                if (i % primes[j] == 0) break; // 当遍历到i时，退出循环
            }
        }
    }
    
    public static void main(String[] args) {
        get_primes(100000);
        for (int i = 0; i < 20; i ++ ) System.out.println(primes[i]);
    }
}

代码

import java.util.*;

public class Main {
    static final int N = (1 << 20) + 10;
    static int n;
    static int[] minp = new int[N];
    static int[] primes = new int[N];
    static int[] sum = new int[N];
    static int cnt;
    static boolean[] st = new boolean[N];
    
    static void get_primes(int n) {
        for (int i = 2; i <= n; i ++ ) {
            if(!st[i]) {
                primes[cnt ++ ] = i;
                minp[i] = i;
            }
            for (int j = 0; primes[j] * i <= n; j ++ ) {
                int t = primes[j] * i;
                st[t] = true; // 筛掉primes[j] * i
                minp[t] = primes[j];  // 保存i的最小质因数
                if (i % primes[j] == 0) break; // 可以保证primes[j] <= i的最小质因子
                                              // 从而得到 : primes[j] * i一定是被最小质因子primes[j]筛掉的, 且只筛一次
            }
        }
    }
    
    public static void main(String[] args) {
        get_primes(N - 1);
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            n = in.nextInt();
            int k = 0, tot = 0; // k表示第几个质数，tot表示质数共有多少个
            while (n > 1) {
                int p = minp[n]; // 当前数的最小质因数
                System.out.println(Arrays.toString(minp));
                sum[k] = 0; //当前质因子的指数初始化为0
                while (n % p == 0) {
                    n /= p;
                    sum[k] ++;
                    tot ++;
                }
                k ++;
            }
            
            long res = 1;
            for (int i = 1; i <= tot; i ++ ) res *= i;
            for (int i = 0; i < k; i ++ )
                for (int j = 1; j <= sum[i]; j ++ ) 
                    res /= j;
            System.out.println(tot + " " + res);
        }
    }
}