ACM基础数论笔记

基础数论部分

整除

定义

a,bZ,a0,若存在qZ使得b=aq则b可被a整除,记作ab,称b是a的倍数,a是b的约数

不能整除 ab

定理

  1. ababab|a||b|
  2. abbcac
  3. abacx,yZ,abx+cy
  4. m0,abmamb
  5. abbab=±a
  6. b0,ab|a||b|

约数

对于一个数n,其约数定义为能够整除n的数,在整数域内等价于因数

试除法求n的所有约数:

vector<int> get_divisors(int x){
    vector<int> res;
    for (int i = 1; i <= x / i; i ++ )
        if (x % i == 0){
            res.push_back(i);
            if (i != x / i) res.push_back(x / i);
        }
    sort(res.begin(), res.end());
    return res;
}

最大公约数(GCD)

指两个或多个整数中共有的约数中最大的一个a,b的最大公约数记为(a,b)gcd(a,b)

特别的gcd(0,a)=a

最常见使用辗转相除法求gcd

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

最小公倍数(LCM)

两个或多个整数最小的公共倍数,a,b的LCM记为[a,b]

公式:[a,b]=a/(a,b)b

ll lcm(ll m,ll n){
    ll g1,b;
    g1 = __gcd(m,n);
    b = (m*n) / g1; 
    return b;
}

质数

一个正数p除了±1,±p之外无其他约数,则称p为质数

若a是一个合数,则必有质数p,pa

质数的个数是无穷的

判定质数的方法

试除法判质数

适用于数据范围1012

试除法的原理就是用[2,n]内的所有数试着除n,如果都不能整除,就是素数

时间复杂度O(n)

bool isPrime(int x){
    if(x<2){
        return false;
    }
    for(int i=2;i<=x/i;i++){
        if(x%i==0){
            return false;
        }
    }
    return true;
}

//常数优化 sqrt(x)/3
bool isPrime(int n) {
    if (n == 1) return false;
    if (n == 2 || n == 3) return true;
    if (n % 6 != 1 && n % 6 != 5) return false;
    for (int i = 5, j = n / i; i <= j; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) {
            return false;
        }
    }
    return true;
}

Miller Rabin素性测试

适用于数据范围>1012时使用

费马素性测试:基于费马小定理

找一个数x,判定am1mod m1,如果找到n个数满足判定,就把m认为是质数

正是由于费马小定理无法判断伪质数也叫Carmichael数,所以费马素性测试并不能保证完全正确

二次探测定理:如果p是一个奇素数,且e1,则方程x21(mod pe)仅有两个解:x=1x=1e=1时方程仅有两个解x=1x=p1,称其为平凡平方根

Miller Rabin算法在费马素性测试基础上通过二次探测定理改进而来

如果一个数满足方程x21(mod n)x不等于平凡平方根1或n-1,则称其为非平凡平方根,如果对模n存在1的非平凡平方根,n就是合数

ll mul(ll a, ll b, ll m) {
    return static_cast<__int128_t>(a) * b % m;
}
ll power(ll a, ll b, ll m) {
    ll res = 1 % m;
    for (; b; b >>= 1, a = mul(a, a, m))
        if (b & 1)
            res = mul(res, a, m);
    return res;
}
bool isprime(ll n) {
    if (n < 2)
        return false;
    static constexpr int A[] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
    int s = __builtin_ctzll(n - 1);
    ll d = (n - 1) >> s;
    for (auto a : A) {
        if (a == n)
            return true;
        ll x = power(a, d, n);
        if (x == 1 || x == n - 1)
            continue;
        bool ok = false;
        for (int i = 0; i < s - 1; ++i) {
            x = mul(x, x, n);
            if (x == n - 1) {
                ok = true;
                break;
            }
        }
        if (!ok)
            return false;
    }
    return true;
}

标准分解形式

n=p1k1p2k2...pnkn {p1<p2<...<pn}

pi为质数,也为质因数分解形式

算数基本定理:任意一个大于1的整数都可以被分解成若干个质数相乘的形式

  1. n=p1a1p2a2...pnan

    m=p1b1p2b2...pnbn

    0biai,i=1,...,k,则m是n的正因数

  2. n=p1a1p2a2...pnanai>0,i=1,2,...,k,则n的正因数个数有(a1+1)(a2+1)...(ak+1)

  3. n=p1a1p2a2...pnan

    m=p1b1p2b2...pnbn

    (a,b)=p1γ1p2γ2...pnγn

    [a,b]=p1σ1p2σ2...pnσn

    其中 γi=min(ai,bi),σi=max(ai,bi),i=1,2,...,k

  4. 约数之和:(p10+p11+...+p1k1)(p20+p21+...+p2k2)...(pn0+...+pkkn)

