Acwing - 算法基础课 - 笔记（数学知识 · 二）

数学知识（二）

这一小节主要讲解的内容是：欧拉函数，快速幂，扩展欧几里得算法，中国剩余定理。

这一节内容偏重于数学推导，做好心理准备。

欧拉函数

公式法

什么是欧拉函数呢？

欧拉函数用 $\varphi (n)$ 来表示，它的含义是，$1$ 到 $n$ 中与 $n$ 互质的数的个数

比如，$\varphi (6)=2$，解释：1到6当中，与6互质的数只有1，5，共两个数。

两个数 $a$ , $b$ 互质的含义是 $gcd(a,b)=1$

欧拉函数如何求解呢？

对于一个数 $N$ ，将其写为分解质因数的形式 $N=P_1^{k_1}\times P_2^{k_2}\times ...\times P_n^{k_n}$

则 $\varphi (N)=N\times (1-\frac{1}{P_1})\times (1-\frac{1}{P_2})\times ...\times (1-\frac{1}{P_n})$，这就是欧拉函数的求解公式

比如 $N=6$， 6有2个质因子2和3，则

$\varphi (6)=6\times (1-\frac{1}{2})\times (1-\frac{1}{3})=2$

欧拉函数的公式如何证明呢？

欧拉函数的证明需要用到容斥原理，容斥原理的具体内容将在下一节进行讲解，本节直接借用容斥原理的结论。

注：下面的 $\frac{N}{P}$ 实际指的都是 $\lfloor \frac{N}{P}\rfloor$，比如 $\frac{15}{7}$ 指的是 $\lfloor \frac{15}{7}\rfloor =2$，由于加上取整符号会导致编写latext语法变得非常繁琐，特此申明。

我们求 $1$ 到 $n$ 中，与 $n$ 互质的数的个数，仍然采用删数的思想，只要把那些和 $n$ 有公约数的数删掉就可以了。那么还是需要先对 $n$ 做分解质因数，因为 $n$ 的质因数是 $n$ 的约数的最小组成部分。

1. 从 $1$ 到 $N$ 中，去掉其全部质因子 $P_1，P_2,...,P_n$ 的所有倍数。这些数都和 $N$ 不互质，因为都有公因子 $P_i$

   那么剩余的数的个数就是$N-\frac{N}{P_1}-\frac{N}{P_2}-...-\frac{N}{P_n}$

2. 加上所有 $P_i\times P_j$ 的倍数的个数，其中 $i$ 和 $j$ 是从 $1$ 到 $n$ 之中任选两个数

   假设第一步计算得到的结果是 $S_1$，那么第二步要做的就是 $S_1+\frac{N}{P_1\times P_2}+\frac{N}{P_1\times P_3}+...\frac{N}{P_1\times P_n}+\frac{N}{P_2\times P_3}+...+\frac{N}{P_2\times P_n}+...+\frac{N}{P_{n-1}\times P_n}$

   因为在第一步时，会多删掉一些数，比如某个数既是 $P_1$ 的倍数，也是 $P_2$ 的倍数（即这个数是 $P_1\times P_2$ 的倍数），那么这个数会被 $P_1$ 减一次，被 $P_2$ 减一次，一共减了两次 ，多减了一次，那么我们需要加一次加回来。

3. 加上所有 $P_i\times P_j\times P_k$ 的倍数的个数

   若有某个数，同时是3个质因子的倍数，假设一个数同时是 $P_1$，$P_2$，$P_3$ 的倍数，那么这个数第一步会被减3次，会在第二步被加3次 ，实际是没减的。所以还要对这种数减去一次

   假设第二步计算得到的结果是 $S_2$，那么第三步要做的就是 $S_2-\frac{N}{P_1\times P_2\times P_3}-\frac{N}{P_1\times P_2\times P_4}-...-\frac{N}{P_{n-2}\times P_{n-1}\times P_n}$

   即，对 $i,j,k\in [1,n]$ 的全部组合，进行减

