数论学习（1）

质数

概念：质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。
如何判定质数？
代码模板 时间复杂度O(sqrt(n))

bool is_prime(int x) （试除法）
{
    if (x < 2) return false;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
            return false;
    return true;
}
因为因数总是成对出现的，所以只需要判断根号n之前的数是否是因数即可。
另外不建议写成i*i<=x（可能会溢出）。

分解质因数
代码模板 *时间复杂度O（log₂n~sqrt(n))

void divide(int x)
{
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
        {
            int s = 0;
            while (x % i == 0) x /= i, s ++ ;
            cout << i << ' ' << s << endl;   //其中i为底数 s为指数
        }
    if (x > 1) cout << x << ' ' << 1 << endl;
    cout << endl;
}

筛质数（筛法）
题目描述：给定一个正整数n，请你求出1~n中质数的个数。
朴素筛法
代码模板 *时间复杂度O(nloglogn)

int primes[N], cnt;
bool st[N];
void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (st[i]) continue;
        primes[cnt ++ ] = i;
        for (int j = i + i; j <= n; j += i)
            st[j] = true;
    }
}
删去质数的所有倍数 ，剩下的即为质数。

线性筛法（较快）

int primes[N], cnt;
bool st[N];

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; primes[j] <= n / i; j ++ )//此处防止primes[j]*i>n超出筛选范围
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;  //primes[j]一定是i的最小质因子
        }
    }
}
任何一个合数一定会被筛掉。
每一个合数一定会有一个最小质因子，且一定会被筛一次，顾它是线性的。

约数

概念：约数，又称因数。整数a除以整数b(b≠0) 除得的商正好是整数而没有余数，我们就说a能被b整除，或b能整除a。a称为b的倍数，b称为a的约数。
试除法求约数
题目描述：给定n个正整数ai，对于每个整数ai,请你按照从小到大的顺序输出它的所有约数。

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;
}
因数总是成对出现，顾只需要求其中一个。

约数个数

题目描述：给定n个正整数ai，请你输出这些数的乘积的约数个数，答案对109+7取模。
代码模板

unordered_map<int,int>primes;  //哈希存储质数
while(n--)                                   //先分解质因数
    {
        int x;cin>>x;
        
        for(int i=2;i<=x/i;i++)
            while(x%i==0)
            {
                primes[i]++;
                x/=i;
            }
        if(x>1) primes[x]++;
    }
    ll res=1;
    
    for(auto t:primes) res=res*(t.second+1)%mod; 
    最后套用公式即可  

约数之和

题目描述：给定n个正整数ai，请你输出这些数的乘积的约数之和，答案对109+7取模。
代码模板

#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <vector>

using namespace std;

typedef long long LL;

const int N = 110, mod = 1e9 + 7;

int main()
{
    int n;
    cin >> n;

    unordered_map<int, int> primes;

    while (n -- )
    {
        int x;
        cin >> x;

        for (int i = 2; i <= x / i; i ++ )
            while (x % i == 0)
            {
                x /= i;
                primes[i] ++ ;
            }

        if (x > 1) primes[x] ++ ;
    }

    LL res = 1;
    for (auto p : primes)
    {
        LL a = p.first, b = p.second;
        LL t = 1;
        while (b -- ) t = (t * a + 1) % mod; //其中可令t=t*a+1这样可以让0到p的每一次幂都想加
        res = res * t % mod;                 //即为a(a(a+1)+1))+····
    }

    cout << res << endl;

    return 0;
}

求最大公约数代码模板

辗转相除法

int gcd(int a,int b)
{
    if(b==0) return a;
    
    return gcd(b,a%b);
}
可简写为
int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

欧拉函数

欧拉函数：
就是对于一个正整数n，小于n且和n互质的正整数（包括1）的个数，记作φ(n) 。
欧拉函数的通式：φ(n)=n(1-1/p1)(1-1/p2)(1-1/p3)(1-1/p4)……(1-1/pn)

一个小概念：在自然数中,公因数只有1的两个数叫互质数,1与任何一个自然数（零除外）的因数只有一个1,所以一与任何一个自然数都是互质数.

例题描述：请你求出欧拉函数。
代码模板

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;
}

筛法求欧拉函数

题目描述：给定一个正整数n，求1~n中每个数的欧拉函数之和。
代码模板（在线性筛法的基础上）

int primes[N], cnt;
int euler[N]; //记录每个数的欧拉函数值
bool st[N];
void get_eulers(int n)
{
    euler[1] = 1;
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i])  当这个数是素数时
        {
            primes[cnt ++ ] = i;
            euler[i] = i - 1; 其欧拉函数值为1到i-1，都与其互质可直接算出
        }
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            int t = primes[j] * i;
            st[t] = true;
            if (i % primes[j] == 0)   //当pj是i的因数时，i也是pj*i的因数，根据公式可算出,
            {                        //pj*i的欧拉函数值与i之间差一个pj（pj*i与i的质因数全部相同，因为i时pj的质因数）
                euler[t] = euler[i] * primes[j];
                break;
            }
            euler[t] = euler[i] * (primes[j] - 1); //当pj不是i的质因数时
        }                                         //i与pj成i之间差了个pj*(1-1/pj)故只需要成上即可
    }
}

快速幂