基础数论

欧拉函数 $\phi (x)$

https://oi-wiki.org/math/number-theory/euler/

$\phi (x)=\sum _{k=1}^x[gcd(k,x)=1]，$表示 $1\sim x-1$ 中与 $x$ 互质的数。

欧拉函数是一个积性函数，但不是完全积性函数。

• 积性函数：$f(1)=1$，且当 $gcd(x,y)=1$ 时，$f(xy)=f(x)f(y)$。
• 完全积性函数：$f(1)=1$，且 $\mathrm{\forall }x,y,f(xy)=f(x)f(y)$。

性质

• $\phi (n)=n\times \prod _{p\mid n,pisaprime}{\displaystyle \frac{p-1}{p}}$
• $\phi (p^k)=p^k-p^{k-1}$
• $\sum _{gcd(i,n)=1}i={\displaystyle \frac{\phi (n)\times n}{2}}$

欧拉定理

若 $gcd(k,n)=1$，则有 $k^{\phi (n)}\equiv 1(\mathrm{mod}n)$

证明

设序列 $a$ 为 $1\sim n$ 中与 $n$ 互质的数，为 $\{a_1,a_2,a_3,\dots ,a_{\phi (n)}\}$，显然有以下两条性质：

• $\mathrm{\forall }i$，有 $gcd(a_i,n)=1$，也就是 $a_i$ 与 $n$ 互质。这是显然的，因为这是欧拉函数的定义；
• $\mathrm{\forall }(i,j)$，有 $a_i\not\equiv a_j(\mathrm{mod}n)$。因为所有 $a_i$ 都是 $<n$ 的。

现在找到一个数 $k$，满足 $gcd(k,n)=1$，也就是 $k$ 与 $n$ 互质，并重新定义一个序列 $b=\{k{a}_1,k{a}_2,k{a}_3,\dots ,k{a}_{\phi (n)}\}$，那么现在证明仍然满足上面的性质：

• $\mathrm{\forall }i$，有 $gcd(b_i,n)=1$，也就是 $b_i$ 与 $n$ 互质。由于 $b_i=k\times a_i$，又因为 $k$ 与 $n$ 互质，$a_i$ 与 $n$ 互质，所以 $k\times a_i$ 也与 $n$ 互质；
• $\mathrm{\forall }(i,j)$，有 $b_i\not\equiv b_j(\mathrm{mod}n)$。利用反证法，若 $b_i\equiv b_j(\mathrm{mod}n)$，则这个式子可以变为 $k{a}_i\equiv k{a}_j(\mathrm{mod}n)$。两边同时 $÷k$，也就变成了 $a_i\equiv a_j(\mathrm{mod}n)$，这与上面的结论不符。故 $b_i\not\equiv b_j(\mathrm{mod}n)$。.

若将所有的 $b_i$ 对 $n$ 取模，也就是 $b_i^{\prime }=k{a}_{i}modn$，那么根据上面的证明，可知 $b^{\prime }$ 中的元素互不相同。而且由于有过取模，所以 $b_i^{\prime }$ 一定是在 $[0,n)$ 的范围内的，所以 $b_i^{\prime }$ 与 $n$ 互质。像这样大小为 $\phi (n)$，各不相同，且与 $n$ 都互质的数构成的序列有且仅有一个，所以 $b^{\prime }=a$。

所以可以得到：

$$\prod _{i=1}^{\phi (n)}{a}_i=\prod _{i=1}^{\phi (n)}{b}_i^{\prime }=\prod _{i=1}^{\phi (n)}(k{a}_{i}modn)=\left(\prod _{i=1}^{\phi (n)}{a}_i\right)\times k^{\phi (n)}modn$$

等式两边同时 $÷\prod _{i=1}^{\phi (n)}{a}_i$，则有：

$$k^{\phi (n)}\equiv 1(\mathrm{mod}n)$$

应用

• 求逆元：${\displaystyle \frac{1}{k}}\equiv k^{\phi (p)-1}(\mathrm{mod}p)$（当 $p$ 为质数时）。
• 降低指数：$k^a\equiv k^{amod\phi (p)}(\mathrm{mod}p)$。
• 扩展欧拉定理：$p$ 可以不是质数，$k$ 可以不与 $p$ 互质。

