「壹」 数学基础

数论 for OI

BY SCErutsiom

「壹」 数学基础

一、高精度运算

前备知识：重载运算符

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。

重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。

当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。

也就是说，当我们给高精度数定义加减乘除时，由于操作的是结构体，所以对之前默认存在的数字加减乘除不会产生影响，二者并存。

拿自定义高精加举例：

data operator + (const data &a, const data &b)

data是结构体的类型，在重载的+之前需要加上operator(记住这个单词qwq)

struct data
{
    int a[1000], len;
};//用结构体内数组储存高精度数字，len储存长度

data operator + (const data &a, const data &b)
{//重载运算符
    data c;
    c.len = max(a.len, b.len);//得数的最小位数
    for (int i = 0; i <= c.len; i++)
        c.a[i] = a.a[i] + b.a[i];//逐位相加。
        //注意，此时可能出现一位上超过十的情况
    for (int i = 0; i <= c.len; i++)
    {//进位
        c.a[i + 1] += c.a[i] / 10;
        c.a[i] %= 10;
    }
    if (c.a[c.len + 1]) c.len++;//判断是否最高位有进位
    return c;
}

data operator - (const data &a, const data &b)
{
    data c;
    c.len = a.len;//前提是a>b，得数最大的位数是被减数位数
    for (int i = 0; i <= c.len; i++)
        c.a[i] = a.a[i] - b.a[i];//逐位相减
    for (int i = 0; i <= c.len; i++)
        if (c.a[i] < 0)
        {//退位
            c.a[i + 1]--;
            c.a[i] += 10;
        }
    while (c.a[c.len] == 0) c.len--;
    return c;
}

data operator * (const data &a, const int &b)
{//高精乘int
    data c;
    c.len = a.len;//至少是高精数的位数
    for (int i = 0; i <= c.len; i++)
        c.a[i] = a.a[i] * b;
    for (int i = 0; i <= c.len + 10; i++)
    //注意：此时每一位上的数字可能大于20，甚至非常大
    {
        c.a[i + 1] += c.a[i] / 10;
        //进位
        c.a[i] %= 10;
    }
    for (int i = c.len + 10; i >= 0; i--)
        if (c.a[i])
        {
            c.len = i;
            break;
        }//寻找最高位
    return c;
}

data operator * (const data &a, const data &b)
{//高精乘高精
    data c;
    c.len = a.len + b.len;//划重点qwq
    for (int i = 0; i <= a.len; i++)
        for (int j = 0; j <= b.len; j++)
            c.a[i + j] += a.a[i] * b.a[j];
    for (int i = 0; i <= c.len + 10; i++)
    {
        c.a[i + 1] += c.a[i] / 10;
        c.a[i] %= 10;
    }
    for (int i = c.len + 10; i >= 0; i--)
        if (c.a[i])
        {
            c.len = i;
            break;
        }
    return c;
}

data operator / (const data &a, const int &b)
{
    data c;
    int d = 0;
    for (int i = a.len; i >= 0; i--)
    {//从高往低除
        d = d * 10 + a.a[i];
        c.a[i] = d / b;
        d %= b;
    }
    for (int i = a.len; i >= 0; i--)
        if (c.a[i])
        {
            c.len = i;
            break;//寻找最高位
        }
    return c;
}
//高精除高精...老师说oi不会考（可以尝试二分答案，用猜到的数去乘除数），勉强信了qwq

【例题】

给出正整数a，b，求a^b的最后500位。
a<=10^500 , b<=100

【分析】

分析a的数据范围可知此题需要用高精度。

根据常识，较大位上的数不会对较小位上的数产生影响，所以只需记录最后500位的数即可。（结合快速幂）

二、模与逆元

模

$a≡b(mod \ m)$ 表示在模m意义下，a等于b。

在模m意义下，两个小于m的数a,b四则运算如下：

加法：$(a+b) \% m$

减法：$(a-b+ m ) \%m$

乘法：$a * b \% m$

除法——

逆元

引入：

欧拉定理：

$Φ(n)$表示1-n中与n互质的数的==个数==

性质：

①对于质数p，Φ(p)=p-1

② $Φ(n)=Σ^n_{i=1}[(i,n)==1]=n∏(1-\frac{1}{p_i})$
(其中pi是n的质因子)

③ $Σ_{d|n}Φ(d)=n$

也就是说，一个数所有因数的Φ值的和等于这个数本身。

正题：如果(a,n)=1，即a与n互质，那么$a^{Φ(n)}=1(mod \ n)$

所以:$a^{Φ(n)-1}*a^1=1(mod \ n)$

由性质①可知，当n是质数p时，对于任意不是p的倍数的a，都有:$\frac{1}{a}=a^{p-2}$

我们称1/a为a在模n意义下的逆元，经常记作inv(a)。

