第六章 数学(一)

一、数论

1 质数

定义： 在所有大于1的自然数，如果只包含1和本身这两个约数，就被称为质数，或者叫做素数。

1.1 判定质数——试除法

ACWing 866

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

方法一：定义法

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

方法二：对定义法进行优化

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

对于整数n，可以发现n的约数都是成对出现的，比如n = 12，<2, 6>与<3, 4>都是12的约数，且成对出现，所以每次枚举仅枚举每对约数中较小的一个，即判断条件修改为i <= n / i即可。

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;
}

注意两个细节：

• 条件写成i <= sqrt(n)不好，因为函数sqrt计算很慢；
• 条件写成i * i <= n不好，因为这里的i * i当(i+1)*(i+1)时会存在溢出风险，这是i会变成一个负数影响结果。

1.2 分解质因数——试除法

ACWing 867

因数与约数：

• 数域不同。约数只能是自然数（即0,1,2,3…）；而因数可以是任何数，当然也可以是小数；
• 关系不同。约数是对两个自然数的整除关系而言，只要两个数是自然数，就能确定它们之间是否存在约数关系，如：40÷5=8，40能被5整除，5就是40的约数，12÷10=1.2，12不能被10整除，10不是12的约数。因数是两个或两个以上的数对它们的乘积关系而言的。如：8×2=16，8和2都是积16的因数，离开乘积算式就没有因数了；
• 大小关系不同。当数a是数b的约数时，a不能大于b，当a是b的因数时，a可以大于b，也可以小于b。例如，5可以是10的约数，也可以是10的因数；但20只能是10的约数。

合数：

合数是指在大于1的整数中除了能被1和本身整除外，还能被其他数（0除外）整除的数。与之相对的是质数，而1既不属于质数也不属于合数。最小的合数是4。

分解质因数：

每个合数都可以写成几个质数相乘的形式，其中每个质数都是这个合数的因数，把一个合数用质因数相乘的形式表示出来，叫做分解质因数。如30=2×3×5 。分解质因数只针对合数。

方法一：定义法（会TLE）

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

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

注：这个代码中有个细节

每一次for循环的时候，我们都将2 ~ n所有的数（包括质数和非质数）都遍历了，这会有问题么？没有，注意代码中的while循环，因为任意一个合数可以表示成几个质数的乘积。证明一下循环里面的 i 一定是一个质数：假如 i 是一个合数，那么它一定可以分解成多个质因子相乘的形式，这多个质因子同时也是 n 的质因子且比 i 要小，而比 i 小的数在之前的循环过程中一定是被条件除完了的，所以 i 不可能是合数，只可能是质数。

方法二：对定义法进行优化

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

重要性质：n 中最多只包含一个大于$\sqrt{n}$ 的质因子。证明通过反证法：如果有两个大于$\sqrt{n}$的因子，那么相乘会大于n，矛盾。

故如果遍历完后n > 1，则n就是n中那个大于sqrt(n)的质因子

void divide(int n) {
    for (int i = 2; i <= n / i; i++) {
        if (n % i == 0) {
            int s = 0;
            while (n % i == 0) {
                n /= i;
                s++;
            }
            printf("%d %d\n", i, s);
        }
    }
    if (n > 1) // 如果n大于1，则n就是n中那个大于sqrt(n)的质因子
        printf("%d %d\n", n, 1);
    puts("");
}

1.2.1 阶乘分解

ACwing 197

算法思路：

