算法——基础数学

约数

---

互质：两个数公约数只有1

对于一个大于1正整数n可以分解质因数：n = p1^a1 * p2^a2 * p3^a3 * … * pk^ak

求一个数的约数个数：
n的正约数有(a₁+1)(a₂+1)(a₃+1)…(ak+1)个

求一个数的所有约数的和：
n的正约数之和为(p1^0 + p1^1 + p1^2 + … + p1^a1) * (p2^0 + p2^1 + p2^2 + … + p2^a2) * … * (pk^0 + pk^1 + pk^2 + … + pk^ak)

// 分解约数
void divide(int n)
{
    for (int i = 2; i <= n/i; i++)
    {  
        int cnt = 0;
        if (n % i == 0)
        {
            while (n % i == 0) n /= i, cnt++ ;
            cout << i << " " << cnt << endl;
        }
    }
    if (n > 1) cout << n << " 1" << endl;
}

 

欧拉筛

---

int primes[100010], cnt;
bool st[100010];
void get_primes(int n)
{
    for (int i = 2; i <= n; i++)
    {
        if (!st[i]) primes[cnt++] = i;

        for (int j = 0; j < cnt; j++)
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

 

欧拉函数

---

欧拉函数φ(n)：小于等于n且和n互质的正整数（包括1）的个数
公式：φ(n)=n*(1-1/p1)(1-1/p2)(1-1/p3)*(1-1/p4)……(1-1/pn) (容斥原理可证)

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

 
nlogn级别求区间欧拉函数

int phi[N];

cin >> n;

for(int i = 2; i <= n; i++) phi[i] = i;

for(int i = 2; i <= n; i++)
{
    if(phi[i] == i) // 该数为质数
    {
        for(int j = i; j <= n; j += i)
            phi[j] = phi[j] / i * (i-1);
    }
}

 

// 求 1-n 的欧拉函数之和
int primes[100010], phis[100010] cnt;
bool st[100010];
void get_phis(int x)
{
    phis[1] = 1;
    for (int i = 2; i <= x; i++)
    {
        if (!st[i])
        {
            primes[cnt ++] = i;
            phis[i] = i - 1; // 质数的欧拉函数为其本身减1
        }
        for (int j = 0; j < cnt; j++)
        {
            st[i * primes[j]] = true;
            if (i % primes[j] == 0)
            {
                phis[i * primes[j]] = primes[j] * phis[i]; // 当primes[j]为i的约数时，由欧拉函数公式， p1...pk均不变，n增加primes[j]倍
                break;
            }

            phis[i * primes[j]] = (primes[j] - 1) * phis[i]; // 当primes[j]为该项的最小质数时，i中不含primes[j]， 故在i的基础上多了(1-1/primes[j]), 而n增加primes[j]倍
        }
    }
}

 

快速幂

---

int qmi(int a, int k, int p)
{
    int res = 1;
    while(k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;    
    }

    return res % p;
}

 

逆元

---

定义：对于a*b≡1(mod m),那么称b是a的模m乘法逆元。
欧拉定理： 当a与n互质，则存在 a^φ(n) ≡ 1(mod n)
费马小定理： 特别的，当n为质数时, a^(n-1) ≡ 1(mod n)

/********
快速幂求乘法逆元
设逆元为x
t/a ≡ t * x (mod p) => 
t ≡ a * t * x (mod p) =>
a * x ≡ 1 (mod p)

当p均为质数， 由费马小定理  a^(p-1) ≡ 1 (mod p)
故x = a^(p-2) (mod p) => qmi(a, p-2, p);
*********/

 

欧几里得扩展

---

int exgcd(int a, int b, int &x, int &y)
{
    if (!b)
    {
        x = 1, y = 0;
        return a;
    }
    int d = exgcd(b, a % b, y, x); // 若未将x, y交换顺序，则需写成:
    y -= (a/b)*x;                  // int t = x;
                                   // x = y, y = t - (a/b)*y;
    return d;
}

 

矩阵乘法

---

两矩阵相乘，左矩阵列数必须等于右矩阵行数

struct matrix  
{
    int n, m; // 行, 列
    int c[N][N];
};

matrix mul(matrix a, matrix b, int mod)
{
    matrix res;
    res.n = a.n;
    res.m = b.m
    
    memeset(res, 0, sizeof res);
    
    for(int i = 0; i < n; i++) // a的行数
        for(int j = 0; j < m; j++)// b的列数
            for(int k = 0; k < a.m; k++)// a的列数或b的行数(相同)
                res.c[i][j] = (res.c[i][j] + a.c[i][k] * b.c[k][j] % mod) % mod;
    return res;
}

 

矩阵快速幂

---

原理与快速幂相似，将乘法改为矩阵乘法即可

matrix matirx_qmi(matrix a, int k, int mod)
{
    matrix res;
    
    res.n = a.n, res.m = a.m;
    
    for(int i = 0; i < n; i ++)
        for(int j = 0; j < m; j++) 
            res.c[i][j] = (i == j);
    
    while(k) 
    {
        if(k & 1) res = mul(res, a, mod);
        a = mul(a, a, mod);
        k <<= 1;
    }    
    return res;
}