质数分解-扩展（约数个数、约数和、欧拉函数）

质数分解-扩展（约数个数、约数和、欧拉函数）

• C++实现
• 此处vector<int> P, C并非必要，这里只是为了顺序查看分解后的质数
• 约数个数与约数之和适用的场景多为处理一个极大的数（基本类型无法表示，如$N$个$a_i$相乘后的约数个数或约数之和）
  • 解决方法：
    • 用unordered_map替代divide函数中vector
    • 以p为key，c为value存储，汇总每个$a_i$​​的分解结果，最后统一处理
    • 在最后一节会给出对应代码，有兴趣的话可以看一下

质数分解-简单回顾

根据算术基本定理，任何一个大于$1$的正整数都能唯一分解为有限个质数的乘积，可写作：
$$N=p_1^{c_1}{p}_2^{c_2}\cdots p_m^{c_m}$$
其中，$c_i$都是正整数，$p_i$都是质数，且满足$p_1<p_2<\cdots <p_m$

该节是下面各节的基础，P, C在之后会被反复用到，请优先理解本节代码

后面章节在运行前，都需要先运行一遍本节divide函数

vector<int> P, C; // 存储的是对应的p_i, c_i

void divide(int n) 
{
    for (int i = 2; i <= n / i; i ++)
    {
        if (n % i == 0)
        {
            int s = 0;

            while (n % i == 0)
            {
                n /= i;
                s ++;
            }

            P.push_back(i);
            C.push_back(s);
        }
    }

    if (n > 1) // 可能会剩余一个大质数，也需将其加入P, C
    {
        P.push_back(n);
        C.push_back(1);
    }
}

输入：
n = 100

输出：
p = 2, c = 2
p = 5, c = 2

约数个数

针对一个正整数$N$，它的正约数个数为：
$$(c_1+1)\ast (c_2+1)\ast \cdots \ast (c_m+1)=\prod _{i=1}^m{c}_i+1$$

int count()
{
    int res = 1;
    for (int i = 0; i < C.size(); i ++)
    {
        int c = C[i];

        res *= (c + 1);
    }
    return res;
}

输入：
n = 100 // 从divide函数输入

输出：
约数个数: 9

约数之和

针对一个正整数$N$，它的正约数之和为：
$$(1+p_1+p_1^2+\cdots +p_1^{c_1})\ast \cdots \ast (1+p_m+p_m^2+\cdots +p_m^{c_m})=\prod _{i=1}^m\left(\sum _{j=0}^{c_i}(p_i{)}^j\right)$$

int sum()
{
    int res = 1;
    for (int i = 0; i < P.size(); i ++)
    {
        int p = P[i];

        int t = 1;
        // 秦九韶算法 -> p^3 + p^2 + p + 1 = p(p(p + 1) + 1) + 1
        for (int j = 0; j < C[i]; j ++) t = (t * p + 1); 

        res *= t;
    }
    return res;
}

输入：
n = 100 // 从divide函数输入

输出：
所有约数之和: 217

欧拉函数

$1\sim N$中与$N$互质的数的个数被称为欧拉函数，记为$\phi (N)$

• $\forall a,b\in \mathbb{N}$，若$gcd(a,b)=1$，则称$a,b$互质

$$\phi (N)=N\ast \frac{p_1-1}{p_1}\ast \frac{p_1-2}{p_2}\ast \cdots \ast \frac{p_m-1}{p_m}=N\ast \prod _{p=1}^m\left(1-\frac{1}{p}\right)$$

int phi(int n)
{
    int res = n;

    for (int i = 0; i < P.size(); i ++)
    {
        int p = P[i];
        res = res / p * (p - 1);
    }

    return res;
}

输入：
n = 100

输出：
1~100中与100互质的数的个数: 40

附录

#include <iostream>
#include <unordered_map>

using namespace std;

unordered_map<int, int> map;

void divide(int n)
{   
    for (int i = 2; i <= n / i; i ++)
    {
        if (n % i == 0)
        {
            int s = 0;
            
            while (n % i == 0)
            {
                n /= i;
                s ++;
            }

            map[i] += s;
        }
    }

    if (n > 1) map[n] += 1;
}

int count()
{
    int res = 1;

    for (auto i : map) res *= (i.second + 1);

    return res;
}

int sum()
{
    int res = 1;

    for (auto i : map)
    {
        int p = i.first;

        int t = 1;
        for (int j = 0; j < i.second; j ++) t = (t * p + 1);

        res *= t;
    }

    return res;
}

int main()
{
    int a[] = {10, 45, 66, 39, 75};
    for (int i = 0; i < sizeof(a) / sizeof(int); i ++) divide(a[i]);
    cout << count() << endl;  // 360
    cout << sum() << endl; // 334317984
}