素数表+因式分解+完美数

1 素数

素数即质数，指在大于1的自然数中，除了1和此整数自身外无法被其它自然数整除的数。

1.1 试除法

该方法用于验证一个数是否为素数。例求x是否为素数，只需要验证1到中是否存在一个数位x的约数，即能被x整除。

1.2 Eratosthenes方法

该方法用于高效的求出小于任何数N的所有素数。该方法的原理为先用一个筛子存放所有的数，显然其中最小的为2且为质数，这时可以过滤掉2的任何倍数。紧接着寻找比2大的最小数3，则过滤掉所有3的倍数。如此，比已经找到的质数大的最小数即为素数，然后删除该素数的所有倍数。最终将筛选出所有小于N的素数。

参考代码：

void test()

{

      int prime[PRIMEMAX + 1];

      for (int i = 2; i < PRIMEMAX; i++)

      {

             prime[i] = 1;

      }

      for (int i = 2; i * i <= PRIMEMAX; i++)

      {

             if (1 == prime[i])

             {

                    for (int j = 2 * i; j <=PRIMEMAX; j++)

                    {

                           if (0 == j % i)

                           {

                                  prime[j] = 0;

                           }

                    }

             }

      }

      for (int i = 2; i < PRIMEMAX; i++)

      {

             if (1 == prime[i])

             {

                    cout<<setw(4)<<i;

                    if (0 == i % 16)

                    {

                           cout<<endl;

                    }

             }

      }

}

2 因式分解

这里的因式分解是指将一个数分解成若干个素数乘积的形式。例如12 = 2 * 2 * 3。算数基本定理证明每个大于1的正整数都可以写成素数的乘积，并且这种乘积的形式是唯一的。因此素数也被称为自然数的“建筑的基石”。可以用以下方法分解N。

2.1 试除法

让N去除从1到的任意数，直到商为1则所有的能被整除的数即为N的一项，若某个数能被整除m次，则N的因式中应该还有m个该数。

例如N=12，则：

N=12能整除2，得6……N的一个因子为2

N=6能整除2，得3……N的一个因子为2

N=3能整除3，得1……N的一个因子为3

因为商为1，则停止运算可得N=12=2*2*3为N的因式分解。

2.2 素数表法

试除法存在的问题为不是所有的被除数都为素数，例如N=30，当整除2和3后，又去试除4，显然这是没有必要的。因此可以预处理一张素数表，继2和3之后去试除5而不再是4。

参考代码如下：

#define MAXNUM110000

int num1;

intprimetable[MAXNUM1];

void prime()

{

      int temp[MAXNUM1];

      int genprime = 0;

      for (int i = 0; i < MAXNUM1; i++)

      {

             temp[i] = 1;

             primetable[i] = 1;

      }

      for (int i = 2; i < MAXNUM1; i++)

      {

             if (1 == temp[i])

             {

                    primetable[genprime++] = i;

                    for (int j = 2*i; j <MAXNUM1; j++)

                    {

                           if (0 == j % i)

                           {

                                  temp[j] = 0;

                           }

                    }

             }

      }

}

 

void factor()

{

      int num = num1;

      cout<<num<<" = ";

      for (int i = 0; primetable[i] *primetable[i] <= num;)

      {

             if (0 == num % primetable[i])

             {

                    cout<<primetable[i]<<"*";

                    num = num / primetable[i];

             }

             else

             {

                    ++i;

             }

      }

      cout<<num<<endl;

}

int main()

{

      prime();

factor();

}

3 完美数

如果一个数n，其真约数（比n小的约数）的总和等于n，则称之为完美数。例如6 = 1 + 2 + 3，28 = 1 + 2 + 4 + 7 + 14。

3.1 朴素法

求出数n的所有真约数，然后相加判断是否与n相等即可，若相等则是完美数，反之不是。

3.1 因式分解法

由算数基本定理可得任何数n均可分解为若干素数的乘积，而一个数的所有约束应该为所有这些约数的组合和1。例如n=12=2*2*3的分解素数为2、2以及3，他们的组合数为2、4、6、12，显然与1一起组成了n=12的所有约束。若n为完美数则有n分解的素数的所有组合数的和加上1为n的2倍。例如：

2 * 28 = 1 + 2 + 4 + 7 + 14 + 28 = （2⁰ + 2¹ + 2²）*（7⁰ + 7¹）

显然等式的右边为用n=28的分解成的素数组成，即若某一个素数x有m个，则组合数中可以包含0、1……m个，对约数的贡献分别为x⁰, x¹……x^m。

完美数的求解总共分为三步：

(1) 求出一定数目的素数表

(2) 利用素数表求指定数的因式分解

(3) 利用因式分解求所有真约数和，并判断是否为完美数

参考代码：

 

#define N 1000

#define P 10000

 

int prime(int*pNum)

{

      int i, j;

      int prime[N+1];

      for(i = 2; i <= N; i++)

             prime[i] = 1;

      for(i = 2; i*i <= N; i++)

      {

             if(prime[i] == 1)

             {

                    for(j = 2*i; j <= N; j++)

                    {

                           if(j % i == 0)

                                  prime[j] = 0;

                    }

             }

      }

      for(i = 2, j = 0; i < N; i++)

      {

             if(prime[i] == 1)

                    pNum[j++] = i;

      }

      return j;

}

 

int factor(int*table, int num, int* frecord)

{

      int i, k;

      for(i = 0, k = 0; table[i] * table[i]<= num;)

      {

             if(num % table[i] == 0)

             {

                    frecord[k] = table[i];

                    k++;

                    num /= table[i];

             }

             else

             i++;

      }

      frecord[k] = num;

      return k+1;

}

 

int fsum(int*farr, int c)

{

      int i, r, s, q;

      i = 0;

      r = 1;

      s = 1;

      q = 1;

      while(i < c)

      {

             do

             {

                    r *= farr[i];

                    q += r;

                    i++;

             } while(i < c-1 &&farr[i-1] == farr[i]);

             s *= q;

             r = 1;

             q = 1;

      }

      return s / 2;

}

 

int main(void)

{

      int ptable[N+1] = {0}; // 储存质数表

      int fact[N+1] = {0};     // 储存因式分解结果

      int count1, count2, i;

      count1 = prime(ptable);

      for(i = 0; i <= P; i++)

      {

             count2 = factor(ptable, i, fact);

             if(i == fsum(fact, count2))

             printf("Perfect Number:%d\n", i);

      }

      printf("\n");

      return 0;

}