1. 先筛除$[1,10^6]$中的所有质数，由质数定理可得$[1,n]$之间的质数个数为$\frac{n}{l{n}^n}$，做一下放缩$\frac{n}{l{n}^n}>\frac{n}{lo{g}_2^n}$。当$n=10^6$的时候，$lo{g}_2^{10^6}\approx 20$，所以$\frac{n}{lo{g}_2^n}\approx 50000$，因此质数大约$50000$个。
2. 对每个质数$p$的次数。首先分别求出$[1,n]$中$p、p^2、p^3...$的倍数(直到$p^u>n$)，有$\lfloor \frac{n}{p}\rfloor +\lfloor \frac{n}{p^2}\rfloor +\lfloor \frac{n}{p^3}\rfloor ...$个，每一个$p$的倍数都至少有一个$p$的质因子，所以$p$的次数为$\lfloor \frac{n}{p}\rfloor +\lfloor \frac{n}{p^2}\rfloor +\lfloor \frac{n}{p^3}\rfloor ...$，总共约为$lo{g}_p^n$个。

时间复杂度：

总共时间复杂度为$lo{g}_1^{10^6}+lo{g}_2^{10^6}+lo{g}_3^{10^6}+...\le 50000\times lo{g}_2^{10^6}$，时间复杂度为$O(50000\times lo{g}_2^{10^6})$。如果按照公式则为$O(\frac{n}{lo{g}_2^n}\times lo{g}_2^n)=O(n)$。

#include <cstdio>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1000010;

int primes[N], cnt;
bool st[N];

void init(int n) {
    for (int i = 2; i <= n; i++) {
        if (!st[i]) primes[cnt++] = i;
        for (int j = 0; primes[j] * i <= n; j++) {
            st[i * primes[j]] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

int main() {
    int n; cin >> n;
    init(n);
    for (int i = 0; i < cnt; i++) {
        int p = primes[i], s = 0; // s记录次数
        for (int j = n; j; j /= p) s += j / p;
        printf("%d %d\n", p, s);
    }
    return 0;
}

1.3 筛质数

ACWing 868

方法一：朴素筛法

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

算法思想：

将2 ~ n这n - 1个数存入数组中，将2 ~ n这几个数的所有倍数都删掉，剩下的数都是质数。比如对于一个数p而言，如果最后p没有被删掉，那么2 ~ p-1都不是p的因数，所以p就是一个质数。

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 1e6 + 10;

int n;
int primes[N], cnt;  // primes 存储质数， cnt 统计质数个数
bool st[N];  // 判断给位置上的数是否被筛过

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;
    }
    printf("%d\n", cnt);
}

int main() {
    scanf("%d", &n);
    get_prime(n);
    return 0;
}

方法二：埃氏筛法

时间复杂度： $O(nlo{g}^{lo{g}^n})$

优化思路：

执行for (int j = i + i; j <= n; j += i) st[j] = true;的时候，并不需要将每个数的倍数都删掉，而只需要将质数的倍数都删掉。因为对于一个数p，如果对于2 ~ p-1中的所有质数都不是p的因数，那么p就是一个质因数。

质数定理：1 ~ n 个数中含有 $\frac{n}{l{n}^n}$ 个质数。

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 1e6 + 10;

int n;
int primes[N], cnt;
bool st[N];

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;
        }
    }
    printf("%d\n", cnt);
}

int main() {
    scanf("%d", &n);
    get_prime(n);
    return 0;
}

方法三：线性筛法

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

优化思路： 将其每个合数用它的某一个质因子筛掉即可。

核心：每个数只会被它的最小质因子筛掉

对于埃氏筛法存在一个问题：同一个合数可能会被两个质数筛。任何一个合数，一定会被筛掉，因为任何一个合数一定存在一个最小质因子，每个数都是用最小质因子来筛除，所以每个数只会被筛一次，所以整个算法是线性的。

代码中的几点说明：

1. 代码第7行循环：表示从小到大枚举所有的质数；
2. 代码第8行：使用最小质因子primes[j]来筛除primes[j] * i，解释见下面第3点；
3. 代码第9行：因为是从小到大枚举的质数
   • 当第一次出现i % primes[j] == 0的时候，primes[j]一定是i的最小质因子，primes[j]也一定是primes[j] * i的最小质因子；
   • 当i % primes[j] != 0的时候，因为是从小到大枚举的质因子并且没有枚举到i的最小质因子，说明primes[j]一定小于i的所有质因子，所以primes[j]也一定是primes[j] * i的最小质因子；
   • 所以综上两点，不管什么情况下，代码第8行一定是使用最小质因子primes[j]来筛除primes[j] * i的。

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 1e6 + 10;