4. 后续的步骤同理

   若若某个数，同时是4个质因子的倍数，这种数在第一步被减了4次，第二步被加了$C_4^2=\frac{4\times 3}{2\times 1}=6$ 次，第三步被减了 $C_4^3=4$ 次，总共是减了2次，则需要加回一次

   所以要做的就是 $S_3+\frac{N}{P_1\times P_2\times P_3\times P_4}+....+\frac{N}{P_{n-3}\times P_{n-2}\times P_{n-1}\times P_n}$

5. 对于那些是5个质因子的倍数的数，第一次被减了 $C_5^1=5$ 次，第二步加了 $C_5^2=10$ 次，第三步被减了 $C_5^3=10$ 次，第四步被加了 $C_5^4=5$ 次，总共是0次操作，所以需要减一次

6. …

是不是感觉像是无限套娃？！hhhhh

这个过程会在第 $n$ 次后停止，而 $n$ 是$N$ 的质因数个数

所以，$1$ 到 $N$ 中所有和 $N$ 互质的数的个数，就等于

$N-\frac{N}{P_1}-\frac{N}{P_2}-...-\frac{N}{P_n}$

$+\frac{N}{P_1\times P_2}+\frac{N}{P_1\times P_3}+...\frac{N}{P_1\times P_n}+\frac{N}{P_2\times P_3}+...+\frac{N}{P_2\times P_n}+...+\frac{N}{P_{n-1}\times P_n}$

$-\frac{N}{P_1\times P_2\times P_3}-\frac{N}{P_1\times P_2\times P_4}-...-\frac{N}{P_{n-2}\times P_{n-1}\times P_n}$

$+\frac{N}{P_1\times P_2\times P_3\times P_4}+....+\frac{N}{P_{n-3}\times P_{n-2}\times P_{n-1}\times P_n}$

$....$

$\pm \frac{N}{P_1\times P_2\times ...\times P_n}$

而这一大坨式子，化简后得到的就是

$N\times (1-\frac{1}{P_1})\times (1-\frac{1}{P_2})\times ...\times (1-\frac{1}{P_n})$

这也就是本节开头提到的欧拉函数的公式

练习题：acwing - 873: 欧拉函数

#include <iostream>

int euler(int x) {
	int ans = x;
	for(int i = 2; i <= x / i; i++) {
		if(x % i == 0) {
			while(x % i == 0) x /= i;
			ans = ans / i * (i - 1);
		}
	}
	if(x > 1) ans = ans / x * (x - 1);
	return ans;
}

int main() {
	int n, a;
	scanf("%d" ,&n);
	while(n--) {
		scanf("%d", &a);
		printf("%d\n", euler(a));
	}
}

注意，欧拉公式的计算过程中，每一项计算完毕后都应该是一个整数，不应该出现小数。

故 对于 $N\times (1-\frac{1}{P_1})$ 这样的式子，计算时我们采用 $\frac{N}{P_1}\times (P_1-1)$，这样能保证得到的结果是整数，而不出现小数。

由于 $P_1$ 是 $N$ 的质因子，故 $\frac{N}{P_1}$ 一定是整数，所以 $\frac{N}{P_1}\times (P_1-1)$ 就一定是整数，令 $S=\frac{N}{P_1}\times (P_1-1)$，那么在第二轮迭代中，我们需要计算 $S\times (1-\frac{1}{P_2})$，同样的，我们计算 $\frac{S}{P_2}\times (P_2-1)$，那么 $\frac{S}{P_2}$ 一定是整数吗？答案是肯定的。

因为 $N=P_1^{k_1}\times P_2^{k_2}\times ...\times P_n^{k_n}$，容易得到，第一步计算的结果 $S=P_1^{k_1-1}\times P_2^{k_2}\times ...\times P_n^{k_n}\times (P_1-1)$，所以 $S$ 是一定能被 $P_2$ 整除的，同理，在第三轮迭代时，第二轮的计算结果仍然能被 $P_3$ 整除，所以我们就可以在每轮迭代时，计算 $\frac{S_i}{P_i}\times (P_i-1)$，这样能保证整个计算的过程中，不出现小数，即可保证最终结果的正确性。

