算法解析：质数判断与分解、约数计算-优快云博客

本文链接：https://blog.youkuaiyun.com/hacker__man/article/details/124042995

质数：

1.试除法 $o(\sqrt{n})$

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

分解质因数 $O(log_2{n} \sim\sqrt{n})$

void divide(int x){
	for(int i=2;i<=n/i;i++){
		if(n%i==0){
			int s=0;
			while(n%i==0){
				n/=i;
				s++;
			}
			cout<<i<<" "<<s<<endl;
		}
	}
    if(n>1){//n中最多只有一个大于sqrt(n)的质因子，将n中其他的因子除干净就剩他了
        cout<<n<<" "<<1<<endl;
    }
}

证明：i 一定是n的质因子。

如果 i 是 n 的合数因子，i 一定可以被分解成质数乘积的形式，这些质数比i小，同时也是n的质因子，但在枚举到i之前，所有小于i的因子都被筛掉了，所以i一定是n的质因子。

n中最多只有一个大于sqrt(n)的质因子

质数筛法

暴力的思想，将所有数列举出来，用2,3,4作为底数，将他们的倍数筛掉。

对于 p ，如果 p 没有被筛掉的话，那么 2 ~ p-1 不存在p的因子，满足素数定义。

void get_primes(int n){
    for(int i=2;i<=n;i++){
        if(!st[i])pre[++cnt]=i;
        for(int j=i+i;j<=n;j+=i){
            st[j]=1;
        }
    }
}

时间复杂度：

$O(n\ ln \ n+c) = O(nlogn)$

质数定理:1~n中一共有 n/ln n 个质数

优化，只筛掉质数的倍数，当一个数不是质数就不需要筛掉他的倍数。

原因：根据质数分解定理，任意一个合数都可以表示成质数的幂的乘积，所以只需要用质数来筛合数就行。

埃氏筛法 真实的时间复杂度 $\ loglogn)$

void get_primes(int n){
    for(int i=2;i<=n;i++){
        if(!st[i]){
            pre[++cnt]=i;
            for(int j=i+i;j<=n;j++){
                st[j]=1;
            }  
        }
    }
}

线性筛法

每个数 i 只被他的最小质因子筛掉。

for(int i=2;i<=n;i++){
    if(!st[i])pre[++cnt]=i;
    for(int j=0;pre[j]<=n/i;j++){
        st[i*pre[j]]=1;
        if(i%pre[j]==0)break;
    }
}

一些说明：

证明1：证明数 n 一定会被他的最小质因子筛掉。

1. if(i%pre[j]==0)break;
因为pre[j]是从小到大枚举的所有质因子，所以pre[j]  一定是 pre[j] * i 的最小质因子。
2. 当 i%pre[j] != 0
	pre[j] 一定小于i的最小质因子，此时pre[j] 也一定是 pre[j] * i 的最小质因子。

证明2：对于一个合数，他一定是会被筛掉。

合数 x ，有pre[j] 是他的最小质因子， i 枚举到 i = x/pre[j] ，i * pre[j] 就把 x 筛掉了。

约数

试除法求一个数的约数。 $O(\sqrt{n})$

一个数的约数一定是成对出现的。

vector<int>get(int n){
	vector<int>res;    
    for(int i=1;i<=n/i;i++){
        if(n%i==0){
            res.push_back(i);
            if(i!=n/i){
                res.push_back(n/i);
            }
        }
    }
    sort(all(res));
    return res;
}

约数个数 $O(\sqrt{n})$

根据唯一分解定理，每个数的唯一分解的形式是唯一的。

$p^{\alpha_1}p^{\alpha_2}p^{\alpha_3}...p^{\alpha_k}$

$N$ 的约数一定是这样的形式：

$p^{\beta_1}p^{\beta_2}p^{\beta_3}...p^{\beta_k}$

$0\leq \beta_i \leq \alpha_i $

所以，约数个数是 $(\alpha_1+1) *(\alpha_2+1) * ...* (\alpha_k+1)$

考虑：1~n 中每个数的约数个数是多少

对于1~n中的每个数分别考虑， i有约数k，那么k就有倍数i。

易得，1~n中约数的个数是 n ln n，所以每个数的约数的期望是 ln n ~ log n

int 范围内，一个数约数个数最多大概是1500

求n个数的乘积的的约数个数，求mod

#include<iostream>
#include<cstring>
#include<algorithm>
#include<unordered_map>
using namespace std;

const int N=1e6+10,mod=1e9+7;

int n;


int main()
{
    cin>>n;
    unordered_map<int,int>Hash;
    while(n--)
    {
        int x;cin>>x;
        for(int i=2;i<=x/i;i++)
        {
            while(x%i==0)
            {
                x/=i;
                Hash[i]++;
            }
        }
        if(x>1)Hash[x]++;
    }
    long long res=1;

    unordered_map<int,int>::iterator it;
    for(it=Hash.begin();it!=Hash.end();it++)
    {
        res=(res*(it->second+1))%mod;
    }
    
    cout<<res%mod<<endl;
    
    return 0;
}

约数之和

利用组合数的思想。

约数之和 = $(p_1^{0}+p_1^{1} + ...+p_1^{\alpha_1}) * ...* (p_k^{0}+p_k^{1} + ...+p_k^{\alpha_k})$

求n个数的乘积的约数之和。

方法也是把 n个数的乘积都分解质因数，将结果存到一个hash表中。

对于每个质数求 $p^0+p^1+...+p^k$ $有分治 O (l o g k)$ 的做法

这个怎么求！

y总的方法 $O (n)$ ：另 $t = p * t + 1$

$t = 1\\ t = p*t+1\\ t = p^2+p+1\\ a次之后\\ t= p^a+p^{a-1}+...+1$

#include<iostream>
#include<algorithm>
#include<unordered_map>
using namespace std;
typedef long long ll;
const int mod=1e9+7;


unordered_map<int,int>m;
int main()
{
    int n;cin>>n;//预处理，得到所有数分解质因数的情况
    while(n--)
    {
        int x;cin>>x;
        for(int i=2;i<=x/i;i++)
        {
            while(x%i==0)
            {
                m[i]++;
                x/=i;
            }
        }
        if(x>1)m[x]++;
    }
    ll res=1;//这个不能放在外面
        for(auto t:m)
        {
            ll p=t.first,a=t.second;
            ll ans=1;
            while(a--)
            {
                ans=(p*ans+1)%mod;
            }
            res=res*ans%mod;
        } 
    cout<<res;
    return 0;
}