int n;
int primes[N], cnt;
bool st[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[primes[j] * i] = true;
            if i % primes[j] == 0) break;
        }
    }
    printf("%d\n", cnt);
}

int main() {
    scanf("%d", &n);
    get_prime(n);
    return 0;
}

1.3.1 哥德巴赫猜想

ACwing 1292

哥德巴赫猜想：任意一个大于 $4$ 的偶数都可以拆成两个奇素数之和。

算法思路：

暴力做法：代码如下。
时间复杂度：因为最多$n$个数，每个数使用试除法判断其是否为质数，时间复杂度为$O(\sqrt{n})$，所以总共时间复杂度为$O(n\sqrt{n})$。又$n$最坏为$10e^6$，所以时间复杂度最坏为$10^6\sqrt{10^6}=10^9$，总共$T$组数据，最终时间复杂度为$O(T10^9)$，时间复杂度太糟糕了。

for (a = 3; ; a ++ ) {
	b = n - a;
	if (a、b均是质数) 输出并break
}

优化做法：因为$max(n)=10^6$，所以可以先将$1$到$10^6$之间的所有质数预处理出来存入数组$boolst[]$中，后面做法如代码。

时间复杂度：

• 由质数定理，$1$到$10^6$之间的所有质数个数有 $\frac{n}{l{n}^n}$ 个，所以预处理时间复杂度为$(\frac{n}{l{n}^n})$；
• 判断的时间复杂度为$O(1)$。

若有$T$组数据，时间复杂度为$O(10^6+T\frac{10^6}{l{n}^{10^6}})\approx 10^6+50000T$。

for (a = 所有奇质数; ; a ++ ) {
	b = n - a;
	if (st[b]) 输出并break
}

#include <cstdio>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1000010;

int primes[N], cnt;
bool st[N];

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

int main() {
    init(N - 1);
    int n;
    while (cin >> n, n) {
        for (int i = 1;; i++) {
            int a = primes[i];
            int b = n - a;
            if (!st[b]) {
                printf("%d = %d + %d\n", n, a, b);
                break;
            }
        }
    }
    return 0;
}

1.3.2 夏洛克和他的女朋友

ACwing 1293

算法思路：

如果从图论角度来思考，可以将所有的质数放在一边，所有的合数放在一边，然后建立从质数指向合数的边，这个边表示该质数为该合数的质因数，所以这里就形成了一个二分图。

二分图可以对所有质数和所有合数进行染色，就可以得到本题解，并且可以知道最终解一定属于$[1,2]$，当二分图里面没有边的时候，就是$1$，有一条边就是$2$。

进一步，对于这个题，因为一个合数一定会有质因子，因此只要存在合数就一定存在边，答案就是$2$，否则答案为$1$。

当$n=1$时，价值为$2$，没有合数，答案为$1$；
当$n=2$时，价值为$2、3$，没有合数，答案为$1$；
当$n=3$时，价值为$2、3、4$，有合数，答案为$2$；

因此当$n\ge 3$时就会存在合数，答案为$2$，染色方案为所有质数一种颜色，所有合数一种颜色；
当$n=1$或者$2$的时候，答案为$1$，染色方案为所有数为一种颜色。

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

#include <cstdio>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int primes[N], cnt;
bool st[N];