筛法

上面的公式法，适用于求解某一个数的欧拉函数，就类似于用试除法判断某一个数是否是质数。

然而，有的时候，我们需要求解某一个范围内全部数的欧拉函数（比如求解 $1$ 到 $N$ 之间所有数的欧拉函数），此时若对每个数依次套用欧拉公式，则整体的时间复杂度为 $O(N\times \sqrt{N})$ ，因为欧拉函数的计算依赖于分解质因数，而分解质因数的时间复杂度是 $O(\sqrt{N})$ 。这个时间复杂度是不被接受的，太慢了，所以我们需要变换思路。

联想到在求解 $1$ 到 $N$ 之间全部质数的时候，我们采用的是筛法，而不是对每个数依次判断是否是质数。类似的，求解 $1$ 到 $N$ 之间全部数的欧拉函数，我们也可以用类似的思想。

借鉴前面筛选质数时所采用的线性筛法，能够在 $O(N)$ 的时间复杂度内求解出 $1$ 到 $N$ 每个数的欧拉函数。在本章（数论）后面的学习中，会发现线性筛法在执行过程中不仅仅能求出欧拉函数，还能求出很多其他的内容。

我们先把线性筛法的代码写一遍

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

const int N = 1e6 + 10;

bool st[N];

int primes[N], ctn;

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

当某一个数 $i$ 是质数时，根据欧拉函数的公式，我们容易得出，这个质数的欧拉函数 $\varphi (i)=i-1$；而当我们在通过 $p_j\times i$ 来筛数时。分两种情况

• 当 $i\mathrm{mod}{p}_j=0$ 时

  容易推出 $\varphi (p_j\times i)=p_j\times \varphi (i)$

  因为一个数 $N$ 的欧拉函数 $\varphi (N)=N\times (1-\frac{1}{p_1})\times ...\times (1-\frac{1}{p_n})$

  假设 $i$ 一共有 $k$ 个质因子 $p_1$ ，$p_2$，…，$p_k$

  则 $\varphi (i)=i\times (1-\frac{1}{p_1})\times ...\times (1-\frac{1}{p_k})$

  而 $i\mathrm{mod}{p}_j=0$ ，说明 $p_j$ 是 $i$ 的一个质因子。则 $p_j\times i$ 这个数的质因子也是 $p_1$，$p_2$，…，$p_k$

  则 $\varphi (p_j\times i)=p_j\times i\times (1-\frac{1}{p_1})\times ...\times (1-\frac{1}{p_k})=p_j\times \varphi (i)$

• 当 $i\mathrm{mod}{p}_j\ne 0$ 时

  根据类似上面的过程，容易推出

  $\varphi (p_j\times i)=p_j\times i\times (1-\frac{1}{p_1})\times ...\times (1-\frac{1}{p_j})\times ...\times (1-\frac{1}{p_k})=(p_j-1)\times \varphi (i)$

  $p_j\times i$ 这个数的质因子，比 $i$ 这个数的质因子，多一个 $p_j$

由于在线性筛法的执行过程中，对于质数会保留，对于合数会用其最小质因子筛掉。所以线性筛法是会访问到所有数的。而根据上面的推导，在遇到每种情况时，我们都能求出欧拉函数

• 当这个数是质数：$\varphi (i)=i-1$

• 当这个数是合数

  其一定会被某个 $p_j\times i$ 筛掉

  • 当 $i\mathrm{mod}{p}_j=0$，则 $\varphi (p_j\times i)=p_j\times \varphi (i)$
  • 当 $i\mathrm{mod}{p}_j\ne 0$，则 $\varphi (p_j\times i)=(p_j-1)\times \varphi (i)$

• 特殊的，$\varphi (1)=1$（ $1$ 既不是质数也不是合数）

于是，我们便可以通过线性筛法来求解出 $1$ 到 $N$ 的所有数的欧拉函数，时间复杂度 $O(N)$

练习题2：acwing - 874: 筛法求欧拉函数

#include<iostream>
using namespace std;

