算法设计与分析学习（6）——数论

数论

整除

• 基本概念

  • 若 $a$ 和 $b$ 为整数，且 $a\ne 0$
    • 若存在整数 $q$ 使得 $b=aq$ ，那么就说 $a$ 可以整除 $b$ 或是 $b$ 被 $a$ 整除，记作 $a|b$ 。$a$ 也被称为 $b$ 的约数， $b$ 也被称为a的倍数。
    • 若 $b$ 不能被 $a$ 整除，则记作 $a\nmid b$。
  • 整数 $p\ne 0,\pm 1$，且除了 $\pm 1,\pm p$ 外没有其他的约数存在，那么p被称之为质数或素数。
    • 没有特殊说明的话，质数(素数)指的是正整数中的质数。
  • 整数 $q\ne 0,\pm 1$，且不是质数，那么 $q$ 被称之为合数。
    • 没有特殊说明的话，合数指的是正整数中的合数。
  • 设 $a,b$ 是两个整数，若存在整数 $d$，$d|a$ 且 $d|b$ ，则 $d$ 被称为 $a$ 和 $b$ 的公约数。
    • 若 $a,b$ 两数不全为 $0$，则把 $a$ 和 $b$ 的所有公约数中最大的那个称之为最大公约数，记作$(a,b)$ 或 $gcd(a,b)$ 。
    • 同理可以定义公倍数和最小公倍数的概念。 $a$ 和 $b$ 的最小公倍数记作 $[a,b]$ 或 $lcm(a,b)$ 。
    • 如果两个数的最大公约数为 $1$，则我们称两数互质或互素。
  • 设 $a,b$ 为整数，且 $a\ne 0$ 。那么一定存在唯一的一对整数 $q$ 和 $r$，满足$b=qa+r$，其中$0\le r<|a|$。 $r$ 被称作是 $b$ 除以 $a$ 的余数，这样的除法运算又被称之为带余除法

• 性质

  • 若 $a|b$ 且 $b|c$ ，则有 $a|c$。
  • 素数有无穷多个。如果用 $\pi (x)$ 表示不超过 $x$ 的素数的个数，可以用 $ x/lnx$ 对 $\pi (x)$ 进行估计。
  • 若 $n$ 为合数，则必有素数 $p|n$ ，且 $p\le \sqrt{\pi }$。
  • $(a,b)=(b,a)$ 且 $(a,b,c)=((a,b),c)=(a,(b,c))$。
  • $[a,b]=[b,a]$ 且 $[a,b,c]=[[a,b],c]=[a,[b,c]]$。
  • $(a,b)\times [a,b]=ab$。
  • 可以证明，对于任意的整数 $a$ 和 $b$，总归存在相应的整数 $x$ 和 $y$ ，满足 $(a,b)=ax+by$，即 $a$ 和 $b$ 的最大公约数可以写成 $a$ 和 $b$ 的线性表示。
  • $(a,b)=(r,a)$ 其中 $a\ne 0$，$r$ 为 $b$ 除以 $a$ 的余数。
  • 设$n>1$，那么 $n$ 必存在唯一的质因数分解，即$n=p_1^{{\alpha }_1}{p}_2^{{\alpha }_2}\dots p_s^{{\alpha }_s}$。其中 $p_i$ 为质数$(1\le i\le s)$，${\alpha }_i$ 为正整数，且 $p_i<p_{i+1}(1\le i<s)$。
    • 正整数 $n$ 的正约数的个数（记作 $a(n)$ ）也可以通过 $n$​ 的质因数分解式计算出来。

