数论基础知识点整理（基础篇）

这是我在ACM竞赛中学习数论时整理的一些基础的知识点，主要讨论整除、同余、最大公约数以及素数及其判定、快速幂、逆元，写的不太专业，有错误的地方还请多批评指正！

整除

• 定义： 整数$a,b\in \mathbb{Z},且a\ne 0$,若$\exists q$,使得$b=aq$，则称b可被a整除（或a能整除b），记作$a\mid b$；且称b是a的倍数，a是b的约数（或因子、因数）。若a不能整除b，则记作$a\nmid b$
• 定理
  • 1. $a\mid b，且b\mid c，则a\mid c$
    • 证明： $\because a\mid b,且b\mid c;令b=pa,c=qb，\therefore c=pqa$，根据整除定义即$a\mid c$
  • 2. $a\mid b,且a\mid c,则\forall x,y,满足a\mid bx+cy$
    • 证明：$\because a\mid b且a\mid c,令b=pa,c=qa,则bx+cy=pax+qay=(px+qy)a,\therefore a\mid bx+cy$
  • 3. 若$a\ne 0,b=aq+c$，那么$a\mid b$ 的充分必要条件是$a\mid c$
    • 充分性证明：$\because a\mid b,令b=pa,则c=(p-q)a,\therefore a\mid c$
    • 必要性证明： $\because a\mid c,令c=pa,则b=(p+q)a,\therefore a\mid b$

同余

$\forall a,b\in \mathbb{Z},且a\ne 0,\exists p,c$，使得等式$b=pa+c,0⩽c⩽a-1$成立

• 取模运算
  b对a取模的结果即b除以a的余数，符号表示为 $b\mathrm{m}\mathrm{o}\mathrm{d}a$，计算值为$b-\lfloor \frac{b}{a}\rfloor \ast a$。
• 同余
  $m⩾1,a,b\in \mathbb{Z},若m\mid (a-b)$，则称a与b关于模m同余，符号表示为$a\equiv b(modm)$。
• 性质
  • 1. 自反性： $a\equiv a(modm)$
  • 2. 对称性： $a\equiv b(modm)则b\equiv a(modm)$
  • 3. 传递性：$a\equiv b(modm)且b\equiv c(modm)则a\equiv c(modm)$
    • 证明：$\because a\equiv b(modm)且b\equiv c(modm)$则根据同余定义$m\mid (a-b),m\mid (b-c)$,再根据整除的定理2,$m\mid [(a-b)+(b-c)],即m\mid (a-c)$,再由同余定义得$a\equiv c(modm)$
  • 4. 同余式相加：$a\equiv b(modm)且c\equiv d(modm)则a\pm c\equiv b\pm d(modm)$
    • 证明：$\because a\equiv b(modm)且c\equiv d(modm)\therefore m\mid (a-b),m\mid (c-d)\therefore m\mid [(a-b)+(c-d)],m\mid [(a+c)-(b+d)]\therefore a+c\equiv b+d(modm)$同理也能证明$a-c\equiv b-d(modm)$
  • 5. 同余式相乘：$a\equiv b(modm)且c\equiv d(modm)则ac\equiv bd(modm)$
    • 证明：$\because a\equiv b(modm)且c\equiv d(modm)\therefore m\mid (a-b),m\mid (c-d)\therefore m\mid [(a-b)c+(c-d)b]\therefore m\mid (ac-bd)\therefore ac\equiv bd(modm)$
  • 6. 除法： $ac\equiv bc(modm)则a\equiv b(mod\frac{m}{gcd(c,m)})$，$gcd(c,m)$就是c和m的最大公约数
    • 证明： 令$d=gcd(c,m)$，则令$c=pd,m=qd$,满足$gcd(p,q)=1$$\because ac\equiv bc(modm)\Rightarrow qd\mid (a-b)pd\Rightarrow q\mid (a-b)p\because gcd(p,q)=1\therefore q\mid (a-b)\therefore a\equiv b(modq)$，q即$\frac{m}{gcd(c,m)}$
  • 7. 幂运算： $a\equiv b(modm)则a^n\equiv b^n(modm)$

最大公约数

最大公约数（Greatest Common Divisor，简称GCD）

• 定义： a,b的公共的约数中最大的约数，记作$gcd(a,b)$， $gcd(a,b)=max\{d,d\mid a且d\mid b\}$