void init(int n) {
    for (int i = 2; i <= n; i++) {
        if (!st[i]) primes[cnt++] = i;
        for (int j = 0; primes[j] * i <= n; j++) {
            st[i * primes[j]] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

int main() {
    int n; cin >> n;
    init(n + 1);
    if (n <= 2) puts("1");
    else puts("2");
    for (int i = 2; i <= n + 1; i++)
        if (!st[i]) printf("1 ");
        else printf("2 ");
    return 0;
}

1.3.3 质数距离

ACwing 196

因为题目中$1\le L、R\le 2^{31}-1\approx 2\times 10^9$，如果直接使用线性筛质数，将其存储进一个数组，时间复杂度和空间复杂度都太糟糕了，并且普通的线性筛法只能在$[1,n]$之间筛质数，不能在任意一个区间$[L,R]$之间筛质数。

算法思路：

首先明确一个性质：如果一个数$n$为合数，必然存在因子$d$和$\frac{n}{d}$，不妨设$d\le \frac{n}{d}$，则有$d\le \sqrt{n}$。

因此可以先将$[1,\sqrt{2^{31}-1}]$之间的质因子筛出来，因为$2^{31}-1\approx 2\times 10^9$，$50000^2=2.5\times 10^9$，所以可以先将$[1,50000]$之间的质因数先筛出来。

对于$[L,R]$之间的任意一个数$x$，如果$x$为合数，那么它就必然存在一个$[1,50000]$之间的质因子$p$，满足$p|x、p<x$(注意：如果一个数为质数，它的质因子可以是自己，如果一个数为合数，它的质因子一定小于自己)。反之如果$x$为质数，则必然不存在一个$[1,50000]$之间的质因子。

然后对于$[1,50000]$中的每一个质数$p$，将$[L,R]$之间$p$的所有倍数筛掉(至少两倍，保证为合数)，这样在区间$[L,R]$之间的所有数都为质数。

1. 在$[L,R]$之间找到一个$p$的倍数的方法：首先在$[L,R]$之间找到一个大于等于$L$的最小的$p$的倍数$p_0$，然后可以从$p_0$开始，每次$+p$，从而找出$[L,R]$之间$p$的所有倍数。
2. 那么如何在$[L,R]$之间找到一个大于等于$L$的$p$的最小的倍数$p_0$呢？可以知道大于等于$L$的$p$的最小的倍数应该为$\lceil \frac{L}{p}\rceil \times p=\lfloor \frac{L+p-1}{p}\rfloor \times p$。并且这里的$p$至少要从$2p$开始筛，所以$p_0=max(2p,\lfloor \frac{L+p-1}{p}\rfloor )$。

关于$\lceil \frac{L}{p}\rceil =\lfloor \frac{L+p-1}{p}\rfloor$的证明 (c++ 的运算符"\"是向下取整)：

• 如果$L$不是$p$的倍数，$Lmodp\ge 1$，再加上$p-1modp=p-1$后一定大于$1$，最后向下取整的结果就相比于原来多$1$；
• 如果$L$是$p$的倍数，那么$L+p-1$在整除$p$的算式中，即$\frac{L+p-1}{p}$等于没有加$p$，比如$L=4、P=2$，那么$\lfloor \frac{4+2-1}{2}\rfloor =2$。

时间复杂度：

由题 m a x { R − L } = 1 0 6 max\{R - L\} = 10^6 max{R−L}=106，对于$[1,50000]$中的每一个质数$p$，$[L,R]$之间$p$的倍数最多有$\frac{10^6}{p}$个。因为每一个质数都需要计算一遍，所以计算$[1,50000]$中所有质数倍数的时间复杂度为$$\begin{array}{rl}& \frac{10^6}{2}+\frac{10^6}{3}+\frac{10^6}{5}+...\\ =& 10^6(\frac{1}{2}+\frac{1}{3}+\frac{1}{5}+...+\frac{1}{\sqrt{n}})\\ =& O(10^{6}lo{g}^{\frac{1}{2}lo{g}^{10^6}})\\ =& O(10^6(lo{g}^{\frac{1}{2}}+lo{g}^{lo{g}^{10^6}}))\\ =& O(10^6(lo{g}^C+lo{g}^{lo{g}^{10^6}}))\\ =& O(10^{6}lo{g}^{lo{g}^{10^6}})\\ \approx & O(10^{6}lo{g}^{17})\\ \approx & O(4\times 10^6)\end{array}$$所以整个时间复杂度约为$O(n)$。

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 1000010;

int primes[N], cnt;
bool st[N];

void init(int n) {
    memset(st, 0, sizeof st);
    cnt = 0;
    for (int i = 2; i <= n; i++) {
        if (!st[i]) primes[cnt++] = i;
        for (int j = 0; primes[j] * i <= n; j++) {
            st[i * primes[j]] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

int main() {
    int l, r;
    while (cin >> l >> r) {
        init(50000);
        memset(st, 0, sizeof st);
        for (int i = 0; i < cnt; i++) {
            LL p = primes[i];
            for (LL j = max(p * 2, (l + p - 1) / p * p); j <= r; j += p) // j至少从2p开始筛
                st[j - l] = true;
        }
        cnt = 0;
        for (int i = 0; i <= r - l; i++) // 将[L,R]之间所有质数存入primes
            if (!st[i] && i + l >= 2)
                primes[cnt++] = i + l;
        if (cnt < 2) puts("There are no adjacent primes.");
        else {
            int minp = 0, maxp = 0;
            for (int i = 0; i + 1 < cnt; i++) {
                int d = primes[i + 1] - primes[i];
                if (d < primes[minp + 1] - primes[minp]) minp = i;
                if (d > primes[maxp + 1] - primes[maxp]) maxp = i;
            }
            printf("%d,%d are closest, %d,%d are most distant.\n",
                   primes[minp], primes[minp + 1], primes[maxp], primes[maxp + 1]);
        }
    }
    return 0;
}

2 约数

2.1 求约数——试除法

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

ACWing 869

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int n, m;

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() {
    scanf("%d", &n);
    while (n -- ) {
        scanf("%d", &m);
        vector<int> res = get_divisors(m);
        for (int i = 0; i < res.size(); i ++ )
            printf("%d ", res[i]);
        puts("");
    }
    return 0;
}

2.2 约数个数

ACWing 870

由算数基本定理：任何一个数$N$可以表示成
$$N=P_1^{{\alpha }_1}\cdot P_2^{{\alpha }_2}\cdot \cdot \cdot P_k^{{\alpha }_k}$$那么约数个数为
$$({\alpha }_1+1)\cdot ({\alpha }_1+1)\cdot \cdot \cdot ({\alpha }_k+1)$$

证明：设$N$的任意一个约数为$d$，那么$d$可以表示为
$$d=P_1^{{\beta }_1}\cdot P_2^{{\beta }_2}\cdot \cdot \cdot P_k^{{\beta }_k}(0\le {\beta }_i\le {\alpha }_i)$$只要任意一个${\beta }_i$不同，约数$d$就不同。因为${\beta }_1\in [0,{\alpha }_1]，{\beta }_2\in [0,{\alpha }_2]...{\beta }_k\in [0,{\alpha }_k]$。由乘法原理，约数的个数为$({\alpha }_1+1)\cdot ({\alpha }_1+1)\cdot \cdot \cdot ({\alpha }_k+1)$。

同时要注意对于$[1,N]$中，约数个数为$\frac{N}{1}+\frac{N}{2}+...+\frac{N}{N}\approx Nlo{g}_2^N$。

常识：$0\le N\le 2\times 10^9$范围内，即 $int$ 范围内，约数个数最多的个数有$1600$个。(计算见 2.2.3 反素数)

算法思路： 先求出乘积$a_1\cdot a_2...\cdot a_n$的因式分解，即$$a_1\cdot a_2...\cdot a_n=P_1^{{\alpha }_1}\cdot P_2^{{\alpha }_2}\cdot \cdot \cdot P_k^{{\alpha }_k}$$然后结果为$$({\alpha }_1+1)\cdot ({\alpha }_1+1)\cdot \cdot \cdot ({\alpha }_k+1)$$

对乘积进行质因数分解等价于对每个数进行质因式分解。

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

#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;

typedef long long LL;

const int N = 110, mod = 1e9 + 7;

int n;
unordered_map<int, int> primes; // 每一个质因数的底数 : 指数

int main() {
    scanf("%d", &n);
    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] ++ ;
    }
    LL res = 1;
    for (auto p: primes)
        res = res * (p.second + 1) % mod;
    printf("%lld\n", res);
    return 0;
}

2.2.1 轻拍牛头

ACwing 1291

因为求约数个数(除法)的时间复杂度为$O(n\sqrt{n})$，太糟糕了，所以可以考虑求每一个数的倍数(乘法)。

算法思路：

从$1$到$10^6$枚举每个数$i$，判断$[1,10^6]$中有多少个数为$i$的倍数，倍数记为$j$，这时候因为$i$为$j$的约数，$j$为$i$的倍数，所以应该同时将$i$所出现的次数添加进$j$对应的数组中。

时间复杂度：

由开头注解可知道：$[1,N]$中，约数个数为$\frac{N}{1}+\frac{N}{2}+...+\frac{N}{N}\approx Nlo{g}_2^N$，因此这个题目的时间复杂度为$O(10^{6}lo{g}_2^{10^6})$。

#include <cstdio>

using namespace std;

const int N = 1000010;

int n;
int a[N], cnt[N], s[N]; // a存储元素 cnt元素出现次数 s元素约数个数

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", a + i);
        cnt[a[i]]++;
    }
    for (int i = 1; i < N; i++)
        for (int j = i; j < N; j += i)
            s[j] += cnt[i];
    for (int i = 0; i < n; i++) printf("%d\n", s[a[i]] - 1); // 最后要减去自己
    return 0;
}

2.2.2 樱花

ACwing 1294

题目求满足$\frac{1}{x}+\frac{1}{y}=\frac{1}{n!}$，其中$x、y\in N_{+}，n\in [1,10^6]$，这样的一对$(x,y)$有多少对。

算法思路：

对公式变形有：$$\begin{array}{rl}& \frac{1}{x}+\frac{1}{y}=\frac{1}{n!}\\ \Rightarrow & \frac{x+y}{xy}=\frac{1}{n!}\\ \Rightarrow & x\cdot n!+y\cdot n!=xy\\ \Rightarrow & x\cdot n!=(x-n!)y\\ \Rightarrow & y=\frac{x\cdot n!}{x-n!}=\frac{(x-n!+n!)n!}{x-n!}=\frac{(x-n!)n!}{x-n!}+\frac{(n!{)}^2}{x-n!}\\ \Rightarrow & y=n!+\frac{(n!{)}^2}{x-n!}\end{array}$$该题问题就转换为了求$x\in N_{+}$有多少种取值，使得$y\in N_{+}$。因为$n!\in N_{+}$，故只需要使$\frac{(n!{)}^2}{x-n!}\in N_{+}$即可，即 $x\in N_{+}$有多少种取值，使得 $x-n!$ 为 $(n!{)}^2$ 的约数。

更进一步，因为$\frac{1}{y}=\frac{1}{n!}-\frac{1}{x}$，当$x\le n!$的时候，$\frac{1}{y}\le 0$，不满足条件。所以一定满足$x-n!>0$，故问题 “$x\in N_{+}$有多少种取值，使得 $x-n!$ 为 $(n!{)}^2$ 的约数” 进一步转换为了 $x$取值个数等价于$(n!{)}^2$的约数个数，即求$(n!{)}^2$的约数个数。

由题 1.2.1 阶乘分解 可以求解出每一个阶乘的表示，进而可以表示出$(n!{)}^2$的表示，即$$\begin{array}{rl}& n!=p_1^{c_1}+p_2^{c_2}+...p_k^{c_k}\\ \Rightarrow & (n!{)}^2=p_1^{2c_1}+p_2^{2c_2}+...p_k^{2c_k}\end{array}$$因此约数个数为$$(2c_1+1)(2c_2+1)...(2c_k+1)$$

#include <cstdio>
using namespace std;

typedef long long LL;
const int N = 1e6 + 10, mod = 1e9 + 7;

int n, primes[N], cnt;
bool st[N];

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

int main() {
    scanf("%d", &n);
    init(n);
    int res = 1;
    for (int i = 0; i < cnt; i++) {
        int p = primes[i], s = 0; // s为质数p的次数
        for (int j = n; j; j /= p) s += j / p;
        res = (LL) res * (2 * s + 1) % mod;
    }
    printf("%d\n", res);
    return 0;
}

2.2.3 反素数

ACwing 198

$[1,N]$中最大的反素数 等价于 $[1,N]$中约数个数最多的最小的数

解释：假设区间$[1,N]$中约数个数最多的最小的数为$x$，那么在$i\in [1,x-1]$中所有数的$g(i)<g(x)$，因此$x$一定是一个反素数；因为$x$在整个区间中约数个数最多，所以对于$i\in [x+1,N$，$g(x)>g(i)$，因此$i\in [x+1,N]$一定不是反素数。

对于这个题，有三点性质：

1. 因为$N\in [1,2\times 10^9]$，对于$N$不同的质因子数目最多只有$9$个。因为$$2\times 3\times 5\times 7\times 11\times 13\times 17\times 19\times 23\times 29=6469693230>2\times 10^9$$因此不同的质因子数目最多只有$9$个，即$2、3、5、7、11、13、17、19、23$；
2. 每个质因子的次数最大为$30$。因为质因子$2$的$31$次方$2^{31}>2\times 10^9$，所以质数$2$的次方数目最多为$30$，则对于质因子$3$的次数一定小于$30$，对于大于$3$的质因数的次方一定更小；
3. 所有质因子的次数一定是递减的。当$N=2^{c_1}\times 3^{c_2}\times 5^{c_3}\times 7^{c_4}\times ...$，则一定有$c_1\ge c_2\ge c_3\ge ...$ 。假设$3^4$和$5^5$，它们次数不递减，交换二者次数之后，有$3^5、5^3$，那么$\frac{3^4\times 5^5}{3^5\times 5^4}=\frac{5}{3}<1$，因此质因数次数递减的时候所求出的$N$更小， 满足”$[1,N]$中约数个数最多的最小的数“的特点。

因此这个题能搜索的情况很少，可以使用爆搜。依次枚举质因数$2、3、5、...$的次数，并且次数依次递减，求出满足上面三点性质的、$[1,N]$中约数个数最多的最小的数。

#include <cstdio>
using namespace std;

typedef long long LL;

int primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
int maxd, number; // 约数个数maxd 数值number
int n;

// 第u个质数 上一次质数的次数last 当前乘积p 约数个数s
void dfs(int u, int last, int p, int s) {
    if (s > maxd || s == maxd && p < number) maxd = s, number = p;
    if (u == 9) return;
    for (int i = 1; i <= last; i++) { // 枚举次数
        if ((LL) p * primes[u] > n) break;
        p *= primes[u];
        dfs(u + 1, i, p, s * (i + 1));
    }
}

int main() {
    scanf("%d", &n);
    dfs(0, 30, 1, 1);
    printf("%d\n", number);
    return 0;
}

2.2.4 Hankson的趣味题

ACwing 200

有2000组测试数据，每一组中有四个数$a、b、c、d\in [1,2\times 10^9]$，求解有多少个$x\in N_{+}$满足$(a,x)=b、[c,x]=d$ ？

暴力解法：枚举$d$的所有约数$x$，然后判断是否满足$(a,x)=b$。 前一步时间复杂度会达到$\sqrt{n}$！

最大公倍数与最大公约数关系：$[a,b]=\frac{a\cdot b}{(a,b)}$

优化：枚举$d$的所有约数$x$的时候，先对$d$分解质因数，然后在求约数的时候并不是从$1$开始枚举，而仅枚举所有质数，然后再通过$dfs$爆搜出所有约数。

#include <cstdio>

using namespace std;

typedef long long LL;
const int N = 50010; // 筛质数最大50000

int primes[N], cnt;
bool st[N];
struct Factor { // 存储d的每个质因子
    int p, s; // p质因子 s质因子出现次数
} factor[10]; // int范围内的数据不同的质因子最多有9位
int fcnt; // 质因子个数

// int范围内的数据不同的约数最多为1600个
int dividor[1601], dcnt; // dividor所有约数 dcnt约数个数

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

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

// 第u个质因子 约数的值为p
void dfs(int u, int p) {
    if (u == fcnt) {
        dividor[dcnt++] = p;
        return;
    }
    for (int i = 0; i <= factor[u].s; i++) {
        dfs(u + 1, p);
        p *= factor[u].p;
    }
}


int main() {
    init(N);
    int n; scanf("%d", &n);
    while (n--) {
        int a, b, c, d; scanf("%d%d%d%d", &a, &b, &c, &d);

        fcnt = 0;
        int t = d;
        for (int i = 0; primes[i] <= t / primes[i]; i++) { // 分解质因式
            int p = primes[i];
            if (t % p == 0) {
                int s = 0;
                while (t % p == 0) t /= p, s++;
                factor[fcnt++] = {p, s};
            }
        }
        if (t > 1) factor[fcnt++] = {t, 1};

        dcnt = 0;
        dfs(0, 1); // 求每个约数

        int res = 0;
        for (int i = 0; i < dcnt; i++) { // 判断所有约数
            int x = dividor[i];
            if (gcd(a, x) == b && (LL) c * x / gcd(c, x) == d) res++;
        }
        printf("%d\n", res);
    }
    return 0;
}

2.3 约数之和

ACWing 871

任何一个数$N$可以表示成
$$N=P_1^{{\alpha }_1}\cdot P_2^{{\alpha }_2}\cdot \cdot \cdot P_k^{{\alpha }_k}$$那么约数之和为
$$(P_1^0+p_1^1+...+P_1^{{\alpha }_1})(P_2^0+p_2^1+...+P_2^{{\alpha }_1})\cdot \cdot \cdot (P_k^0+p_k^1+...+P_k^{{\alpha }_1})$$

证明：将式子$$(P_1^0+p_1^1+...+P_1^{{\alpha }_1})(P_2^0+p_2^1+...+P_2^{{\alpha }_1})\cdot \cdot \cdot (P_k^0+p_k^1+...+P_k^{{\alpha }_1})$$展开，可见其为约数之和。

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

#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;

typedef long long LL;

const int N = 110, mod = 1e9 + 7;

int n;
unordered_map<int, int> primes;

int main() {
    scanf("%d", &n);
    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] ++ ;
    }
    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;
    }
    printf("%lld\n", res);
    return 0;
}

2.4 最大公约数 (欧几里得算法、辗转相除法)

ACwing 872

性质：若$d$能整除$a$和$b$，记为$d|a、d|b$。那么$d$也能整除$a+b、ax+by$($a$的倍数和$b$的倍数)，记为$d|(a+b)、d|(ax+by)$。

$a$和$b$的最大公约数$(a,b)=(b,amodb)$

证明：$amodb=a-\lfloor \frac{a}{b}\rfloor \cdot b$，令$c=\lfloor \frac{a}{b}\rfloor$，那么有$amodb=a-c\cdot b$，则有$$(a,b)=(b,a-c\cdot b)$$从左往右：设$d$为$a、b$的最大公约数，由性质可知，左边的最大公约数也为右边的最大公约数；
从右往左：设$d$为$b、a-c\cdot b$的最大公约数，由性质可知$d$也为$c\cdot b$的最大公约数。所以$d$也为$(a-c\cdot b)+c\cdot b=a$的最大公约数，即为$a、b$的最大公约数。

时间复杂度：$O(lo{g}^n)$

#include <iostream>
#include <algorithm>
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;
}