分解质因数

大数的质因数分解一直以来是亟需解决的难题。本文从最基本的试除法开始，探讨分解质因数的方法。

下面的程序在开头定义了一个宏OPT，如果删掉这个定义，就可以运行最原始的算法。

一、朴素算法

#include <cstdio>
#include <cstdlib>
#include <cmath>
using namespace std;
#define OPT

int main()
{
    int n;
    for (int num=10000;num<=110000;++num)
    {
        n=num;
        printf("%d=",num);
        #ifndef OPT
        for (int i=2;i<=sqrt(n);)
        {
            if (n%i==0){
                printf("%d ",i);
                n/=i;
            }
            else{
                ++i;
            }
        }
        printf("%d\n",n);
        #endif // OPT

        #ifdef OPT
        //6n+1  6n+5
        //deal with number <=5 first
        for (int i=2;i<=5;)
        {
            if (n%i==0){
                printf("%d ",i);
                n/=i;
            }
            else
                ++i;
        }

        for (int k=1;(6*k+5)<=sqrt(n);)
        {
            while (n%(6*k+1)==0)
            {
                printf("%d ",6*k+1);
                n/=(6*k+1);
            }
            while (n%(6*k+5)==0)
            {
                printf("%d ",6*k+5);
                n/=(6*k+5);
            }
            ++k;
        }
        if (n!=1)
            printf("%d\n",n);
        else
            printf("\n");
        #endif // OPT
    }
    return 0;
}

在上段代码中，核心代码为：

        for (int i=2;i<=sqrt(n);)
        {
            if (n%i==0){
                printf("%d ",i);
                n/=i;
            }
            else{
                ++i;
            }
        }
        printf("%d\n",n);

i为进行尝试的质因子，这里并不需要判断i是否为质数，因为i若是合数，并且满足n%i==0，那么i的质因子在i的前面肯定出现过，其质因子一定已经作为n的质因子除过了，所以也就不会再出现这样一个合数i

以100=2*2*5*5为例，不必要担心4也是100的约数而被误作为质因子。因为100在连续两次除以2后等于25，25是没有4这个因子的。

还有一点需要注意的是最后一行：

        printf("%d\n",n);

不能删去，根据我们的程序，算法结束时的n刚好是最后一个质因子。

二、优化尝试(一)

以上代码的时间复杂度为O( sqrt(n) )，在寻找较大的质因子时，需要以1为步长加上去，这还是比较消耗时间的。

考虑这样的一个数列6n,  6n+1,  6n+2,  6n+3,  6n+4,  6n+5，  其中6n, 6n+2, 6n+3, 6n+4, 都明显地有2, 3等约数，不可能是约数。只有形如6n+1,6n+5的数，才有可能有约数。利用这种思路，我认为可以做到一个常数上的小优化。在开头给出的程序中，宏OPT指明的程序段就是用这种思想编写的。

但是实际测试并非如此，实际测试中，对1万到11万的数进行分解，朴素算法是22.033秒，而所谓的优化算法时间为41.645s，几乎慢了一倍。

可能的原因是我的“优化”写得太复杂了吧。让我进一步挖掘一下。