算法：完美数

转载请注明出处：http://blog.csdn.net/awebkit

感谢

http://qiuchixue.blogspot.fr/2006/10/knuthperfect-number.html 

http://blog.csdn.net/wall_f/article/details/8463652

先介绍一下什么是 完美数

一个数，它的所有小于或等于它自身的因子(包括1)之和=这个数
例如：
6=1+2+3 =2^1(2^2-1)=1+...+(2^2-1)
28=1+2+4+7+14 =2^2(2^3-1)=1+...+(2^3-1)
496=1+2+4+8+16+31+62+124+248 =2^2(2^5-1)=1+...+(2^5-1)
注意到后面的指数2,3,5都是质数。

研究完美数，一般要研究到梅森素数
完美数和梅森素数紧密关联。Mersenne primes(梅森素数):
M_p = 2^p - 1 ,如果要使得M_p为素数，p必须为素数。但这是必要条件，例如p=11时，M_p不是梅森数，因为2^11-1不是素数。
完美数和梅森素数之间的关系如下。如M_p = 7，可得P＝28是完美数
P = 1/2(M_p+1)M_p = q*(2^(p-1)) = (2^p-1)(2^(p-1))

2*28 = (2*2)*(7) = (2^0 + 2^1 + 2^2)(7^0 + 7^1)

根据上面的公式，我们可以看到完美数和素数以及素数的个数相关

因此，我们能得到第一个求解完美数的算法，如下代码perfect1（这是错误的，但却是网上流传最广的，如4会被打印，但4不是完美数）

对于数学功底很强的人，我们可以继续看公式

一个2^p-1是否梅森素数的测试方法：
Lucas-Lehma 测试(Ref:Knuth vol2,4.5.4 (24), maybe P.391)
定理: 设q是一个奇素数，用下面的规则定义序列:
L[0]=4, L[n+1]=(L[n]^2 - 2) mod (2^q-1)
那么 2^q-1 是(梅森)素数，当且仅当 L[q-2]=0.

#include <stdio.h>
#include <stdlib.h>
#define N 1000
#define P 100000
int prime(int*); // 求质数表
int factor(int*, int, int*); // 求factor
int fsum(int*, int); // sum ot proper factor

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;
}

void perfect1()
{
    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");
}

typedef long long LL;
LL data[70];
/*
 * Mul和Mul2的功能应该是一样的。只是
 * Mul考虑到了大数相乘的问题吧
 */
LL Mul(LL a, LL b, LL m)
{
    LL ans = 0;
    while(b)
    {
        if(b & 1)
            ans = (ans + a) % m;
        a = (a*2)%m;
        b /= 2;

    }
    return ans;
}

LL Mul2(LL a, LL b, LL m)
{
    return a * b % m;
}

int Lucas_Lehmer(int p)
{
    LL MOD = (1LL<<p)-1;
    data[1] = 4;
    for(int i = 2; i <= p-1; i++)
    {
        LL ans = Mul(data[i-1], data[i-1], MOD);
        data[i] = (ans-2) % MOD;
    }
    if(data[p-1] == 0) return 1;
    return 0;
}

void perfect2()
{
    for(int i = 0; i <= 62; i++) {
        if (Lucas_Lehmer(i)){
            int meson = pow(2,i) - 1;
            int num = meson * (meson + 1) / 2;
            printf("meson num %d perfect number %d\n", i, num);
        }
    }
}

int main(void)
{

    //perfect1();
    perfect2();
    return 0;
}