typedef long long LL;

const int N = 1e6 + 10;

int primes[N], ctn;

bool st[N];

LL phi[N];

void get_eulers(int n) {
	phi[1] = 1;
	for(int i = 2; i <= n; i++) {
		if(!st[i]) {
			primes[ctn++] = i;
			phi[i] = i - 1;
		}
		for(int j = 0; primes[j] <= n / i; j++) {
			st[primes[j] * i] = true;
			if(i % primes[j] == 0) {
				phi[primes[j] * i] = primes[j] * phi[i];
				break;
			}
			phi[primes[j] * i] = (primes[j] - 1) * phi[i];
		}
	}
}

int main() {
	int n;
	scanf("%d", &n);
	get_eulers(n);
	LL sum = 0;
	for(int i = 1; i <= n; i++) sum += phi[i];
	printf("%lld", sum);
	return 0;
}

欧拉定理

说了这么多，那么欧拉函数有什么实际的作用或者应用场景呢？

有一个定理叫做欧拉定理，它描述这样一个规律：

若 $a$ 与 $n$ 互质，则 $a^{\varphi (n)}\mathrm{mod}n=1$

比如 $a=5$ ，$n=6$ ，由于 $\varphi (6)=6\times (1-\frac{1}{2})\times (1-\frac{1}{3})=2$

则有 $a^{\varphi (n)}\mathrm{mod}n=5^2\mathrm{mod}6=1$

那么欧拉定理如何证明呢？

yxc是这样讲的：

首先，$1$ 到 $n$ 以内与 $n$ 互质的数，有 $\varphi (n)$ 个，将其编号如下

$a_1$，$a_2$，…，$a_{\varphi (n)}$

而 $a$ 与 $n$ 互质，则可以得知，在 $\mathrm{mod}n$ 的语义下。

$a\times a_1$，$a\times a_2$，…，$a\times a_{\varphi (n)}$

这个集合，与上面的与 $n$ 互质的数是同一个集合

进而有，两个集合中全部数的乘积，在 $\mathrm{mod}n$ 的语义下是相等的

$a_1\times a_2\times ...\times a_{\varphi (n)}\equiv a^{\varphi (n)}\times a_1\times a_2\times ...\times a_{\varphi (n)}$

将两边的 $a_1\times a_2\times ...\times a_{\varphi (n)}$ 消掉，则有

$a^{\varphi (n)}\equiv 1$，也即 $a^{\varphi (n)}\mathrm{mod}n=1$

（其实我没有完全把推导的原理搞懂，这个有待后续补充，TODO）

特殊的，当 $n$ 是一个质数时（此时我们将 $n$ 替换成 $p$ 来表示），则有

$a^{\varphi (p)}\mathrm{mod}p=1$

即 $a^{p-1}\mathrm{mod}p=1$

这个欧拉定理的特例，被称为费马小定理。

快速幂

快速幂，是用来快速求解出 $a^k\mathrm{mod}p$ 的结果，时间复杂度为 $O(\log k)$，其中 $a$，$k$，$p$ 都可以在 $10^9$ 内，如果是按照朴素做法的话，则需要 $O(k)$ 的时间复杂度，如果 $k=10^9$ ，则这个复杂度就比较高了，而如果是 $O({\log }_{2}k)$，即便 $k=10^9$，也大概只需要 $30$ 次计算即可，非常的快。

那么，快速幂是怎么做到的呢？

快速幂的核心思路是：反复平方法（思想上有点类似逆向二分。二分是每次在当前基础上减一半，快速幂是每次在当前基础上扩大一倍）。

原理说明如下

我们先预处理出来如下的值：$a^{2^0}\mathrm{mod}p$， $a^{2^1}\mathrm{mod}p$，$a^{2^2}\mathrm{mod}p$ ，…，$a^{2^{{\log }_{2}k}}\mathrm{mod}p$

一共 ${\log }_{2}k$ 个数。随后，我们通过这些数，组合出 $a^k$