质因数分解

试除法分解质因数

时间复杂度O(n)

map<int,int> cnt;
void divide(int x){
    for(int i=2;i<=x/i;i++){
        if(x%i==0){
            while(x%i==0){
                x/=i;
                cnt[i]++;
            }
        }
    }
    if(x>1) cnt[x]++;
}

Pollard Rho算法

pollard rho用于求解大数质因子问题,使用Miller Rabin判断质数,原理是生日悖论,了解即可

ll mul(ll a, ll b, ll m) {
    return static_cast<__int128_t>(a) * b % m;
}
ll power(ll a, ll b, ll m) {
    ll res = 1 % m;
    for (; b; b >>= 1, a = mul(a, a, m))
        if (b & 1)
            res = mul(res, a, m);
    return res;
}
bool isprime(ll n) {//Miller Rabin部分
    if (n < 2)
        return false;
    static constexpr int A[] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
    int s = __builtin_ctzll(n - 1);
    ll d = (n - 1) >> s;
    for (auto a : A) {
        if (a == n)
            return true;
        ll x = power(a, d, n);
        if (x == 1 || x == n - 1)
            continue;
        bool ok = false;
        for (int i = 0; i < s - 1; ++i) {
            x = mul(x, x, n);
            if (x == n - 1) {
                ok = true;
                break;
            }
        }
        if (!ok)
            return false;
    }
    return true;
}
std::vector<ll> factorize(ll n) {//pollard rho部分,所有的质因数都会作为vector元素返回
    std::vector<ll> p;
    std::function<void(ll)> f = [&](ll n) {
        if (n <= 10000) {
            for (int i = 2; i * i <= n; ++i)
                for (; n % i == 0; n /= i)
                    p.push_back(i);
            if (n > 1)
                p.push_back(n);
            return;
        }
        if (isprime(n)) {
            p.push_back(n);
            return;
        }
        auto g = [&](ll x) {
            return (mul(x, x, n) + 1) % n;
        };
        ll x0 = 2;
        while (true) {
            ll x = x0;
            ll y = x0;
            ll d = 1;
            ll power = 1, lam = 0;
            ll v = 1;
            while (d == 1) {
                y = g(y);
                ++lam;
                v = mul(v, std::abs(x - y), n);
                if (lam % 127 == 0) {
                    d = std::__gcd(v, n);
                    v = 1;
                }
                if (power == lam) {
                    x = y;
                    power *= 2;
                    lam = 0;
                    d = std::__gcd(v, n);
                    v = 1;
                }
            }
            if (d != n) {
                f(d);
                f(n / d);
                return;
            }
            ++x0;
        }
    };
    f(n);
    std::sort(p.begin(), p.end());
    return p;
}

整除函数

定义

xR,定义[x]等于不超过x的最大整数,称[x]为取整函数或高斯函数,也称[x]为x的整数部分,{x}为x的小数部分

性质

  1. x=[x]+x

  2. [x]x<[x]+1,x1<[x]x,0{x}<1

  3. nZ,[n+x]=n+[x]

  4. [x]+[y][x+y],{x}+{y}{x+y}

  5. 带余除法:设a,bZ,b>0,a=b[ab]+b{ab},0b{ab}b1

  6. a,bZ+,ba[ab]

  7. xy,[x][y]

二元一次不定方程

定义

未知数必须受到某种限制(如整数,正整数,有理数等)的方程,称为不定方程

a,b,cZ,ab0,ax+by=c为关于变量x,y的二元一次不定方程

定理

  1. 设二元一次不定方程ax+by=c(a,b,cZ,ab0)

    有一整数解x=x0,y=y0,(a,b)=d,a=a1d,b=b1d则此不定方程的一切整数解可以表示为x=x0b1t,y=y0a1t,tZ

  2. 二元一次不定方程ax+by=c有整数解的充要条件是(a,b)c

  3. 裴蜀定理:二元一次不定方程ax+by=c一定存在x,y 使得ax+by=(a,b)

    可以拓展到多元一次不定方程:

    void solve(){
        int n;
        cin>>n;
        vector<int> a(n);
        in(a,n);//输入n个系数
        int sum=0;
        For(i,0,a.size()){
            sum=__gcd(sum,abs(a[i]));//gcd(0,a)=a
        }
        cout<<sum<<"\n";
    }
    