$$k^a\equiv \{\begin{array}{cc}{k}^a& a<\phi (p)\\ k^{amod\phi (p)+\phi (p)}& a\ge \phi (p)\end{array}(\mathrm{mod}p)$$

求解

$\mathrm{\Theta }(\sqrt{n})$ 求一个 $\phi (n)$：$\phi (n)=n\times \prod _{p\mid n,pisaprime}{\displaystyle \frac{p-1}{p}}$

$\mathrm{\Theta }(n)$ 求 $\phi (1)\sim \phi (n)$：线性筛法：

• 若 $i$ 是质数，显然 $1\sim i-1$ 都与 $i$ 互质，故 $\phi (i)=i-1$；
• 枚举 $j$，找到 $p_j\times i$，分两种情况求解 $\phi (p_j\times i)$：
  • 若 $imod{p}_j=0$，也就是 $p_j$ 是 $i$ 的最小质因子。那么也就是说在原来的 $i$ 中就已经有了一个质因子 $p_j$，所以 $i$ 和 $i\times p_j$ 的质因子是相同的。假设 $i$ 的所有质因子是 $q_k$，那么 $i\times p_j$ 的质因子也是 $q_k$，所以有 $\phi (p_j\times i)=p_j\times i\times \prod _{q\mid i,qisaprime}{\displaystyle \frac{q-1}{q}}$。其中后面的 $\prod _{q\mid i,qisaprime}{\displaystyle \frac{q-1}{q}}$ 就是 $\phi (i)$ 的值，所以 $\phi (p_j\times i)=p_j\times \phi (i)$；
  • 若 $imod{p}_j\ne 0$，也就是 $p_j$ 不是 $i$ 的最小质因子。那么根据积性函数的定义，显然有 $\phi (p_j\times i)=\phi (p_j)\times \phi (i)$，也就是 $\phi (p_j\times i)=(p_j-1)\times \phi (i)$。

int p[N];		// p[i] 表示第 i 个质数
bool st[N];		// st[i] 表示 i 是否是质数
int phi[N];

void prime(int n)
{
	phi[1] = 1;
	for (int i = 2; i <= n; i ++ )
	{
		if (!st[i]) p[ ++ cnt] = i, phi[i] = i - 1;
		for (int j = 1; p[j] <= n / i; j ++ )
		{
			st[p[j] * i] = 1;
			if (i % p[j]) phi[i * p[j]] = phi[i] * p[j];
			else
			{
				phi[i * p[j]] = phi[i] * (p[j] - 1);
				break;
			}
		}
	}
}

---

除数函数 ${\sigma }_k(x)$

${\sigma }_k(x)=\sum _{d\mid x}{d}^k$。

$k=0$ 时，含义为 $n$ 的约数个数和。

$k=1$ 时，含义为 $n$ 的约数和。

除数函数全部是积性函数，但不是完全积性函数。

${\sigma }_0$ 求解

$\mathrm{\Theta }(\sqrt{n})$ 求一个 ${\sigma }_0(n)$：若 $n=\prod _{i=1}^m{p}_i^{c_i}$，那么根据乘法原理，有 ${\sigma }_0(n)=\prod _{i=1}^m(c_i+1)$。

$\mathrm{\Theta }(n)$ 求 ${\sigma }_0(1)\sim {\sigma }_0(n)$：线性筛法：

在线性筛约数个数时还需要额外记录一个 $nu{m}_i$ 数组，表示 $i$ 的最小质因子的出现次数。

• 若 $i$ 是质数，那么根据质数的定义，$i$ 只有两个约数 $1$ 和 $i$，故 ${\sigma }_0(i)=2$，而且显然 $nu{m}_i=1$；
• 枚举 $j$，找到 $p_j\times i$，分两种情况求解 ${\sigma }_0(p_j\times i)$：
  • 若 $imod{p}_j=0$，也就是 $p_j$ 是 $i$ 的最小质因子。那么 $i$ 原来有 $p_j$ 这个约数，并且是最小的约数，现在的 $p_j\times i$ 相比 $i$ 又多了一个 $p_j$，也就是原来的 $\times (p_j+1)$ 变成了 $\times (p_j+1+1)$，也就是 $\times (p_j+2)$。所以求 ${\sigma }_0(p_j\times i)$ 时就需要先把原来 $(p_j+1)$ 的贡献移除，在重新加上 $(p_j+2)$ 的贡献，也就是 ${\sigma }_0(p_j\times i)={\sigma }_0(i)\times {\displaystyle \frac{p_j+2}{p_j-1}}$；
  • 若 $imod{p}_j\ne 0$，也就是 $p_j$ 不是 $i$ 的最小质因子。那么也就是说原来的 $i$ 中没有 $p_j$ 这个约数，所以把 $p_j\times i$ 分解质因数后应该有一项是 $p_j^1$，剩下的是原来 $i$ 分解质因数的结果。根据约数个数的公式，将所有的指数加 $1$ 后连乘，那么就应该在原来 ${\sigma }_0(i)$ 的基础上 $\times (1+1)$，所以 ${\sigma }_0(p_j\times i)=2\times {\sigma }_0(i)$。

int p[N];		// p[i] 表示第 i 个质数
bool st[N];		// st[i] 表示 i 是否是质数
int d[N];		// d[i] 表示 σ0(i) 的值 
int num[N];		// num[i] 表示 i 的最小质因子出现次数 

void prime(int n)
{
	d[1] = 1;
	for (int i = 2; i <= n; i ++ )
	{
		if (!st[i]) p[ ++ cnt] = i, d[i] = 2, num[i] = 1;
		for (int j = 1; p[j] <= n / i; j ++ )
		{
			st[p[j] * i] = 1;
			if (i % p[j]) num[i * p[j]] = 1, d[i * p[j]] = d[i] * 2;		// p[j] 不是 i 的最小质因子 
			else 	// p[j] 是 i 的最小质因子 
			{
				num[i * p[j]] = num[i] + 1, d[i * p[j]] = d[i] / （num[i * p[j]] + 1) * (num[i * p[j]] + 2);
				break;
			}
		}
	}
}