• 性质：

  • 1. $gcd(a,b)=gcd(b,a)$
  • 2. $gcd(a,b)=gcd(a,a\pm b)$
    • 证明：请点击链接
  • 3. $gcd(a,b)=gcd(a\pm mb)$
  • 4. $gcd(a,b)=gcd(b,a\%b)$
    • 证明： $gcd(b,a\%b)=gcd(b,a-\lfloor \frac{a}{b}\rfloor \ast b)$，根据性质1、3可得gcd(a,b)=gcd(b,a%b)
  • 5.$gcd(ma,mb)=m\ast gcd(a,b)$
    • 证明： 令$d=gcd(a,b),则d|a,d|b,满足a=pd,b=qd且gcd(p,q)=1\therefore gcd(ma,mb)=gcd(mdp,mdq)=md$

• 求解方法
  辗转相除法（欧几里德法）

  • 原理：
    $gcd(a,b)=gcd(b,a\%b)$
    当b=0时，gcd(a,b)=a，否则根据公式继续迭代。
  • 代码实现：

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

• 扩展欧几里德:ax+by=gcd(a,b)

  • 原理：
    $令d=gcd(a,b)$
    $\because ax+by=gcd(a,b)$
    $\therefore b{x}^{{}^{\prime }}+(a\%b)y^{{}^{\prime }}=gcd(b,a\%b)$
    $\therefore b{x}^{{}^{\prime }}+(a\%b)y^{{}^{\prime }}=ax+by$
    $\therefore a{y}^{{}^{\prime }}+b(x^{{}^{\prime }}-\lfloor \frac{a}{b}\rfloor \ast y^{{}^{\prime }})=ax+by$要使任意a,b都满足此等式，
    则$x=y^{{}^{\prime }},y=x^{{}^{\prime }}-\lfloor \frac{a}{b}\rfloor \ast y^{{}^{\prime }}$
    当b=0时，ax=a,则x=1,y=0；
    否则，令用$gcd(a,b)=gcd(b,a\%b)$递归求解，回溯时利用两式之间的关系，更新x,y，可求得方程的一组整数解。
  • 代码实现：

    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 z = x; x = y; y = z - (a / b) * y;
    	return d;
    }
    

  • 方程$ax+bx=c$：
    利用扩展欧几里德算法可求得$ax+by=gcd(a,b)$的一组解$x_0,y_0$；令d=gcd(a,b)
    + 当$d\mid c$时，方程有解，其一组解为:
    $x=x_0\ast \frac{c}{d},y=y_0\ast \frac{c}{d}$
    通解为：
    $x=x_0\ast \frac{c}{d}+k\ast \frac{b}{d}$
    $y=y_0\ast \frac{c}{d}+k\ast \frac{a}{d},(k\in \mathbb{Z})$。

扩展欧几里德例题

• POJ1061
• 题意： 两只青蛙在同一条维度线上朝西跳动， 青蛙A起始点坐标x，每次跳动m米，青蛙B起始点坐标y，每次跳动n米，问他们跳动多少次能沟相遇，不能输出Impossible
• 题解： 设两只青蛙跳动次数为t,则此时青蛙A的坐标为(x+mt)%l,青蛙B的坐标为(y+nt)%l,当两只青蛙相遇时，满足
  $(x+mt)\equiv (y+nt)(\mathrm{m}\mathrm{o}\mathrm{d}l)$
  $l\mid ((x+mt)-(y+nt))$
  $\exists k\in \mathbb{Z}$使得等式$((x+mt)-(y+nt))=kl$成立
  $(m-n)t+lk=x-y$
  当$gcd(m-n,l)\mid (x-y)$时，方程有解，即答案就是t的最小正整数解，否则方程无解，则两青蛙永远不能相遇。