阶乘逆元

已知n的逆元，怎么求n-1的逆元呢？

很简单，因为1/(n-1)与1/n只差分母上的一个n，所以只要将n的逆元*n，即可得到n-1的逆元

一个小小的应用——排列组合

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

用逆元可以优化计算过程

伪代码如下：

#include<cstdio>
#include<iostream>
#define ll  long long;
ll fac[MAXN],inv[MAXN];
int n,mod;
ll pow(ll x,ll n,ll m)
{
    ll res=1;
    while( n > 0 )
    {
       if( n % 2== 1 )  
       {
         res = res * x;
         res = res % m;
       }
       x = x * x;
       x = x % m;
       n >>= 1;
    }
    return res; 
}
void pree(){//预处理
  fac[0] = inv[0] = 1;
  for( int i = 1 ; i <= n ; i++ ){
      fac[i] = fac[i - 1] * i % mod;
      inv[n] = pow( fac[n] , mod-2 , mod );//快速幂
      for( int i = n; i >= 2 ; i-- )
      inv[i - 1] = inv[i] * i % mod; 
  }
}
int C(int n,int m){//求组合数
    if( n<0 || m<0 || n-m <0 )
    return 0;
    return fac[n]*inv[m] % mod *inv[n-m] % mod;
} 
int main()
{
    //do something
}

三、快速幂

丑陋的代码

//求b^p mod k的值
#include<bits/stdc++.h>
using namespace std;
long long b,a,p,base,k,ans=1;//记得开ll
int main()
{
    scanf("%d%d%d",&b,&p,&k);
    if(b==k){
        cout<<b<<"^"<<p<<" "<<"mod"<<" "<<k<<"="<<0<<endl;
    }
    else{
    base=b;a=p;
    while(a>0)
    {
        if(a%2!=0)ans=ans*base%k;
        base=base*base%k;
        a=a>>1; 
    }
    cout<<b<<"^"<<p<<" "<<"mod"<<" "<<k<<"="<<ans<<endl;}
    return 0;
}

四、gcd&lcm相关

gcd(a,b)表示a与b的最大公因数

lcm(a,b)表示a与b的最小公倍数

性质

① $gcd(a,b)=gcd(a-b,b)=gcd(a\%b,b)$

证明：设$a>b$

设 $gcd(a-b,b)=g$

$∴g|a,-b g|b$

$∵a=a+(a-b)$

$∴g|a$

$∴g|gcd(a,b)$

$∴gcd(a-b,b)|gcd(a,b)$

同理可证，$gcd(a,b)|gcd(a-b,b)$

$∴gcd(a,b)=gcd(a-b,b)$

`倒推可知，$gcd(a,0)=gcd(a,a)=a$

②$gcd(a,b)×lcm(a,b)=a×b$

证明：设$g=gcd(a,b)，a=k1 * g , b=k2 * g$

$lcm(a,b)=lcm(k1×g,k2×g)$
$=g * lcm(k1,k2)=g×k1×k2$

$gcd(a,b)×lcm(a,b)=g×g×k1×k2$
$=(g×k1)×(g×k2)=a×b$

3、贝祖定理（裴蜀定理）

对于任意整数a，b和它们的最大公约数d，关于x，y的方程$ax+by=m$当且仅当m是d的倍数时有整数解

五、埃氏筛法

求1~N范围内所有质数的埃氏筛法

从2~N顺序枚举，当前位若未被标记，则是质数，标记该数在N以内的所有倍数。

对于一个合数，它一定会在枚举到它的最小质因子时被标记。

时间复杂度$O(NloglogN)$

【例题1】

5000000组询问，每次给出n，问n的约数个数。
n<=1e6

【分析】

对n进行质因数分解:$n=∏p_i^{c_i}$
其中pi均为质数。

根据组合思想易知，约数个数$sum=∏(ci+1)$

利用埃氏筛处理出1e6以内每个数的最小质因子。因为埃氏筛第一次筛到的一定是最小质因子，所以可以记录下p与c，然后将最小质因子除去，最终一定会变成1。这样就完成了质因数分解。

【例题2】

给定n，求有多少正整数数对(x,y)满足$\frac{1}{x}+\frac{1}{y}=\frac{1}{n!}$

n<=1e6

【分析】

可以发现，x和y都大于n!

不妨设$y=t+n! (t \in Z+)$

原式==> $\frac{1}{x}+\frac{1}{n!+t}=\frac{1}{n!}$

化简得:$x=\frac{(n!)^2}{t}+n!$

只要确保分子是分母的倍数，就可以保证xy满足约束

所以解的数量就是$(n!)^2$的约数个数

$(n!)^2$分解质因数分解出质数p的次数（也就是上一题中的c）是：

$2Σ_{i>=1}\lfloor \frac{n}{p^i} \rfloor$