即，将 $a^k$ 拆成 $a^k=a^{2^i}\times a^{2^j}\times ...=a^{2^i+2^j+...}$ ，即 $k=2^i+2^j+...$

即，将 $k$ 拆成 $2^0$，$2^1$，$2^2$，…，$2^{{\log }_{2}k}$ 的某些数的和

其实，就只需要把 $k$ 转化为二进制即可。

比如 $k=(54{)}_{10}=(110110{)}_2=2^1+2^2+2^4+2^5$

由于一个十进制的数 $k$ ，一定可以转化为二进制，即，$k$ 一定能拆成若干个 $2^i$ 的加和，所以 $a^k$ 一定能按照上面的式子拆开，所以快速幂算法能够生效。

预处理一共计算出 ${\log }_{2}k$ 个数，需要计算 $lo{g}_{2}k$ 次，将 $k$ 拆成二进制表示，并计算结果，需要 $lo{g}_{2}k$ 次，所以总共的时间复杂度就是 $O({\log }_{2}k)$。其实编写代码时，可以将上面两步合在一起，实际只需要 ${\log }_{2}k$ 次运算

举个比较简单例子，比如要计算 $9^7$，对于指数 $7$ ，我们可以将其写成 $2^2+2^1+2^0$，即二进制的 $(111{)}_2$。则计算 $9^7$ ，相当于计算 $9^{2^2+2^1+2^0}$，拆一下，得 $9^{2^2}\times 9^{2^1}\times 9^{2^0}$，每相邻两项之间都是平方的关系，则我们可以通过反复计算平方的方法， 先计算$9$，再计算 $9^2$，再计算 $(9^2{)}^2$，再把每一项乘起来即可。


再比如，计算 $9^{11}$，将$11$写成二进制，为 $(1011{)}_2$，从最低位开始，第一位是1，需要乘个 $9$，第二位也是$1$，则再乘个 $9^2$，第三位是 $0$ ，则不乘，但是我们仍然要计算一下 $9^4$ （对上一轮的 $9^2$ 做平方），然后第四位，是1，再乘个 $9^8$ （对上一轮 $9^4$ 做平方）。


是不是有点类似二分的思路呢？将原先的 $n$ 次乘法运算，通过反复平方，压缩成了 $lo{g}_{2}n$ 次

练习题：acwing - 875: 快速幂

#include<iostream>
using namespace std;

typedef long long LL;

// 快速幂求解 a^k mod p
int qmi(int a, int k, int p) {
	int res = 1;
	// 求 k 的二进制表示
	while(k > 0) {
		if(k & 1 == 1) res = (LL) res * a % p;
		k = k >> 1;
		a = (LL)a * a % p;
	}
	return res;
}

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

练习题：acwing - 876: 快速幂求逆元

乘法逆元的定义：若两个数 $b$ 和 $m$ 互质，则对任意整数 $a$，如果 $b$ 能整除 $a$，则存在一个整数 $x$ ，使得 $\frac{a}{b}\equiv a\times x$，$\mathrm{mod}m$

则称 $x$ 是 $b$ 在模 $m$ 下的乘法逆元，记作 $b^{-1}\mathrm{mod}m$

其实，通俗的说，就是，对于两个互质的数 $b$ 和 $m$，一定存在一个数 $x$，使得所有能够被 $b$ 整除的数 $a$，都有 $\frac{a}{b}\equiv a\times x$ ，则称 $x$ 是 $b$ 在模 $m$ 下的乘法逆元，记作 $b^{-1}\mathrm{mod}m$

容易得到：$b\times b^{-1}\equiv 1$，即 $b\times b^{-1}\mathrm{mod}m=1$

求一个数 $b$ 在模 $m$ 下的逆元，即求一个数 $x$，满足 $b\times x\mathrm{mod}m=1$ 即可

若 $m$ 是一个质数，将其记为 $p$，则根据上面的费马小定理，有 $b^{p-1}\mathrm{mod}p=1$，则 $b$ 的逆元 $b^{-1}\mathrm{mod}p$就等于 $b^{p-2}\mathrm{mod}p$

