寒假训练报告2.2（数论基础）

1.最大公约数 ——辗转相除法
原理：求gcd(a, b)，设 a = p * b + q，所以gcd(b, q) 既整除a，又整除b。故gcd(a, b) = gcd(b, a % b) = … = gcd(c, 0) = c
时间复杂度：O(log max(a, b) )

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

2.扩展欧几里得算法
首先证明定理：ax + by = 1是 a, b互质的充要条件，其为裴蜀定理的推论
参考：https://www.cnblogs.com/tekkaman/p/3732098.html
充分性：设gcd(a, b) = c，则a % c = 0, b % c = 0， 故(ax+by) % c = 0
即1 % c = 0，c = 1，故 gcd(a, b) = 1, a,b互质
必要性：（证明没看懂，日后在看）

假设已经求得bx’+(a%b)y’ = gcd(a,b)，a%b = a - (a/b) * b，当b=0时，有a*1+b*0 = a = gcd(a, b)

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

关于ax+by=gcd(a,b)的解的大小
|x| = |x’| <= b, |y| = |y’-(a/b)x’| <= |y’|+(a/b)|x’| <= a%b+(a/b)*b = a

3.关于素数的基础算法
1) 素性测试O(n^1/2)

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

2)埃氏筛法（素数筛） O(nloglogn) ≈ O(n)
算法描述：从1开始，每次筛去剩下数的倍数，最后剩下的都是素数。

int prime[maxn];    //第i个素数
bool is_prime[maxn];    //第i个数是否为素数
void Prime(int n){
    fill(is_prime, is_prime+n, 1);
    is_prime[0] = is_prime[1] = 0;
    int t = 0;
    for(int i = 2; i <= n; i++){
        if(is_prime[i]){
            prime[t++] = i;
            for(int j = i + i; j <= n; j += i)
                is_prime[j] = 0;
        }
    }
}

3)区间筛法
求区间 [a,b) 内有多少个素数
先求 [2, b^1/2)的素数，再用这些素数筛掉[a, b)，就可求得 [a, b)中的素数

bool is_prime[maxn];    
bool is_prime_small[maxn_b];
void segment_sieve(int a, int b){
    for(int i = 0; i * i < b; i++)  is_prime_small[i] = 1;
    for(int i = 0; i < b - a; i++)  is_prime[i] = 1;
    for(int i = 2; i * i < b; i++){
        if(is_prime_small[i]){
            for(int j = 2 * i; j * j < b; j += i)
                is_prime_small[j] = 0;
            for(j = max(2, (a = i - 1) / i) * i); j < b; j += i)
                is_prime[j - a] = 0;
        }
    }
}

4)欧拉筛O(n)
算法原理：保证每个数只会被它的最小素因子筛掉，在数字范围很大时很快

int prime[maxn];    //第i个素数
bool is_prime[maxn];    //第i个数是否为素数
int Prime(int n){
    fill(is_prime, is_prime+n, 1);
    is_prime[0] = is_prime[1] = 0;
    int t = 0;
    for(int i = 2; i <= n; i++){
        if(is_prime[i]){    //不是目前找到的素数的倍数
            prime[t++] = i;
            for(int j = 1; i*prime[j] <= n; j++){
                is_prime[i*prime[j]] = 0;   //找到的素数的素数倍不访问
                if(i % prime[j] == 0)   break;  //已经找到最小质因子
            }
        }
    }
    return t;
}

4.模运算
基本的模运算率
同余公式也有许多我们常见的定律结合律,交换律,传递律….如下面的表示:

1. 相等率 a≡a(mod d)
2. 对称性 a≡b(mod d)→b≡a(mod d)
3. 传递性 (a≡b(mod d),b≡c(mod d))→a≡c(mod d)
4.     如果a≡x(mod d),b≡m(mod d),则
5. a+b≡x+m (mod d）
6. a -b≡x- m (mod d)
7. a* b≡x* m (mod d )
8. a/ b≡x/ m (mod d）
9. a≡b（mod d）则a-b整除d
10. a≡b（mod d）则a^n≡b^n(mod d)
11. 如果ac≡bc(mod m)，且c和m互质，则a≡b(mod m）

5.快速幂运算 —— 反复平方法O(logn)

ll mod_pow(ll x, ll n){
    ll res = 1;
    while(n > 0){
        if(n & 1)   res = res * x % mod;//如果二进制最低位为1，则乘上x^(2^i)
        x = x * x % mod;    //将x平方
        n >> 1;
    }
    return res;
}