扩展欧几里得(exGCD)

求解二元一次不定方程ax+by=(a,b)的一个特解

int exgcd(int a, int b, int &x, int &y) {
    if (!b) {
        x = 1, y = 0;
        return a;
    }
    int g = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return g;
}

如何用扩展欧几里得算法求二元一次不定方程ax+by=c,gcd(a,b)c的解

先用exgcd求出ax+by=(a,b)的一个特解x0,y0,然后然后给每个数乘上c/gcd(a,b)即可

通解便是x=x0+bgcd(a,b)k,y=y0agcd(a,b)k

使用扩展欧几里得求线性同余方程:设同余方程axb(mod c)

根据同余定义,我们可以将同余方程化为二元一次不定方程axcy=b,这个时候就可以使用exgcd求出一组(a,c)的特解了,再乘以b/gcd(a,c)就是最后的答案ans,如果结果要求是正数,我们可以使用(ans+cgcd(a,c))%cgcd(a,c)的形式获得最小正解,解题时要使b为正数

eg:[P1516 青蛙的约会 - 洛谷](P1516 青蛙的约会 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn))

int exgcd(int a, int b, int &x, int &y) {
    if (!b) {
        x = 1, y = 0;
        return a;
    }
    int g = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return g;
}
void solve(){
    int a,b,m,n,l;
    cin>>a>>b>>m>>n>>l;
    if(n-m<0)swap(a,b),swap(m,n);
    int x,y;
    int g=exgcd((n-m),l,x,y);
    if((a-b)%g){//如果最大公约数不是(a-b)的倍数一定无解
        cout<<"Impossible\n";
    }else{
        cout<<((x*((a-b)/g))%(l/g)+(l/g))%(l/g)<<"\n";//最小正整数解
    }
}

同余

定义

m>0,如果a,b的差ab能被m整除,即有q使得ab=qm ,称a,b关于模m同余,记为ab(mod m)

eg:6248(mod 7)

性质

  1. 同余具有自反,对称,传递性,同余是等价关系

  2. ab(mod m),cd(mod m),a±cb±d(mod m)

  3. ab(mod m),cd(mod m),acbd(mod m),反之不然

  4. ab(mod m),nN,anbn(mod m)

  5. acbc(mod m),c0,ab(mod m(c,m))

  6. ab(mod m),m=qn,ab(mod n)

  7. ab(mod mi),i=1,2,3,...,n,ab(mod [m1,m2,...mn])

完全剩余系

如果a,b关于m同余,则a与b属于同一类,否则不属于同一类

这样可以得到m个类,即Mi={i+km|kZ},i=0,1,2,...,m1,称为模m的剩余类

从每个剩余数中各取一个数作为代表,这样得到的m个数成为模m的一个完全剩余系,也叫完系,比如{1,2,...,m}

当m为奇数时,{0,±1,±2,...,±m12}是一个完系

当m为偶数时,{0,±1,±2,...,±m2}是一个完系

a1,a2,...am中每两个数互不同余,则它们毕分属于模m的m个剩余类,组成一个完系

如果(n,m)=1,那么当a1,a2,...am是模m的完系时,na1+k,na2+k,...,nam+k模m互不同余,因此他们也是模m的完系

缩系/既约剩余系

在完全剩余系中,与m互质的元素组成的子集

中国剩余定理(CRT)

求解同余方程的一个解,要求m1,m2,...mn必须互质,如果不互质就需要使用扩展中国剩余定理exCRT