• 代码实现：

  #include 
  #include 
  #include 
  #include 
  using namespace std;
  #define mes(a, val) memset(a, val, sizeof a)
  #define mec(b, a) memcpy(b, a, sizeof a)
  #define ll long long
  
  ll exgcd(ll a, ll b, ll &x, ll &y){
         
  	if(!b) {
         x = 1; y = 0; return a;}
  	ll d = exgcd(b, a % b, x, y);
  	ll z = x; x = y; y = z - (a / b) * y;
  	return d;
  }
  int main()
  {
         
      ll n, m, x, y, l;
      scanf("%lld %lld %lld %lld %lld", &x, &y, &m, &n, &l);
      ll a = n - m;
      ll b = l;
      ll c = x - y;
      ll d = exgcd(a, b, x, y);
      if(d < 0) d = -d;
      if(c % d){
         
          printf("Impossible\n");
      }
      else {
         
          ll p = b / d;
          x = x * c / d;
          x = ((x % p) + p) % p;
          printf("%lld\n", x);
      }
      return 0;
  }
  
  

最小公倍数

最小公倍数（Least Common Multiple 简称LCM ）

• 定义： a, b的所有公共的倍数中最小的公倍数，记作lcm(a,b)， $lcm(a,b)=min\{d,a\mid d且b\mid d\}$。
• 计算方法： 公式$lcm(a,b)=\frac{a\ast b}{gcd(a,b)}$

素数及其判定

• 素数（也称质数）： 一个正整数n是素数当且仅当只能被1和其自身整除，否则就称n是合数 。
  注: 1既不是素数也不是合数，最小的素数是2
• 素数判定
  • 1. 暴力枚举：
    • 原理： 循环遍历i从2到$\sqrt{n}$，只要存在 $n\%i=0$即可判定n不是素数，这样每次判定时间复杂度都是$O(\sqrt{n})$
    • 代码实现

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

  • 2. 埃拉托斯特尼筛法，简称埃氏筛：
    是一种用来求自然数n以内的全部素数的方法 。
    • 原理： 一个合数必然可以表示一个质数和另一个数相乘。对于一个素数p,那么p的倍数2p,3p,…kp,…必然都是合数。时间复杂度为$O(nlog(n))$
    • 实现代码：

      /*
      	定义数组：isprime[i]，表示数组i是否时素数
      	
      */
      const int maxn = 1e5 + 100;
      int m;
      bool isprime[maxn];
      int p[maxn];
      void sieze(int n)
      {
                 
          m = 0; memset(isprime, true, sizeof(isprime));
          for(int i = 2; i <= n; i ++){
                 
              if(isprime[i]){
                 ///表明 i 就是素数
              	p[++ m] = i;
                  for(int j = 2 * i; j <= n; j += i){
                 
                      isprime[j] = false;
                  }
              }
          }
      }
      

    • 不足： 仔细分析可以看出，这种方法筛出n以内的所有素数还是有不足之处的。原因在于每个合数会被其每一个质因子筛到一次。因此就有了接下来的线性筛。
  • 3. 线性筛
    它能在$O(n)$的时间复杂度内筛选出n以内的所有素数。
    • 原理：
      线性筛能保证n以内的任何一个数只能被他的最小质因子筛一次。
      一个数n可以表示成$n=Factor{y}_{max}\ast p$
      $Factor{y}_{max}$是除n以外的最大因子，p是n的质因子，满足p小于等于 $Factor{y}_{max}$ 的所有质因子。
      用数组v[i]表示i是否是素数，v[i]为false时表示i是素数，
      然后便利之前筛出的所有素数，v[i*p[j]]则不是素数，标记为true。 i % p[j] 为0时，跳出第二层循环，以此保证每个数只被他的最小质因子筛一次。
      当i %p[j]为0时，p[j]已经是i的最小值质因子，且p[j]时i*p[j]的最小值质因子，p[j+1]大于i的最小质因子，也就不是i*p[j]的最小质因子。
    • 代码实现：

    const int maxn = 1e5 + 100;
    int m;
    bool v[maxn];
    int p[maxn];
    void sieze(int n)
    {
             
        m = 0; memset(v, false, sizeof v);
        for(int i = 2; i <= n; i ++){
             
            if(!v[i]) {
             
                p[++ m] = i;
            }
            for(int j = 1; j <= m && i * p[j] <= n; j ++){
             
                v[i * p[j]] = true;
                if(i % p[j] == 0) break;//这条语句很关键
            }
        }
    }
    

整除分块

计算表达式：${\sum }_{i=1}^n\lfloor \frac{n}{i}\rfloor$