若 $m$ 不是一个质数（但注意 $b$ 和 $m$ 是互质的），则根据欧拉定理，有 $b^{\varphi (m)}\mathrm{mod}m=1$，则 $b$ 的逆元 $b^{-1}\mathrm{mod}p$ 就等于 $b^{\varphi (m)-1}\mathrm{mod}p$

这道题考察的就是快速幂+费马小定理

#include<iostream>
using namespace std;

typedef long long LL;

int qmi(int a, int k, int p) {
	int res = 1;
	while(k > 0) {
		if(k & 1 == 1) res = (LL) res * a % p;
		k = k >> 1;
		a = (LL) a * a % p;
	}
	return res;
}

int main() {
	int n;
	scanf("%d", &n);
	while(n--) {
		int a, p;
		scanf("%d%d", &a, &p);
		if(a % p == 0) printf("impossible\n"); // a 和 p 不互质
		else printf("%d\n", qmi(a, p - 2, p));
	}
	return 0;
}

扩展欧几里得算法

裴蜀定理：对任意的一对正整数 $a$，$b$，一定存在一对非零整数 $x$，$y$，使得 $ax+by=gcd(a,b)$

令 $ax+by=d$，则 $d$ 一定是 $gcd(a,b)$ 的倍数。这个是显而易见的，令 $a$ 和 $b$ 的最大公约数是 $c$，即令 $gcd(a,b)=c$，则 $a$ 一定是 $c$ 的倍数，$b$ 也一定是 $c$ 的倍数，故 $ax+by$ 也一定是 $c$ 的倍数。则最小可以凑出的倍数就是 $1$。所以裴蜀定理是成立的。

那么给定一对正整数 $a$，$b$，如何求解出一对 $x$，$y$，使得 $ax+by=gcd(a,b)$ 成立呢？

求解 $x$，$y$ 的过程，就可以采用扩展欧几里得算法。

扩展欧几里得算法，是在欧几里得算法上的扩展。而欧几里得算法，就是前面求解最大公约数时，用到的辗转相除法。

练习题：acwing - 877: 扩展欧几里得算法

#include<iostream>
using namespace std;

int gcd(int a, int b, int &x, int &y) {
	if(b == 0) {
		x = 1;
		y = 0;
		return a;
	} else {
		 int d = gcd(b, a % b, y, x); // 注意这里要交换 x 和 y 的位置
		 y -= a / b * x;
		 return d;
	}
}

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

对代码的解释：

递归到当 $b=0$ 时，找到 $gcd(a,b)=a$，所以 $ax+by=a$，则此时更新 $x=1，y=0$。

当 $b\ne 0$ 时，先计算 $d=gcd(b,a\mathrm{mod}b)$，并且传入 $x$ 和 $y$ ，注意 $x$ 和 $y$ 的位置需要交换一下，然后此时有 $by+(a\mathrm{mod}b)x=d$，展开得 $by+(a-\lfloor \frac{a}{b}\rfloor b)x=d$，变换一下得 $ax+b(y-\lfloor \frac{a}{b}\rfloor x)$

则 $a$ 的系数 $x$ 不更新， $b$ 的系数 $y$ 需要更新为 $y-\lfloor \frac{a}{b}\rfloor x$

由于我们在递归时会交换 $x$ 和 $y$ 的位置，则实际两个数都会被交替更新。即我们在执行 gcd(b, a % b, y, x)这一句之后， $x$ 和 $y$ 都已经满足 $by+(a\mathrm{mod}b)x=d$，我们再通过 $b$ 与 $a\mathrm{mod}b$ 的系数，来更新 $a$ 和 $b$ 的系数。

注意，$x$ 和 $y$ 不是唯一的。由于我们的等式是 $ax+by=gcd(a,b)$，其中 $a$，$b$，$gcd(a,b)$ 都是固定的常数，所以这个式子其实可以转化为我们中学时学过的一次线性函数 $y=ax+b$ 的形式，这个函数的图像是一根直线，线上有多个点 $(x,y)$ 都满足这个等式，所以 $(x,y)$ 是有多组的（准确的说，有无穷多组）