• 代码实现

  • 欧几里得除法

    class Int
    {
        int value;
        Int(int v)
        {
            value=v;
        }
    }
    
    public class Euclid 
    {
        static int gcd(int a,int b)
        {
            return b==0 ? a : gcd(b,a%b);
        }
    	
        //利用对象传递参数
        static int extend_gcd(int a,int b,Int x,Int y)
        {
            if(b==0)
            {    
                x.setValue(1);
                y.setValue(0);
                return a;
            }
            else
            {
                int r=extend_gcd(b,a%b,y,x);
                y.value-=a/b*x.value;
                return r;
            }    
        }
    }
    

  • 素数筛

    public class Prime 
    {
        ArrayList<Integer> ans;
        int tot;
        Prime()
        {
            ans=new ArrayList<>();
            tot=0;
        }
    	//复杂度O(NlogN)
        void getPrimeMethodOne(int n)
        {
            boolean[] valid= new boolean[n];
            for(int i=2;i<n;i++)
                valid[i]=true;
            for(int i=2;i<n;i++)
            {
                if(n<i*i)
                    break;
                for(int j=i*i;j<n;j+=i)
                    valid[j]=false;
            }
            for(int i=2;i<n;i++)
                if(valid[i])
                {
                    ans.add(i);
                    tot++;
                }    
        }
    
        //复杂度O(N)
        void getPrimeMethodTwo(int n)
        {
            boolean[] valid= new boolean[n];
            for(int i=0;i<n;i++)
                valid[i]=true;
            for(int i=2;i<n;i++)
            {
                if(valid[i])
                {
                    tot++;
                    ans.add(i);
                }
                for(int j=0;((j<=tot)&&(i*ans.get(j)<n));j++)
                {
                    valid[i*ans.get(j)]=false;
                    if(i%ans.get(j)==0)
                        break;
                }
            }
        }
    }
    

  • 质因数分解

    static void factor(int n,ArrayList<Integer>ans, ArrayList<Integer>exp)
    {
    	int tmp=(int)((double)Math.sqrt(n)+1);
        int tot=0;
        int now=n;
        for(int i=2;i<=tmp;i++)
    	{
            if(now%i==0)
            {
                ans.add(i);
                exp.add(0);
                while(now%i==0)
                {
                    int oldValue=exp.get(tot);
                    exp.set(tot,oldValue+1);
                    now/=i;
                }
                tot++;
            }
        }
        if(now!=1)
    	{
            ans.add(now);
            exp.add(1);
            tot++;
        }
    }
    

不定方程

• 基本概念
  • 不定方程定义：
    • 变量个数多于方程个数，并且只考虑整数解的方程被称之为不定方程。
    • 典型的二元一次不定方程形式为 $ax+by=c$，其中$a、b、c$皆为已知整数，$a、b$都不为 0，$x、y$​为未知数。
• 性质
  • 二元一次不定方程$ax+by=c$ 有解的充要条件是$(a,b)|c$。
    • 当 $(a,b)|c$ 的时候该方程等价于 $\frac{a}{(a,b)}x+\frac{b}{(a,b)}y=\frac{c}{(a,b)}$​
    • 由最大公约数的性质知道存在$x_0^{\prime },y_0^{\prime }$，使得$a{x}_0^{\prime }+b{y}_0^{\prime }=(a,b)$。此时$x^0=x_0^{\prime }\times \frac{c}{(a,b)}$，$y^0=y_0^{\prime }\times \frac{c}{(a,b)}$​为原不定方程的一组解。
  • 假设二元一次不定方程$ax+by=c$ 有解，并且 $x_0、y_0$ 为方程的一组解，则它的所有解可以表示为 $x=x_0-\frac{b}{(a,b)}t$，$y=y_0+\frac{a}{(a,b)}t$，其中 $t$​ 为任意整数。
  • 要求二元一次不定方程$ax+by=c$ 的解为非负整数，假设 $(a,b)=1$
    • 若 $c>ab-a-b$时，则方程一定有非负解，解的个数等于$\Big [ \frac{c}{ab} \Big ] $或 $\left[\frac{c}{ab}\right]-1$
    • 当 $c=ab-a-b$时，方程一定没有非负解。
      • 其中式子中的 $\left[\frac{c}{ab}\right]$表示的是不超过实数 $\frac{c}{ab}$的最大整数。

