简单数论总结

一、欧几里得定理

欧几里得定理主要可以解决$GCD$问题，也就是所谓的最大公约数。基础思想就是所谓的『辗转相除』。就是两个数字不停地相互取模，最后当其中一个等于$0$的时候另一个数字就是我们要求的$GCD$了。

这个比较基础，直接上代码吧：

int gcd(int a, int b){
    if(b == 0) return a;
    else return gcd(b, a % b);
}

当然还有更短的版本：

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

知道了这个之后，$LCM$（最小公倍数）也就可以求了。两个数的最小公倍数就等于$a\ast b/GCD(a,b)$。用c++来说的话就是：

int lcm(int a, int b){
	return a * b / gcd(a, b);
}

知道原理的话这个也就非常简单了。

二、扩展欧几里得

我们先来考虑二元一次方程。一般来说二元一次方程必须要两个式子才能求解。但如果我们只有一个式子呢？？那我们求出来的就是一个解系。说人话的话就是会有很多解。我们用扩展欧几里得所求的是这么多解中的其中一个~~（任意一个）~~。

那么，如何做到呢？？

各位客官请看，这里有一个式子：

$ax+by=GCD(a,b)$

$b{x}^{\prime }+(a\%b)y^{\prime }=GCD(a,b)$

$\because a\%b=a-a/b\ast b$

$\therefore b{x}^{\prime }+(a-a/b\ast b)y^{\prime }=GCD(a,b)$

$b{x}^{\prime }+a{y}^{\prime }-b\ast a/b\ast y^{\prime }=GCD(a,b)$

$a{y}^{\prime }+b(x^{\prime }-a/b\ast y^{\prime })=GCD(a,b)$

由上面的证明可知，$x=y^{\prime }$，y = $x^{\prime }-a/b\ast y^{\prime }$

那我们就一直递归下去，直到$b=0$。然后呢？我们想，$GCD(a,b)$中$b=0$时，$GCD(a,b)=a$，又原方程可得$ax=a$，即$x=1$。

代码奉上：

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

一般来说会用传地址的方式实现，但我用的是全局变量。主要是因为$x$和$y$的值会不停地变，所以说要么要传地址要么全局变量，当然指针也可以。

任意解就会出现以下问题：

• 你的解比最小正整数解大
• 你的解是个负数

解决思路：$x$的值是可以任意的加上批量$b$的。

为什么？

$ax+by=1$（假设$a$和$b$互质）

$ax+by+k\ast ab-k\ast ab=1$

$a(x+bk)+b(y-ak)=1$ 或者 $a(x-bk)+b(y+ak)=1$

那就很简单了，如果小于0，那就一直加$b$直到$x>0$。如果大于的话就取模。

上面说的大概是不对的。刚刚好像发现扩展欧几里得所得到的解是$x+y$最小的一组解。

那么要是想要改变$x$和$y$的值的话，那就可以$x\pm \frac{LCM(a,b)}{a}$, $y\pm \frac{LCM(a,b)}{b}$

但是如果只是想要最小正整数解的话，完全可以$(x+b)\%b$

三、素数问题

素数问题一般指的就是将素数筛出来。~~出于懒惰，~~这里不会讲解欧拉筛法。

那就只剩下埃氏筛啦！！

超级暴力，时间复杂度是$O(nloglogn)$具体实现大概就是要枚举前$\sqrt{n}$个数。如果这个数没有被访问过，那就说明这个数是素数，标出来。然后将它所有的倍数都标记为已访问过（也就是合数）。最终就将所有的素数都找出来了$Orz$。

void prime(int n){
    bool vis[maxn];
    int m=(int)sqrt(n + 0.5);
    memset(vis, 0, sizeof(vis));
    vis[1] = 1;
    for(int i = 2;i <= m;i++)
        if (!vis[i])
            for (int j = i * i;j <= n;j += i)
            	vis[j]=1;
}

在这个程序里是如果是素数$vis[i]$就是$0$。

四、逆元

一个数逆元在一般情况下就是等于这个数的倒数，也就是$inv[x]=x^{-1}$。但是，如果在膜p意义下就不一定了。为什么不一定呢？

思考…

那么在膜p意义下的逆元应该怎么求呢？在我这里有这么几个办法：

1、扩展欧几里得法

扩展欧几里得在之前也已经讲了，那么应该如何应用呢？？

$ax\equiv 1(\%p)$

那么这个就很明显，$a$是$x$在$\%p$意义下的逆元。这个式子就是一个同余方程啊，那就这么转化：

$ax\%p=1$

$ax-bp=1$

这里面x和p是已知的。那就让$x^{\prime }=a$，$a^{\prime }=x$，$b^{\prime }=p$，$ y’ = b$。

然后就转化为了：

$a^{\prime }{x}^{\prime }+b^{\prime }{y}^{\prime }=1$

就此完成了转化。但是限制条件就是$x$和$p$要互质.

2、费马小定理

费马小定理内容是这个样子的：

$a^{p-1}\equiv 1(\%p)$

那我们就可以利用这个定理来解决问题了。

我们进行这样的转化：

$a\ast a^{p-2}\equiv 1(\%p)$