我们只要求解出一组 $(x_0,y_0)$ 满足上面的等式。就可以求出所有的 $(x，y)$

$ax+by=d$ 可以写成 $a(x-\frac{b}{d})+b(y+\frac{a}{d})=d$

通解如下：$x=x_0-\frac{b}{d}\times k$，$y=y_0-\frac{a}{d}\times k$，其中 $k$ 是任意整数

扩展欧几里得算法的应用 —— 求解线性同余方程

练习题：acwing - 878: 线性同余方程

即，给定 $a$，$b$，$m$，求解一个 $x$，使得满足 $ax\equiv b$ $(\mathrm{mod}m)$

因为上面等式的含义是： $ax$ 除以 $m$，余数是 $b$ ，所以 $ax$ 一定是 $m$ 的某个倍数，加上 $b$，即 $ax=my+b$

再变形一下，得 $ax-my=b$，令 $y^{{}^{\prime }}=-y$，则有 $ax+m{y}^{{}^{\prime }}=b$

这样就转变成了上面使用扩展欧几里得算法能够求解问题，只需要保证 $b$ 是 $a$ 和 $m$ 的最大公约数的倍数即可，否则无解。

为什么要保证 $b$ 是 $a$ 和 $m$ 的最大公约数的倍数呢？解释如下

假设 $a$ 和 $m$ 的最大公约数是 $k$，那么根据上面的裴属定理，一定有一组 $(x,y)$ ，使得 $ax+my=k$ 成立，那么对于 $k$ 的倍数，比如 $t$ 倍，就是 $tk$，则一定有 $atx+mty=tk$。所以，只要保证 $b$ 是 $a$ 和 $m$ 的最大公约数的某个倍数，这个线性同余方程就有解，否则无解。

#include<iostream>
using namespace std;

typedef long long LL;

int gcd(int a, int b, int &x, int &y) {
	if(b == 0) {
		x = 1;
		y = 0;
		return a;
	} else {
		 int d = gcd(b, a % b, y, x); // 注意这里要交换 x 和 y 的位置
		 y -= a / b * x;
		 return d;
	}
}

int main() {
	int n;
	scanf("%d", &n);
	while(n--) {
		int a, b, m, x, y;
		scanf("%d%d%d", &a, &b, &m);
		int d = gcd(a, m, x ,y);
		if(b % d != 0) printf("impossible\n");
        else printf("%d\n", (LL)x * b / d % m);
	}
	return 0;
}

中国剩余定理

例子：有一个数，它除以3余2，除以5余3，除以7余2，问这个数是多少？

即 $x\equiv 2(\mathrm{mod}3)$，$x\equiv 3(\mathrm{mod}5)$，$x\equiv 2(\mathrm{mod}7)$

该问题的求解步骤如下：

1. 找出3和5的公倍数中，除以7余1的最小数，即15；找出3和7的公倍数中，除以5余1的最小数，即21；找出5和7的公倍数中，除以3余1的最小数，即70。
2. 用15乘以2（除7余2的2），用21乘以3（除5余3的3），用70乘以2（除3余2的2），把3个乘积加起来；得 $15\times 2+21\times 3+70\times 2=233$
3. 用 233 除以 3，5，7的最小公倍数 105 ，得到余数 23，答案即为23

这个求解过程，被称为中国剩余定理。更一般的描述如下：

给定一堆两两互质的数 $m_1$，$m_2$，…，$m_k$

存在一个数 $x$，满足

$x\equiv a_1(\mathrm{mod}{m}_1)$

$x\equiv a_2(\mathrm{mod}{m}_2)$

…

$x\equiv a_k(\mathrm{mod}{m}_k)$

求解这个 $x$，如下：

令$M=m_1\times m_2\times ...\times m_k$ ，令 $M_i=\frac{M}{m_i}$，即 $M_i$ 是除了 $m_i$ 之外其他所有数的乘积。

而由于对于 $j\in [1,k]，$ $m_j$ 之间两两互质，所以 $M_i$ 和 $m_i$ 互质。

