算法入门—质因数分解

α. 质因数分解

每个合数都可以写成几个质数相乘的形式，其中每个质数都是这个合数的因数，236可以写成三个质数相乘的数，这就是质因数分解.

236 = 2 * 2 * 59

β. 素数与素数筛

素数与素数筛是解决本问题需要掌握的概念，没有了解过的同学可以点击传送门来了解

γ. 递归解法

以 236 为例：从2到236遍历，发现236 可以被 2 整除（跳出遍历循环），商为 118，2为质数，是组成结果的一个元素，那我们就只需要把2存起来，关注118就行了，接下来和对236的处理方式一毛一样，之后得到了商为59，本身为素数，结束！

#include "bits/stdc++.h"

using namespace std;
using ll = long long;
const int maxN = 1e3 + 10;

ll countN = 0;
ll a[maxN],M;

int isPrime(ll N) { //判断 N 是否为素数，是返回1，否返回0
    for (ll i = 2; i * i <= N; ++i) {
        if (N % i == 0) return 0;
    }
    return 1;
}

void fac(ll N) {
    if (N == 1) return;
    ll i;
    for (i = 2; i <= N; ++i) {
        if (isPrime(i) && N % i == 0) {
            a[countN++] = i;
            break; // 跳出循环
        }
    }
    fac(N / i);
}

int main() {
    cin>>M; // 234
    fac(M);
    for (ll i = 0; i < countN; ++i) {
        printf("%d ", a[i]);
    } // 2 3 3 13
    return 0;
}

δ. 结合素数筛的优化

    for (i = 2; i <= N; ++i) {
        if (isPrime(i) && N % i == 0) {
            a[countN++] = i;
            break; // 跳出循环
        }
    }

我们不难发现每次递归的for循环都需要从2到n开始判断i是否为素数，这就出现了许多的重复计算，如果有一个表上面记录着每一个数字是否为素数的信息，我们用的时候只需要查表，而不是调用函数重复的计算，那么我们的效率肯定会变高的，而这个神秘的表就是素数筛（没有接触过的童鞋可以点击传送门来了解）

#include "bits/stdc++.h"

using namespace std;
using ll = long long;
const int maxN = 1e3 + 10;

ll countN = 0;
ll a[maxN], M;
int prime[maxN]; // 将素数从小到大存储起来
bool isPrime[maxN];  // 存储每一个数 true 表示合数
void Prime(int n) {   //埃氏筛
    ll num = 0;
    for (int i = 2; i <= n; i++) {
        if (!isPrime[i]) {
            prime[num++] = i;
        }
        for (int j = 2; j * i <= n; j++) {
            isPrime[j * i] = true;
        }
    }
}

void fac(ll N) {
    if (N == 1) return;
    ll i;
    for (i = 0; prime[i] <= N; i++) { // 直接枚举全部为素数的数，且不大于N
        if (N % prime[i] == 0) {
            a[countN++] = prime[i];
            break;
        }
    }
    fac(N / prime[i]);
}

int main() {
    cin >> M;
    Prime(M);
    fac(M);
    for (ll i = 0; i < countN; ++i) {
        printf("%d ", a[i]);
    }
    return 0;
}

ε. map解法

从小到大枚举素数（i），使 N 一直被 i 整除，直到不能整除，接着 i 增加，i 和 i用的次数保存在map里面，这里有两种map可供选择：map 和 unordered_map，二者不同之处可参考此篇文章---->传送门，我们需要知道的是，unordered_map 内部元素为无序的，但速度快，map内部元素有序，速度比较慢,如果问题中没有要求排序，推荐使用 unordered_map.

#include "bits/stdc++.h"

using namespace std;
using ll = long long;
const int maxN = 1e3 + 10;
ll countN = 0;
ll a[maxN], M;
int prime[maxN]; // 将素数从小到大存储起来
bool isPrime[maxN];  // 存储每一个数 true 表示合数
//unordered_map<ll, ll> UM;
map<ll, ll> UM;

void Prime(int n) {   //埃氏筛
    ll num = 0;
    for (int i = 2; i <= n; i++) {
        if (!isPrime[i]) {
            prime[num++] = i;
        }
        for (int j = 2; j * i <= n; j++) {
            isPrime[j * i] = true;
        }
    }
}

void uMap_solve(ll n) {
    for (ll i = 0; prime[i] <= n; i++) {  //枚举素数表内所有素数
        while (n % prime[i] == 0) {
            UM[prime[i]]++;         //统计 i 的出现次数
            n /= prime[i];
        }
        if (n == 1)
            break;
    }
}

int main() {
    cin >> M;
    Prime(M);
    uMap_solve(M);
//    unordered_map<ll, ll>::iterator iter;
    map<ll, ll>::iterator iter;
    iter = UM.begin();
    while (iter != UM.end()) {
        printf("%lld -> %lld\n", iter->first, iter->second);
        iter++;
    }
    return 0;
}
/*
 *
 * map: 2 -> 1
3 -> 2
13 -> 1
 unordered_map:
 13 -> 1
2 -> 1
3 -> 2
 */