{xa1(mod m1)xa2(mod m2)......xan(mod mn)

x的解公式:x=a1M1M11+a2M2M21+...+anMnMn1

其中,Mi=k=1nmkmiMi1=inv(Mi)

excrt板子:

using ll = long long;
const int N = 1e5+10;
ll Ai[N], Mi[N];
int n; 
constexpr int qpow(int n, int k, int p) {
    int r = 1;
    for (; k; k >>= 1, n = n * n % p)
        if (k & 1) r = r * n % p;
    return r;
}
constexpr ll mul(ll a, ll b, ll p) {
    ll res = a * b - ll(1.L * a * b / p) * p;
    res %= p;
    if (res < 0) {
        res += p;
    }
    return res;
}
ll exgcd(ll a, ll b, ll &x, ll &y) {
    if (b == 0) { x = 1, y = 0; return a; }
    ll gcd = exgcd(b, a % b, x, y), tp = x;
    x = y, y = tp - a / b * y;
    return gcd;
}
ll excrt() {
    ll x, y, k;
    ll M = Mi[1], ans = Ai[1];
    for (int i = 2; i <= n; ++ i) {
        ll a = M, b = Mi[i], c = (Ai[i] - ans % b + b) % b;
        ll gcd = exgcd(a, b, x, y), bg = b / gcd;
        if (c % gcd != 0) return -1;
        x = mul(x, c / gcd, bg);
        ans += x * M;
        M *= bg;
        ans = (ans % M + M) % M;
    }
    return (ans % M + M) % M;
}

费马小定理

定义

多项式展开中 (x+y)p=xp+(p1)xp1y+(p2)xp2y+...+yp

其中(pk)=p!k!(pk)!,当p为质数时,对于满足1kp1的k,pk!(pk)!

p|k!(pk)!p!k!(pk)!,所以p|(pk),k=1,2,...,p1

从而有(x+y)pxp+yp(mod p)

令x=1,y=1,可得2p2(mod p),令x=2,y=1,可得3p3(mod p),......

因此对于所有a=1,2,...,p1,都有apa(mod p)

得到费马小定理:对于任意整数a和质数p,都有apa(mod p)

gcd(a,p)=1,ap11(mod p)

其逆定理不成立,即使得ana(mod n)成立的n不一定是质数,能使其成立的合数n称为伪质数

341最小伪质数,1000以下还有561和645是伪质数

威尔逊定理

若p为质数,则(p1)!1(mod p)

逆元

aa1(mod p)a称为a的逆元

所以从费马小定理可以得出,aap2(mod p)

逆元可以在模意义下用乘法代替原数除法进行运算,即a/bainv b(mod p)

费马小定理求逆元代码

const int mod = 1e9+7;
int qpow(int a,int b){
    int res=1;
    while(b){
        if(b&1) res=res*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return res;
}
int inv(int x){return qpow(x,mod-2);}

但是费马小定理求逆元也有局限性,就是p必须为一个质数,除了费马小定理,我们也可以使用扩展欧几里得求逆元,它要求a与模数p互质即可,p不必须为质数

int exgcd(int a, int b, int &x, int &y) {
    if (!b) {
        x = 1, y = 0;
        return a;
    }
    int g = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return g;
}
int inv(int a, int p){
    int x, y;
    exgcd(a, p, x, y);
    return (p + x % p) % p;
}

欧拉定理

费马定理阐述的是在质数模下,指数的同余性质,当模是合数时,就要用欧拉定理

欧拉函数

ϕ(n):1到n中与n互质的数的个数

互质:gcd(a,b)=1

eg:ϕ(8)=4 {1,3,5,7}

求单个数字的欧拉函数:

int phi(int x){
    int res = x;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0){
            res = res / i * (i - 1);
            while (x % i == 0) x /= i;
        }
    if (x > 1) res = res / x * (x - 1);
    return res;
}

引理

  1. n为一个质数,则ϕ(n)=n1

  2. n为某一个素数p的幂次pa,则ϕ(pa)=(p1)pa1

  3. n为两个质数a,b的积,则ϕ(ab)=ϕ(a)ϕ(b)

  4. n=p1k1p2k2...pnkn {p1<p2<...<pn},则ϕ(n)=n(11p1)(11p2)...(11pk)

欧拉定理

设n为正整数,考虑mod n的缩系,对于缩系中的任意一个元素a,有aϕ(n)1(mod n)

也就是说,若a与n互质,则aϕ(n)1(mod n)

扩展欧拉定理

xn{xn(mod m)x<ϕ(m)xn mod ϕ(m)+ϕ(m)(mod ϕ(m))xϕ(m)

此时x与m可以不互质

posted @   KrowFeather  阅读(16)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 在鹅厂做java开发是什么体验
· 百万级群聊的设计实践
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
· 永远不要相信用户的输入:从 SQL 注入攻防看输入验证的重要性
· 浏览器原生「磁吸」效果!Anchor Positioning 锚点定位神器解析
点击右上角即可分享
微信分享提示