而根据上面介绍的欧拉定理和乘法逆元，对于两个互质的数 $M_i$ 和 $m_i$，一定存在一个乘法逆元 $M_i^{-1}$ ，使得 $M_i\times M_i^{-1}\equiv 1(\mathrm{mod}{m}_i)$

则 $x=a_1\times M_1\times M_1^{-1}+a_2\times M_2\times M_2^{-1}+...+a_k\times M_k\times M_k^{-1}$ ，这个求解公式，就是中国剩余定理

特殊的，满足中国剩余定理的最小解是：
$x=(a_1\times M_1\times M_1^{-1}+a_2\times M_2\times M_2^{-1}+...+a_k\times M_k\times M_k^{-1})\mathrm{mod}M$

上面式子中的乘法逆元，可以用扩展欧几里得算法求解

参考链接：中国剩余定理学习笔记
（强推这篇博文，讲解的十分清晰）


练习题：acwing - 2024: 表达整数的奇怪方式

题解：

这道题，由于对a和m没有任何限制，所以不能完全套用中国剩余定理来求解。

先考虑2个线性同余等式

$x\mathrm{mod}{a}_1=m_1$，$x\mathrm{mod}{a}_2=m_2$

可以写成如下的式子

$x=k_1{a}_1+m_1$，$x=k_2{a}_2+m_2$

则 $k_1{a}_1+m_1=k_2{a}_2+m_2$

移项并整理一下，得 $k_1{a}_1-k_2{a}_2=m_2-m_1$

这就可以使用扩展欧几里得算法来求解，当然，上式有解的条件是 $gcd(a_1,a_2)|m_2-m_1$，即 $m_2-m_1$ 能够被 $a_1$ 和 $a_2$ 的最大公约数整除。

用扩展欧几里得算法求出上式的一组解 $k_{10}$，$k_{20}$，随后可求出一组通解为

$k_1=k_{10}+k\frac{a_2}{d}$，$k_2=k_{20}+k\frac{a_1}{d}$

其中 $k$ 为任意整数，$d$ 为 $gcd(a_1,a_2)$

则 $x=(k_{10}+k\frac{a_2}{d})a_1+m_1=a_1{k}_{10}+m_1+k\frac{a_1{a}_2}{d}$

令 $x_0=a_1{k}_{10}+m_1$，$a=\frac{a_1{a}_2}{d}$，则 $x=x_0+ka$

这样就将2个不定方程，变成了1个不定方程。

只需要执行n-1次合并，就能将n个不定方程，变成1个不定方程。

最后就是求解一个形如 $x=x_0+ka$ 的不定方程，其中 $x_0$ 和 $a$ 是固定值

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

typedef long long LL;

// 扩展欧几里得算法
LL exgcd(LL a, LL b, LL &x, LL &y) {
	if (b == 0) {
		x = 1;
		y = 0;
		return a;
	}
	LL d = exgcd(b, a % b, y, x);
	y -= a / b * x;
	return d;
}

int main() {
	int n;
	scanf("%d", &n);
	bool no_ans = false;
	LL a1, m1;

	cin >> a1 >> m1;
	for (int i = 0; i < n - 1; i++) {
		LL a2, m2;
		cin >> a2 >> m2;
		LL k1, k2;
		LL d = exgcd(a1, a2, k1, k2);
		if ((m2 - m1) % d != 0) {
			no_ans = true;
			break;
		}
		k1 *= (m2 - m1) / d;
		LL t = a2 / d;
		k1 = (k1 % t + t) % t; // 将k1置为最小的正整数解
		// 更新a1和m1, 准备下一轮的合并
		m1 = a1 * k1 + m1;
		a1 = abs(a1 / d * a2);
	}
	if (no_ans) printf("-1");
	else printf("%lld", (m1 % a1 + a1) % a1);
}

（2021/07/30 更新：补充了中国剩余定理的部分内容，还剩一道练习题的题解）
（2021/08/03 更新：补充了中国剩余定理的练习题题解）