---

莫比乌斯函数 $\mu (x)$

https://oi-wiki.org/math/number-theory/mobius/

$\mu (n)=\{\begin{array}{cc}1& n=1\\ 0& n\mathrm{含}\mathrm{有}\mathrm{平}\mathrm{方}\mathrm{因}\mathrm{子}\\ (-1{)}^{\mathrm{本}\mathrm{质}\mathrm{不}\mathrm{同}\mathrm{质}\mathrm{因}\mathrm{子}\mathrm{个}\mathrm{数}}& \mathrm{otherwise}\end{array}$

性质：$\sum _{d\mid n}\mu (d)=\{\begin{array}{cc}1& n=1\\ 0& n\ne 1\end{array}$

莫比乌斯函数是积性函数，但不是完全积性函数。

求解

$\mathrm{\Theta }(\sqrt{n})$ 求一个 $\mu (n)$；

$\mathrm{\Theta }(n)$ 求 $\mu (1)\sim \mu (n)$：线性筛法：

• 若 $i$ 是质数，那么 $i$ 就只有一个质因子 $i$，所以 $\mu (i)=(-1{)}^1=-1$；
• 枚举 $j$，找到 $p_j\times i$，分两种情况求解 $\mu (p_j\times i)$：
  • 若 $imod{p}_j=0$，也就是 $p_j$ 是 $i$ 的最小质因子。设 $q={\displaystyle \frac{p_j}{i}}$，那么显然有 $p_j\times i=q\times i^2$，所以 $p_j\times i$ 就有了一个平方因子，所以 $\mu (p_j\times i)=0$；
  • 若 $imod{p}_j\ne 0$，也就是 $p_j$ 不是 $i$ 的最小质因子。那么 $p_j\times i$ 就比 $i$ 多了一个新的质因子 $p_j$，故它的本质不同的质因子个数就多了 $1$，所以 $\mu (p_j\times i)=-\mu (i)$。

void prime(int n)
{
	mu[1] = 1;
	for (int i = 2; i <= n; i ++ )
	{
		if (!st[i]) p[ ++ cnt] = i, mu[i] = -1;
		for (int j = 1; p[j] <= n / i; j ++ )
		{
			st[p[j] * i] = 1;
			if (i % p[j]) mu[p[j] * i] = -mu[i];		// p[j] 不是 i 的最小质因子 
			else 	// p[j] 是 i 的最小质因子 
			{
				mu[i * p[j]] = 0;
				break;
			}
		}
	}
}

---

欧几里得算法

https://oi-wiki.org/math/number-theory/gcd/#%E6%AC%A7%E5%87%A0%E9%87%8C%E5%BE%97%E7%AE%97%E6%B3%95

求 $gcd(a,b)$，辗转相除法。

$\because gcd(a,b)=gcd(b,amodb)$

$\therefore gcd(b,amodb)=gcd(amodb,bmod(amodb))$

$gcd(amodb,bmod(amodb))=gcd(bmod(amodb),(amodb)mod(bmod(amodb)))$

$⋮$

$gcd(a,0)=a$

回溯得到答案。

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

扩展欧几里得算法

https://oi-wiki.org/math/number-theory/gcd/#%E6%89%A9%E5%B1%95%E6%AC%A7%E5%87%A0%E9%87%8C%E5%BE%97%E7%AE%97%E6%B3%95

求二元一次方程 $ax+by=c$ 的解。

裴蜀定理

裴蜀定理：有解当且仅当 $gcd(a,b)\mid c$。

证明：

1. 有解当且仅当 $gcd(a,b)\mid c$：

   设 $d=gcd(a,b),a=k_{1}d,b=k_{2}d$，则 $ax+by=k_{1}dx+k_{2}dy=(k_{1}x+k_{2}y)\times d$。这个数一定是 $d$ 的倍数。证毕。

2. $gcd(a,b)$ 是 $ax+by$ 的最小整数解：

   设 $d=gcd(a,b)$， $m$ 是 $ax+by$ 的最小整数解，即 $ax+by=m$。接下来从两个方面证明 $d=m$。

   1. $m\ge d$：与上面类似。设 $a=k_{1}d,b=k_{2}d$，则 $ax+by=k_{1}dx+k_{2}dy=(k_{1}x+k_{2}y)\times d=m\ge d$。

   2. $m\le d$：因为 $d\mid a$ 且 $d\mid b$，尝试证明 $m\mid a$ 且 $m\mid b$。由于 $d$ 是最大公约数，所以 $m\le d$。

      反证法：设 $m\nmid a$，则 $a=km+r,r\in [1,m)$，则 $r=a-km$。因为 $m=ax+by$，则 $r=a-kax-kby$，即 $r=a(1-kx)+b(-ky)$，即得到一组新的解，使得 $ax+by=r$，于 $m$ 是最小正整数结果矛盾，故 $m\mid a$，同理 $m\mid b$。

   证毕。

求解

把这个方程中的 $a,b$ 带入 $gcd(a,b)$ 欧几里得算法中。

$a_1{x}_1+b_1{y}_1=c$

$a_2{x}_2+b_2{y}_2=c$

其中 $a_2=b_1,b_2=a_{1}mod{b}_1=a_1-\lfloor {\displaystyle \frac{a_1}{b_1}}\rfloor \times b_1$。

这样第二个式子就变成了 $b_1{x}_2+(a_1-\lfloor {\displaystyle \frac{a_1}{b_1}}\rfloor \times b_1)\times y_2$。

整理式子：

$b_1{x}_2+a_1{y}_2-\lfloor {\displaystyle \frac{a_1}{b_1}}\rfloor \times b_1{y}_2$

$a_1{y}_2+b_1\times (x_2-\lfloor {\displaystyle \frac{a_1}{b_1}}\rfloor \times y_2)$

至此，这个式子与最开始 $a_2{x}_2+b_2{y}_2=c$ 变得很像，也就是说如果需要从第二个式子变到第一个式子需要 $x_1\leftarrow y_2,y_1\leftarrow (x_2-\lfloor {\displaystyle \frac{a_1}{b_1}}\rfloor \times y_2)$。

这是第二层转换到第一层的过程，在这之前如果要求第二个式子需要往下的第三个式子进行推导，那么就需要写递归函数求解了。

当某个 $y_m=0$ 时，$gcd$ 函数行该返回 $x_m$，此时 $x_m=1,y_m=\text{任意数}$，这里 $y_m=0$，返回函数即可。

代码：

int exgcd(int a, int b, int &x, int &y)
{
	if (!b)
	{
		x = 1, y = 0;
		return a;
	}
	int d = exgcd(b, a % b, x, y);
	int X = x;
	x = y, y = X - a / b * y;
	return d;
}

或：

int exgcd(int a, int b, int &x, int &y)
{
    if (!b)
    {
        x = 1; y = 0;
        return a;
    }
    int d = exgcd(b, a % b, y, x);
    y -= (a / b) * x;
    return d;
}

如果 $(x,y)$ 是一组解，那么 $(x+{\displaystyle \frac{b}{g}},y-{\displaystyle \frac{a}{g}})$ 也是一组解，其中 $g\ne 0$。

求逆元

求 $x$，使得 $xk\equiv 1(\mathrm{mod}p)$。

也就是求 $x\times k+y\times p=1$。

于是就转化成了二元一次方程，求的是 $x$ 在 $[0,p-1]$ 区间内的一个解。

这个方法对 $p$ 的素性没有要求。

int inv(int a, int b)
{
	int x, y, d = exgcd(a, b, x, y);
	if (d == 1) return (x % b + b) % b;
	else return -1;
}

筛质数

https://oi-wiki.org/math/number-theory/sieve/

• 埃氏筛：$\mathrm{\Theta }(n\times \ln (n))$。

从小到大枚举每一个数字，如果之前被筛掉了，那么不是质数，否则就是质数。

无论当前的 $i$ 是不是质数，枚举已经筛出来的每一个质数 $p{m}_j$，把 $i\times p{m}_j$ 筛掉，直到 $i\times p{m}_j$ 大于上街 $n$ 或者质数枚举完毕结束。

这个筛法从来不用。

• 线性筛：$\mathrm{\Theta }(n)$。

对于每一个数字 $x$，仅在 $p{m}_{j^{\prime }}\times i^{\prime }$ 的时候被筛掉，其中 $p{m}_{j^{\prime }}$ 是 $x$ 的最小质因数。

在枚举 $pm$ 的时候，加一句判断，如果 $p{m}_j\mid i$，那说明 $i$ 的最小质因子为 $p{m}_j$，之后再枚举 $pm$ 就不满足要求了，直接 break。

int p[N];
bool st[N];

void prime(int n)
{
	for (int i = 2; i <= n; i ++ )
	{
		if (!st[i]) p[ ++ cnt] = i;
		for (int j = 1; p[j] <= n / i; j ++ )
		{
			st[p[j] * i] = 1;
			if (i % p[j] == 0) break;
		}
	}
}

扩展

线筛除了可以筛质数，还可以筛一类满足条件的函数。

• $f(1),f(pm)$ 可以直接求（$pm$ 指任意一个质数）；
• 设 $p{m}_{j^{\prime }}$ 为 $x$ 的最小质因子，$p{m}_{j^{\prime }}\times i^{\prime }=x$。

那么已知 $f(p{m}_{j^{\prime }})$ 和 $f(i^{\prime })$ 可 $\mathrm{\Theta }(1)$ 或 $\mathrm{\Theta }(\log n)$ 求出 $f$ 值。

中国剩余定理 CRT

https://oi-wiki.org/math/number-theory/crt/

有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二。问物几何？

给定 $a_i,p_i$，其中 $p_i$ 两两互质，求 $x$，满足：

$$\{\begin{array}{c}x\equiv a_1(\mathrm{mod}{p}_1)\\ x\equiv a_2(\mathrm{mod}{p}_2)\\ \dots \dots \dots \dots \\ x\equiv a_n(\mathrm{mod}{p}_n)\end{array}$$

定义一个 $b$ 数组，$b_i\equiv \{\begin{array}{cc}{a}_i& (\mathrm{mod}{p}_i)\\ 0& (\mathrm{mod}{p}_{j\ne i})\end{array}$。

显然 $x=\sum _{i=1}^n{b}_i$。

我们可以这样得到一个 $b_i$：${\displaystyle \frac{P}{p_i}}\times a_i\times {\left({\displaystyle \frac{P}{p_i}}\right)}^{p_i-2}$，其中 $P=\prod _{i=1}^n{p}_i$。

$b_i$ 可能很大，对 $P$ 取模。

时间复杂度 $\mathrm{\Theta }(n\log n)$。

void exgcd(int a, int b, int &x, int &y)
{
    if (!b)
    {
        x = 1, y = 0;
        return;
    }
    exgcd(b, a % b, y, x);
    y -= a / b * x;
}

signed main()
{
    cin >> n;
    
    int M = 1;
    for (int i = 0; i < n; i ++ )
    {
        cin >> A[i] >> B[i];
        M *= A[i];
    }
    
    int res = 0;
    for (int i = 0; i < n; i ++ )
    {
        int Mi = M / A[i], ti, x;
        exgcd(Mi, A[i], ti, x);
        res += B[i] * Mi * ti;
    }
    
    cout << (res % M + M) % M;
    
    return 0;
}

扩展中国剩余定理 EXCRT

如果 $p_i$ 不两两互质，换一个角度分析问题。

求解 $x$ 实际上是合并方程。最终得到：

$$x\equiv A(\mathrm{mod}P)⟺x=A+kP(k\in \mathbb{Z})$$

如果能把两个式子 $x\equiv a_1(\mathrm{mod}{p}_1)$ 和 $x\equiv a_2(\mathrm{mod}{p}_2)$ 合并成 $x\equiv a_{12}mod{p}_{12}$，那么就可以用一般方法不断地合并两个方程，直到仅剩一个方程，得到答案。其中 $p_{12}=\mathrm{lcm}(p_1,p_2)\ne p_1{p}_2$，$a_{12}$ 是原方程组的任意一个特解。

如何求 $a_{12}$？

• $x\equiv a(\mathrm{mod}p)⟺x=a+kp(k\in \mathbb{Z})$
• $\{\begin{array}{c}x\equiv a_1(\mathrm{mod}{p}_1)\\ x\equiv a_2(\mathrm{mod}{p}_2)\end{array}⟺\{\begin{array}{c}x=a_1+k_1{p}_1\\ x=a_2+k_2{p}_2\end{array}$
• $k_1{p}_1-k_2{p}_2=a_2-a_1$

根据裴蜀定理，上式有解当且仅当 $gcd(p_1,p_2)\mid a_2-a_1$。

扩欧求出 $k_1$ 特解，带入得到 $x$ 特解记为 $a_{12}$。

然后不断将方程两两合并即可找到 $x$。

int exgcd(int a, int b, int &x, int &y)  // 扩展欧几里得算法, 求x, y，使得ax + by = gcd(a, b)
{
    if (!b)
    {
        x = 1; y = 0;
        return a;
    }
    int d = exgcd(b, a % b, y, x);
    y -= (a / b) * x;
    return d;
}

int a1, m1;     // 现有方程
int a2, m2;     // 读入的方程
int k1, k2;     // 系数
int d;          // 最大公约数
int t;

signed main()
{
    cin >> n >> a1 >> m1;
    
    for (int i = 0; i < n - 1; i ++ )
    {
        cin >> a2 >> m2;
        d = exgcd(a1, a2, k1, k2);
        if ((m2 - m1) % d)      // 裴蜀定理，判断是否无解
        {
            puts("-1");
            return 0;
        }
        
        k1 *= (m2 - m1) / d; // 把 k1a1 - k2a2 = m2 - m1 翻成 k1a1 - k2a2 = d
        t = a2 / d;
        k1 = (k1 % t + t) % t;
        
        m1 = a1 * k1 + m1;
        a1 = abs(a1 / d * a2);
    }
    
    cout << (m1 % a1 + a1) % a1;
    
    return 0;
}