简单数论

素数筛法

• 暴力枚举求素数O(n*n^(1/2))

枚举每个数，判断是否有正整数能整除这个数

for(int i=2;i<=n;i++)
{
    bool composite=0;    //composite合数标记
    for(int j=2;j*j<=i;j++)    //从2遍历到n，找出从2到n的所有素数，j只需要检查到根号i，因为一个合数composite必然是由一个大于等于根号下composite和一个小于等于根号下composite的数相乘而得的，只要找到小于等于根号下composite的那个数就可以了
    {   
        if(i%j==0)    //i能被整除
        {
            composite=1;    //是合数，composite=1
            break;    //退出当前循环，检查下一个数
        }
    }
    if(composite==0)    //执行到这一步说明i不能被任何数整除，除了1和它本身，即i是一个质数
    {
        count++;
        prime[count]=i;    //加入质数数组
    }
}

 

• 普通筛法O(nlogn)

一个合数一定可以分成多个素数的乘积，因此每找到一个素数，就可以把它的倍数都标记成合数，从2到n只需遍历一遍便可以找到所有素数。

for(int i=2;i<=n;i++)    //检查从2到n的所有数
{
    if(prime[i]==0)    //一开始假定所有数都是素数，即prime[2~n]=0，在后续操作中prime[i]=1表示i是合数
    {
        p[count++]=i;    //从2开始，prime[i]=0说明是素数
        for(int j=2;j*i<=n;j++)    //把2~n范围内所有i的倍数都设置为合数
        {
            prime[i*j]=1;
        }
    }
}

• 线性筛法O(n)

普通筛法中，一个合数可能被多个素数筛掉，也就是重复被筛，浪费时间复杂度，线性筛法中将合数表示成最小素数×一个数的形式。

for(int i=2;i<=n;i++)
{
    if(prime[i]==0)
    {
        p[count++]=i;
    }
    for(int j=1;j<=count&&i*p[j]<=n;j++)    //缩小被筛范围，p[0~count]中是所有比i的最小素因子小的素数，则p[j]*i是合数，若i本身是p[j]的倍数，则跳出这层循环，检查下一个i
    {
        prime[i*p[j]]=1;
        if(i%p[j]==0) break;
    }
}

快速幂

后一项是前一项的平方

int ans=1;
while(b!=0)
{   
    if(b&1)
    {
        ans=(ans*a)%c;
    }
    a=(a*a)%c;    //前一项是后一项的平方
    b/=2;
}

逆元

同余不满足除法，即a/b mod p ≠(a mod p)/(b mod p)

若b*x=1(mod p)则称x是b关于p的乘法逆元

设a/b=k，则a/b=k(mod p)

两边同乘(b*x)，得a*x=k(mod p)

故我们要计算a/b mod p的结果就可以计算a*x mod p的结果

 

拓展欧几里得

ax+by=gcd(a,b) （a,b一定有解）

先考虑辗转相除法计算最大公约数的算法

gcd(a,b)=gcd(b,a%b)

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

即可得到ax+by=gcd(a,b)的解

a/b得到其相除后向下取整的结果，x2,y2是已知的。

int exgcd(int a,int b,int &x,int &y)
{
    if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    int r=exgcd(b,a%b,x,y);
    int temp=x;    //temp存放x2的值
    x=y;    //x1=y2
    y=temp-(a/b)*y;    y1=x2-(a/b)*y2
    //顺序不能乱，x表示x1，若在第一步就执行x=y，后面使用到的x就都是x1的值，但实际上使用的应该是x2的值
    return r;
}

gcd不断递归求解一定会就有个时候b=0，所以递归可以结束。