同余方程和欧拉定理

• 基本概念

  • 假设 $m\ne 0$ 。若 $m|a-b$ 则称 $a$ 同余于 $b$ 模 $m$ ，记作$a\equiv b(\mathrm{mod}m)$。

  • 若 $m\ge 1,(a,m)=1$，则存在 $c$ 使得 $ca\equiv 1(\mathrm{mod}m)$。

    • $c$ 被称为 $a$ 对模 $m$ 的逆，记作 $a^{-1}$。

  • 设整系数多项式 $f(x)=a_n{x}^n+\dots +a_{1}x+a_0$。

    • 方程 $f(x)\equiv 0(\mathrm{mod}m)$ 被称之为模 $m$ 的同余方程。
    • 假设 $x=x_0$ 是方程的一个解，则由同余的性质知 $x_0+km$ 皆为方程的解。
      • 当说模m的同余方程的两个不同的解的时候，往往指的是在模意义下的不同，即两者模m不同余。

  • 设 $n$ 是正整数，$\phi (n)$ 是1,2,…,n中和n互质的数的个数，可以证明
    $$\varphi (n)=n\prod _{p|n}(1-\frac{1}{p})$$

    • $\phi (n)$又被称为欧拉函数。

• 性质

  • 可以用扩展 Euclid 算法求解 $a$ 对模 $m$ 的逆。

    • 因为 $(a,m)=1$，所以可以通过扩展 Euclid 算法求得 $x,y$ 使得$ax+my=1$。
    • 易证$ax\equiv 1(\mathrm{mod}m)$。

  • 若$a\equiv a^{\prime }(\mathrm{mod}m)$，$b\equiv b^{\prime }(\mathrm{mod}m)$，则有$a+b\equiv a^{\prime }+b^{\prime }(\mathrm{mod}m)$，$ab\equiv a^{\prime }{b}^{\prime }(\mathrm{mod}m)$。

    • 若 $d$ 为非负整数，$a^d\equiv a^{\prime d}(\mathrm{mod}m)$。
    • 若 $a$ 对模 $m$ 的逆存在，则 $a^{\prime }$ 对模 $m$ 的逆也存在，并且 $a^{-1}\equiv a^{\prime -1}(\mathrm{mod}m)$

  • 欧拉定理(Euler定理)。

    • 设$(a,m)=1$，则$a^{\varphi (m)}\equiv 1(\mathrm{mod}m)$。

  • 费马小定理(Fermat 小定理)。

    • 对任意 $a$ 和任意质数 $p$ 有，$a^p\equiv a(\mathrm{mod}p)$。
    • 当 $p\nmid a$ 时，进一步有$a^{p-1}\equiv a(\mathrm{mod}p)$

  • 模 $m$ 的一次同余方程F 可以通过扩展 Euclid 算法进行求解。

    • 方程有解的充要条件为 $(a,m)|b$ 。在有解的时候，它的模 $m$ 意义下不同的解的个数为$(a,m)$ 。

    • 假设 $x=x_0$ 是 $ax\equiv b(\mathrm{mod}m)$方程的一个解，那么所有模m意义下不同的解可以表示成
      $$x\equiv x_0+\frac{m}{(a,m)}t(\mathrm{mod}m)$$
      其中 $t=0,1,2,\dots ,(a,m)-1$。

    • 特解 $x_0$ 的求法是先通过扩展 Euclid 算法求得 $x_0^{\prime }$ 使得$a{x}_0^{\prime }\equiv (a,m)(\mathrm{mod}m)$，然后只需要让 $x_0=x_0^{\prime }\times \frac{b}{(a,m)}$

  • 孙子定理或中国剩余定理

    • 设 $m_1,\dots ,m_k$ 是两两互质的正整数。

      • 对于任意整数 $a_1,\dots ,a_k$ 来说，一次同余方程组
        $$\{\begin{array}{c}x\equiv a_1(\mathrm{mod}{m}_1)\\ \cdots \\ x\equiv a_k(\mathrm{mod}{m}_k)\end{array}$$
        $1\le i\le k$必有解。

    • 解答

      • 定义
        $$m=\prod _1^k{m}_i{M}_i=\frac{m}{m_i}$$

      • 由于 $m_i$ 和 $M_i$ 互质，所以存在 $M_i$ 对于模 $m_i$ 的逆 $M_i^{-1}$ 。

      • 方程组在模m意义下的唯一解可以表示为
        $$x=\sum _1^k{M}_i\cdot M_i^{-1}\cdot a_i(\mathrm{mod}m)$$

  • 对于更加一般的一次同余方程组，可以转化为孙子定理的标准形式求解

• 代码实现

  • 单变元模线性方程

    ArrayList<Integer> line_mod_equation(int a,int b,int n)
    {
        ArrayList<Integer> result = new ArrayList<>();
        Int x=new Int();
        Int y=new Int();
        int d=Euclid.extend_gcd(a,n,x,y);
        
        if(b%d==0)
        {
            x.value%=n;
            x.value+=n;
            x.value%=n;
            result.add(x.value*(b/d)%(n/d));
            for(int i=1;i<d;i++)
                result.add((result.get(0)+i*n/d)&n);
        }
        return result;
    }
    

  • 中国剩余定理

    int solveCRT(int[] a,int[] m,int n)
    {
        int M=1;
        for(int i=0;i<n;i++)
            M*=m[i];
    	int result=0;
    	for(int i=0;i<n;i++)
        {
            Int x=new Int();
            Int y=new Int();
            int tmp=M/m[i];
            int d=Euclid.extend_gcd(tmp,m[i],x,y);
            result=(result+tmp*x.value*a[i])%M;
        }
        return (result+M)%M;
    }
    

  • 求欧拉函数

    public class Euler 
    {
        int limit;
        int[] minDiv,phi,sum;
        
        Euler(int limit)
        {
            this.limit=limit;
            minDiv=new int[limit];
            phi=new int[limit];
            sum=new int[limit];
        }
        void getPhi()
        {
            //素数筛
            for(int i=1;i<limit;i++)
                minDiv[i]=i;
            for(int i=2;i*i<limit;i++)
            {
                if(minDiv[i]==i)
                {
                    for(int j=i*i;j<limit;j+=i)
                        minDiv[j]=i;
                }
            }
            //计算欧拉函数值
            phi[1]=1;
            for(int i=2;i<limit;i++)
            {
                phi[i]=phi[i/minDiv[i]];
                if((i/minDiv[i])%minDiv[i]==0)
                    phi[i]*=minDiv[i];
                else
                    phi[i]=minDiv[i]-1;
            }
        }
    }
    

原根、离散对数和二项同余方程

• 基本概念

  • 原根

    • 设 $m$ 为正整数， $(a,m)=1$，若 $d$ 是最小的使得 $a^d\equiv 1(\mathrm{mod}m)$ 成立的正整数, 则 $d$ 被称为 $ a $ 对模 $ m $ 的指数, 记作 ${\delta }_m(a)$ 。

    • 若 ${\delta }_m(a)=\phi (m)$，则称 $a$ 是模 $m$ 的原根。其中 $\phi$​ 为欧拉函数。
      $$a^{\varphi (m)}\equiv 1(\mathrm{mod}m)$$

  • 设模 $m$ 有原根 $g$ 。

    • 对任意满足 $(a,m)=1$ 的 $a$，必存在唯一 $\gamma$，使得 $g^{\gamma }\equiv a(\mathrm{mod}m)$ 且 $0⩽\gamma <\phi (m)$。
    • 称 $\gamma$ 为 $a$ 对模 $m$ 的以 $g$ 为底的指标, 记作 ${\gamma }_{\mathrm{m},\mathrm{g}}(a)$，在不产生混淆的情况下, 可简写作 ${\gamma }_m(a)$ 或 $\gamma (a)$ 。

  • 设 $n⩾2$ 。同余方程 $x^n\equiv a(\mathrm{mod}m)$ 被称为是模 $m$ 的二项同余方程。

• 性质

  • 若 $(a,m)=1$ 且 $a^d\equiv 1(\mathrm{mod}m)$，则必有 $\delta_{m}(a) \mid d $ 。
  • 由 Euler 定理和性质 1 知， ${\delta }_m(a)\mid \phi (m)$ 。
  • $a^0,a^1,\cdots ,a^{{\delta }_m(a)-1}$ 这 ${\delta }_m(a)$ 个数模 $m$ 互不同余。
  • 模 $ m $ 有原根的充要条件是 $m=1,2,4,p^{\alpha },2p^{\alpha }$，其中 $p$ 是奇素数，$\alpha$ 是正整数。
  • ${\gamma }_m(ab)\equiv {\gamma }_m(a)+{\gamma }_m(b)(\mathrm{mod}\phi (m))$
  • ${\gamma }_m\left(a^k\right)\equiv k\times {\gamma }_m(a)(\mathrm{mod}\phi (m))$

• 常用算法

  • 模 $m$ 的原根的计算
    • 通过随机一个数 $g$​ 然后验证其是否为原根；
    • 计算最小正原根
  • 离散对数问题
    • 问题描述：已知模 $m$ 和它的原根 $g$，若 $ (a, m)=1 $，求 $ \gamma_{\mathrm{m}, \mathrm{g}}(a)$​ 。
    • 用空间换时间的算法：
      • 简写 ${\gamma }_{\mathrm{m},\mathrm{g}}(a)$ 为 $\gamma$ 。那么 $g^{\gamma }\equiv a(\mathrm{mod}m)$ 。令 $q=[\sqrt{\phi (m)}]$，把 $ \gamma $ 写作 $iq+j$ 的形式，使得 $0⩽j<q$ 。因为 $\gamma <\phi (m)$，所以 $i=O(\sqrt{\phi (m)})$ 。
      • 由 $g^{iq+j}\equiv a(\mathrm{mod}m)$推出 $a{\left(g^{-q}\right)}^i\equiv g^j(\mathrm{mod}m)$。注意由于 $g$ 是 $m$ 的原根，所以 $g$ 对于模 $m$ 的逆必存在。
      • 预先把 $g^j$ 的 $q$ 种可能的数值都计算出来，放入哈希表中。然后从 $0$ 开始尝试 $i$ 的数值，再去哈希表中查找 $a{\left(g^{-q}\right)}^i$ 。若能找到, 则根据对应的 $i$ 和 $j$ 算出 $ \gamma $ 。
  • 求解特殊二项同余方程。
    • 问题描述:假设模是质数 $p$，且 $p\nmid a$，$n\ge 2$，求解模 $p$ 的二项同余方程 $x^n=a(\mathrm{mod}p)$
    • 解法
      • 首先计算出 $p$ 的原根 $g$ 。然后方程两边一起做指标运算变成 $n\gamma (x)=\gamma (a)(\mathrm{mod}p-1)$。
      • $\gamma (a)$ 可以通过解离散对数的算法计算出来。
      • 如此一来，方程就变成了一个简单的一次同余方程。根据解一次同余方程的算法解出 $\gamma (x)$ 的所有解，再利用 $x=g^{\gamma (x)}(\mathrm{mod}p)$ 算出 $x$​ 的所有解。

• 代码实现

  • 求原根

    public class primitiveRoot 
    {
        ArrayList<Integer> arr;
        
        primitiveRoot()
        {
            arr=new ArrayList<>();
        }
    	//计算快速幂
        int quick_pow_mod(int a,int x,int mod)
        {
            if(x==0)
                return 1%mod;
            int tmp=quick_pow_mod(a,x>>1,mod);
            tmp=tmp*tmp%mod;
            if(x%2==1)
                tmp=tmp*a%mod;
            return tmp;
        }
    	//测试
        boolean g_test(int g,int p)
        {
            for(int i=0;i<arr.size();i++)
            {
                int q = arr.get(i);
                if(quick_pow_mod(g,(p-1)/q,p)==1)
                    return false;
            }
            return true;
        }
    	//计算
        int getPrimitiveRoot(int p)
        {
            //质因数分解
            int tmp=p-1;
            for(int i=2;i*i<=tmp;i++)
            {
                if(tmp%i==0)
                {
                    arr.add(i);
                    while(tmp%i==0)
                    {
                        tmp/=i;
                    }
                }
            }
            if(tmp!=1)
                arr.add(tmp);
            int g=2;
            while(true)
            {
                if(g_test(g, p))
                    return g;
                if(g>p)
                    return -1;
                g++;
            }
        }
    }
    

  • 离散对数

    static int getDiscreteLog(int x,int n,int m)
    {
    	int[] arr = new int[(int)Math.sqrt(m) + 1];
    	int s = (int) Math.ceil(Math.sqrt(m));
        int cur=1;
        for(int i=0;i<s;i++)
        {
            arr[i] = cur;
            cur = (int) ((long)cur * x % m);
        }
        // x 的逆元 (模 m) 的s次幂
        int tmp=quickPowMod.quick_pow_mod(x, m - 2, m);
    	int curInv = quickPowMod.quick_pow_mod(tmp, s, m);
    	int y = n;
        for (int i = 0; i < s; i++) 
    	{
            for (int j = 0; j < s; j++)
            {
                if (arr[j] == y)
                {
                    return i * s + j;
                }
            }
            y = (int) ((long)y * curInv % m);
        }
        return -1;
    }
    

  • n次剩余

    static ArrayList<Integer> residue(int p,int N,int a)
    {
        //求 p 的原根 g
        primitiveRoot pRoot=new primitiveRoot();
        int g=pRoot.getPrimitiveRoot(p);
        //求离散对数m
        int m= discreteLog.getDiscreteLog(g,a,p);
        //存储结果
        ArrayList<Integer> result=new ArrayList<>();
        if(a==0)
        {
            result.add(0);
            return result;
        }
        if(m==-1)
            return result;
    
        // 构造线性同余方程 Ax = C (mod B)，其中 A = N, B = p-1, C = m
        int A=N,B=p-1,C=m;
        Int x=new Int();
        Int y=new Int();
            
        //计算 gcd结果
        int d=Euclid.extend_gcd(A,B,x,y);
        if(C%d!=0)
            return result;
        
        // 将 x 的值更新为线性同余方程 Ax = C (mod B) 的一个解
        x.value=x.value*(C/d)%B;
        int delta=B/d;
        for(int i=0;i<d;i++)
        {
            // 将解转换为对应的元素（使用原根 g 和模幂运算） 
            x.value=((x.value+delta)%B+B)%B;
            result.add(quickPowMod.quick_pow_mod(g, x.value, p));
        }
        Collections.sort(result);
        return result;
    }
    

连分数

• 基本概念

  • 分数式

    $$a_0+\frac{1}{a_1+\frac{1}{a_2+\frac{1}{a_3+\frac{1}{\dots a_n}}}}$$

    • 被称为有限连分数，其中 $a_0$ 是整数，其他所有的 $a_i$ 都是正整数。简写记作 $[a_0;a_1,a_2,\dots ,a_n]$。在$0\le k\le n$ 时， $[a_0;a_1,a_2,\dots ,a_k]$ 被称为对应有限连分数的第 $k$ 个渐进分数。

  • 分数式

    $$a_0+\frac{1}{a_1+\frac{1}{a_2+\frac{1}{a_3\dots }}}$$

    • 被称为无限连分数，其中 $a_0$ 是整数，其他所有的 $a_i$ 都是正整数。简写记作 $[a_0;a_1,a_2,\dots ]$。对于任意非负整数$k$，$[a_0;a_1,a_2,\dots ,a_k]$ 被称作对应无限连分数的第 $k$ 个渐进分数。
    • 对于无限连分数$[a_0;a_1,a_2,\dots ]$，若存在极限 ${\lim }_{k\to \infty }[a_0;a_1,a_2,\dots ,a_k]=\theta$，就说该无限连分数是收敛的，$\theta$被称为它的值。

  • 一个有理分数 $p/q$ 被称之为实数 $x$ 的最佳有理逼近，当且仅当在所有分母不超过 $q$ 的有理分数中， $|\frac{p}{q}-x|$最小

• 性质

  • 有限连分数的值是一个有理分数。

  • 任意有理分数有且仅有两种有限连分数表示式。

    • 第一种为 $[a_0;a_1,a_2,\dots ,a_n]$，其中 $a_n>1$;
    • 第二种可以表示成 $[a_0;a_1,a_2,\dots ,a_n-1,1]$​。

  • 任意有理分数 $p/q$ 其中 $(p,q)=1$，它的有限连分数表示式可以通过辗转相除法得到。

  • 比较有限连分数的大小。

    • 设 $a=[a_0;a_1,a_2,\dots ,a_n]$ 和 $b=[b_0;b_1,b_2,\dots ,b_s]$ 为两个有限连分数。

    • 大小比较

      • $a=b$ 当且仅当 $n=s$ 且 $a_i=b_i$，其中 $0\le i\le n$。
      • 若 $a\ne b$，分两种情况讨论。
        • 若存在 $k$ 使得 $k$ 是满足 $a_k\ne b_k$的最小的非负整数，则 $a<b$ 当且仅当 $(-1{)}^k(a_k-b_k)<0$。
        • 若不存在这样的 $k$，则必有其中一个连分数的序列是另一个的前缀，不妨假设 $a$ 是 $b$ 的前缀，即$n<s$ 且$a_i=b_i$，其中 $0\le i\le n$，则 $a<b$ 当且仅当 $n$​ 是偶数。

    • 用 $a^{(k)}$ 表示连分数 $a$ 的第 $ k$​ 个渐进分数
      $$\begin{gathered} a^{(1)}>a^{(3)}>a^{(5)}>\cdots >a^{(2s-1)}>\cdots \\ {a}^{(0)}<a^{(2)}<a^{(4)}<\cdots <a^{(2t)}<\cdots \\ {a}^{(2s-1)}>a^{(2t)}s\ge 1,t\ge 0 \end{gathered}$$

  • 无限连分数一定收敛，且值为无理数。

    • 任何无理数都存在唯一的一个无限连分数表示。

  • 比较无限连分数的大小

    • 设 $a=[a_0;a_1,a_2,\dots ]$ 和 $b=[b_0;b_1,b_2,\dots ]$ 为两个无限连分数。
    • 大小比较
      • $a=b$ 当且仅当 $a_i=b_i$，其中$i\ge 0$
      • 若 $a\ne b$，则存在最小的非负整数 $k$，满足 $a_k\ne b_k$，那么 $a<b$ 当且仅当 $(-1{)}^k(a_k-b_k)<0$​。

  • 实数 $x$ 的连分数表示的所有渐进分数都是 $x$​ 的最佳有理逼近。

    • 实数 $x$ 的所有最佳有理逼近，都可以表示成 $[a_0;a_1,a_2,\dots ,a_{n-1},a_n^{\prime }]$。其中 $\frac{a_n}{2}\le a_n^{\prime }\le a_n$，并且 $[a_0;a_1,a-2,\dots ,a_{n-1},a_n]$ 是 $x$ 的第 $n$个渐进分数。所以任意实数的所有最佳有理逼近与它的所有渐进分数一一对应。