• 1.暴力O(n)求解不多赘述。
• 2.$O\sqrt{n}$优美解法
  • 证明请看，这位大佬的证明非常清晰，很容易理解。
  • 代码实现

  int solve(int n)
  {
         
      int ans = 0;
      for(int l = 1, r; l <= n; l = r + 1){
         
          r = n / (n / l);
          ans += (r - l + 1) * (n / l);
      }
      return ans;
  }
  

• 例题Gym100923I
  • **题意：**有n个男的，n个女的，第i个人都有为当前一个大小为i的懒惰值，当一男一女懒惰值的乘积<=n他们就就可以一起跳舞，请问有多少种组合可能；
  • 题解： 从1~n枚举男生的懒惰值i，满足条件的女女生个数就是$\lfloor \frac{n}{i}\rfloor$，$ans={\sum }_{i=1}^n\lfloor \frac{n}{i}\rfloor$，经典的整除分块例题。
  • 代码实现：

  #include 
  using namespace std;
  #define mes(a, val) memset(a, val, sizeof a)
  #define mec(b, a) memcpy(b, a, sizeof a)
  #define ll long long
  
  ll solve(ll n)
  {
         
      ll ans = 0;
      for(ll l = 1, r; l <= n; l = r + 1){
         
          r = n / (n / l);
          ans += (r - l + 1) * (n / l);
      }
      return ans;
  }
  int main()
  {
          
      freopen("perechi3.in", "r", stdin);
      freopen("perechi3.out", "w", stdout);
      int T; scanf("%d", &T);
      while(T --){
         
          ll n; scanf("%lld", &n);
          ll ans = solve(n);
          printf("%lld\n", ans);
      }
      return 0;
  }
  

快速幂

51Nod快速幂

• 问题描述： 计算$a^n$为例
• 问题分析： 显然$O(n)$暴力是不能解决问题的，下面我们介绍一种算法 （快速幂） ，它能在$O(logn)$时间复杂度内解决此问题。
• 快速幂原理：
  将正整数n二进制拆分成$n=b_{n-1}{b}_{n-2}...b_0，b_i\in \{0,1\}$
  即$n=2^{n-1}{b}_{n-1}+2^{n-2}{b}_{n-2}+...+2^0{b}_0$
  $\therefore a^n=a^{2^{n-1}{b}_{n-1}+2^{n-2}{b}_{n-2}+...+2^0{b}_0}$
  $=a^{2^{n-1}{b}_{n-1}}\ast a^{2^{n-2}{b}_{n-2}}\ast ...\ast a^{2^0{b}_0}$
  因此我们可以设置一个res（初始为1）和一个base（初始值为a），也即a^{0},在对n进行二进制拆分过程中，当第i位（从右往左第i位）为1时，则将res乘上base,并且base每次都乘上自己。其实在整个过程中，$bas{e}_i=a^{2^i}$。时间复杂度$O(log(n))$

  int ksm(int a, int n, int mod)
  {
         
  	int res = 1;
  	while(n){
         
  		if(n & 1) res = res * a % mod; //二进制拆分n第i位(从右往左)为1
  		a = a * a % mod;
  		n >>= 1;
  	}
  	 return res;
  }
  

逆元

例题hdu1576

• 定义： 整数a,b，若$a\ast b\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}p)$，那么则称a和b互为模p意义下的逆元。
  • 注：逆元需要在取模下才有意义，a对模p意义下的逆元即a在模p意义下的倒数
• 逆元的意义： 如何求解 $\frac{a}{b}\%p$（p是质数）？
  整数的除法运算是向下取整，若b不能整除a，进行除法运算后在对p取模，多得到的并是正确结果，这一点应该很好理解。
  逆元的作用就在如此，他能将除以一个数等价于乘上这个的逆元。
  $\frac{a}{b}\equiv a\ast \frac{1}{b}(\mathrm{m}\mathrm{o}\mathrm{d}p)$
  设b在模p意义下的逆元为invb,则
  $invb\ast b\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}p)\iff invb\equiv \frac{1}{b}(\mathrm{m}\mathrm{o}\mathrm{d}p)$
  $\therefore \frac{a}{b}\equiv a\ast invb(\mathrm{m}\mathrm{o}\mathrm{d}p)$