很明显，$a^{p-2}$就是$a$的逆元。这个就可以用快速幂来实现了。$p$要是质数。

那问题来了，如果说他们不互质，那该怎么求？？？

3、递推法

先给出结论：

$inv[i]=(p-p/i)\ast inv[p\%i]\%p$

怎么推导呢？？

我们都知道，$p\%p=0$

那么就说明$p/i\ast i+p\%i\equiv 0(\%m)$

为了方便 ，我们来换一下元。设$t=p/i$，$k=p\%i$

那么原式就成了：

$=t\ast i+k\equiv 0(\%m)$

$=-t\ast i\equiv k(\%m)$(移项）

$=-t/k\equiv 1/i(\%m)$（同时除以$i\ast k$）

$=-t\ast 1/k\equiv 1/i(\%m)$

$=-t\ast inv[k]\equiv inv[i](\%m)$

$inv[i]=-p/i\ast inv[p\%i]\%p$

$=(p-p/i\ast inv[p\%i]\%p)$

很难受的是，这个算法必须保证$p$是奇素数。

SP、阶乘的逆元

一般用阶乘用的最多的就是排列组合了吧。在这里就不打算说排列组合了，就直接给公式吧：

$A_n^m=\frac{n!}{(n-m)!}$

这里$A$表示排列数，也就是同样的数字不一样排也算在内。

$C_n^m=\frac{n!}{m!(n-m)!}$

这个就不用说了吧。上面的式子都是从$n$个数字中选择$m$个进行组合。我们发现在分母中都出现了阶乘，那么在模数意义下肯定要乘逆元啦。那么，怎么算逆元呢？？

fac[0] = 1;
for(int i = 1; i <= n; i++){
	fac[i] = fac[i - 1] * i % mod;
}
invfac[n] = pow(n, mod - 2);
for(int i = n; i >= 1; i--){
	invfac[i - 1] = invfac[i] * i % mod;
}

这样就打表找出了阶乘的逆元。

4、欧拉法

唉，真香，明明刚刚说了不说欧拉函数来着$Orz$

欧拉函数可以用来求逆元。但是在这之前，我们要先来了解一下欧拉函数。

欧拉函数，$\phi (x)$，是用来表示在小于等于$x$的数中有多少与$x$互质。特别来说，$\phi (1)=1$.

欧拉函数还有一下这么几个性质：

1. 若a为质数,$\phi (a)=a-1$
2. 若a为质数,$b\%a=0,phi(a\ast b)=phi(b)\ast a$
3. 若a b互质,$\phi (a\ast b)=\phi (a)\ast \phi (b)$

那么我们就可以把求欧拉函数和筛素数放在一块来求$Orz$

int prime[maxn];//筛素数，若为素数则为0，否则为1
int p[maxn];//用来存放素数
int cnt;//有多少个素数
int phi[maxn];//欧拉函数
int n;

void getphi(){
    phi[1] = 1;
    for(int i = 2; i <= n; i++){
        if(!prime[i]){//如果是质数
            p[++cnt] = i;
            phi[i] = i - 1;//由特性1可知
        }
        for(int j = 1; j <= cnt && p[j] * i < n; j++){
            prime[p[j] * i] = 1;
            if(!i % p[j]){
                phi[p[j] * i] = phi[i] * p[j];//特性2
                break;
            }
            else phi[p[j] * i] = phi[i] * (p[j] - 1);//特性3
        }
    }
}

那么，怎么求逆元呢？

这就需要我们的欧拉定理了！

$a^{\phi (p)}\equiv 1(\%p)$

那么我们将它转化一下：

$a\ast a^{\phi (p)-1}\equiv 1(\%p)$

所以$a^{\phi (p)-1}$就是$a$的逆元了

五、Lucas定理

定理内容：如果$p$是质数，那么对于任意整数$1<=m<=n$，有：

$C_n^m=C_{nmodp}^{mmodp}\ast C_{n/p}^{m/p}(modp)$

说白了就是把$n$和$m$表示成$p$进制数，对$p$进制下的每一位分别计算组合数，也就是所谓的『分治』思想吧

	#include <iostream>
	using namespace std;
	#define endl "\n"

    long long p;
    long long pow(long long a, long long n) {
        long long res = 1;
        while(n) {
            if(n & 1) res *= a;
            a *= a;
            n >>= 1;
        }
        return res;
    }
    
    long long C(long long n, long long m) {
        if(m > n) return 0;
        long long a = 1, b = 1;
        for(register long long i = n - m + 1; i <= n; ++i)
            a = (a * i) % p;
        for(register long long i = 2; i <= n; ++i)
            b = (b * i) % p;
        return a * pow(b, p - 2) % p;
    }
    
    long long Lucas(long long n, long long m) {
        if(!m) return 1;
        return (C(n % p, m % p) * Lucas(n / p, m / p)) % p;
    }
    int main() {
        int n, m;
        cin >> n >> m;
        cout << Lucas(n, m) << endl;
    }

因为设置的情景实在$\%p$意义下，所以取了逆元，用的是费马小定理。组合数也是用的公式法

六、欧拉定理

$a^{\phi (n)}\equiv 1(modn)$