• 逆元求解方法
  • 1.费马小定理
    • 满足条件： 模数p必须是素数。
    • 原理： $a^{p-1}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}p)$,p是素数 （再此不做证明）
      因此$a\ast a^{p-2}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}p)$
      即$a^{p-2}$就是a在模p意义下的逆元，$inva=a^{p-2}$,利用快速幂可以求解
  • 2.扩展欧几里德
    • 满足条件： $gcd(a,p)=1$即a与p互质。
    • 原理： $inva\ast a\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}p)$
      $\therefore p\mid (inva\ast a-1)$
      $\therefore \exists k\in \mathbb{Z},inva\ast a-1=pk$
      $\therefore inva\ast a+k\ast p=1,\because gcd(a,p)=1$
      因此次方程一定有解，利用扩展欧几里德算法可求得inva
  • 递推公式
    • 满足条件： 模数p必定是素数 。
    • 原理：
      $p=p\%a+\lfloor \frac{p}{a}\rfloor \ast a$
      令 $x=p\%a,y=\lfloor \frac{p}{a}\rfloor$
      $p\%p=(x+y\ast a)\%p$
      $a^{-1}\%p=(p-x)\ast y^{-1}\%p$
      因此得 $a^{-1}=(p-\lfloor \frac{p}{a}\rfloor )\ast (p\%a{)}^{-1}\%p$
      由此递推式可O(n)求解1~n所有数模p的逆元。
    • 代码实现：

    int inv[mod+5];
    void getInv(int  p)
    {
             
    	inv[1] = 1;
    	for(int i = 2; i < p; i ++){
             
    		inv[i] = (p - p / i) * inv[p % i] % p;
    	}
    }
    

O(n)计算阶乘的逆元

• 原理：
  令$f(n)=n!$
  $f(n)=f(n-1)\ast n$
  $f(n-1{)}^{-1}=f(n{)}^{-1}\ast n$
  先$O(n)$预处理出1_{n的阶乘，计算出$f(n)^{-1}$则可通过递推公式往下求解1}n-1以内所有阶乘的逆元。
• 代码实现：

  const int maxn = 1e5 + 10;
  int f[maxn], invf[maxn];
  int p;
  int ksm(int a, int n, int p)
  {
         
      int res = 1;
      while(n){
         
          if(n & 1) res = 1ll * res * a % p;
          a = 1ll * a * a % p;
          n >>= 1;
      }
      return res;
  }
  void init(int n)
  {
         
      f[0] = 1; f[1] = 1;
      for(int i = 2; i <= n; i ++){
         
          f[i] = 1ll * f[i-1] * i % p;
      }
      invf[n] = ksm(f[n], p - 2, p);
      for(int i = n - 1; i >= 0; i --){
         
          invf[i] = 1ll * invf[i+1] * (i + 1) % p;
      }
  }
  

• 例题
  51Nod1118
  • 题意：
    M * N的方格，一个机器人从左上走到右下，只能向右或向下走。有多少种不同的走法？由于方法数量可能很大，只需要输出Mod 10^9 + 7的结果。
  • 题解： 答案就是$C_{n+m}^n$
  • 代码实现：

  import java.math.*;
  import java.util.*;
  
  public class Main {
         
  	
  	public static long mod = 1000000007;
  	public static long f[] = new long[2100];
  	public static long invf[] = new long[2100];
  	
  	public static long ksm(long a, long n, long p) {
         
  		long res = 1;
  		while(n > 0) {
         
  			if(n % 2 == 1) res = res * a % p;
  			a = a * a % p;
  			n >>= 1;
  		}
  		return res;
  	}
  	//计算阶乘的逆元
  	public static void init(int n) {
         
  		f[0] = 1;
  		for(int i = 1; i <= n; i ++) {
         
  			f[i] = f[i-1] * i % mod;
  		}
  		invf[n] = ksm(f[n], mod-2, mod);
  		for(int i = n - 1; i >= 0; i --) {
         
  			invf[i] = invf[i+1] * (i + 1) % mod;
  		}
  	}
  	public static long get(int n, int m) {
         
  		n --; m --;
  		long res = f[n+m]*invf[n]%mod*invf[m]%mod;
  		res = res % mod;
  		return res;
  	}
  	public static void main(String[] args) {
         
  		Scanner cin = new Scanner(System.in);
  		init(2005);
  		int n = cin.nextInt(); int m = cin.nextInt();
  		System.out.println(get(n, m));
  	}
  }