数论之素数，包括eratosthenes算法，欧拉函数

一，素数

素数又称质数，有无限个。除了1和它本身以外不再有其他的除数整除。

算术基本定理:每个大于1的自然数均可写为质数的积，而且这些素因子按大小排列之后，写法仅有一种方式。

例如：6936=2^3*3*17^2，1200=2^4*3*5^2。

二，质因数的分解

概念：把一个合数用素因数相乘的形式表示出来，叫做质因数分解。（注意：由于任何一个合数n至多会有一个大于根号n的因子）

一般我们用短除法分解素因数，算法步骤如下：

1.先用一个能整除这个合数的素数（通常从最小的开始）去除。

2.得出的商如果是合数，再按照上面的方法继续除下去，直到得出的商是素数为止。

3.然后把各个除数和最后的商按从小到大的顺序写成连乘的形式。

代码如下：cnt=0; //cnt表示素因子的个数

for(int i=2;i*i<=n;i++)//由于任何一个合数至多或有一个大于根号n的因子

{

        if(n%i==0)

        {

            ++cnt;

            p[cnt]=i;//p数组存的是素因子

            num[cnt]=0;//存的是每个素因子的指数

            while(n%i==0)

            {

                ++num[cnt];

                n/=i;

            }//while循环的目的是每次历经一个i，n都会进行更新，或者是有多个i，n也会进行更新

        }

}

    if(n>1)

    {

        ++cnt;

        p[cnt]=n;

        num[cnt]=1;

    }需要if循环的原因也是因为由于任何一个合数至多或有一个大于根号n的因子(例如n=10)

三，素数的测试

1，一般的思路

bool divisibiity_test(int n)

{

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

        if (n % i == 0)

            return false;   // 不是质数

    return true;    // 是质数

}

2，改进的方法

bool divisibiity_test(int n)

{

//一个数至少有一个比sprt(n)小的质因数。

      for (int i=2; i<=sqrt(n); i++)

        if (n % i == 0)

            return false;

    return true;

}

时间复杂度：O(sqrtN)

四，Eratosthenes筛法

代码如下：

1，

bool prime[20000000];

void eratosthenes()

{

    memset(prime,1,sizeof(prime));

    prime[0] = 0;  prime[1] = 0;  // 0 和 1 不是质数

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

        if (prime[i]==1) // 删掉质数i的倍数

           for (int j=i+i; j<20000000; j+=i)

                prime[j] = 0;

}

2，优化的如下：(优化的原因：删掉质数 i 的倍数时，早已删掉1 倍~ i-1 倍之间的合数了，所以直接从i倍开始删除)。

void eratosthenes(){

    memset(prime,1,sizeof(prime));

    prime[0] = 0;prime[1] = 0;

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

        if (prime[i]==1)

      //删掉i的倍数从i倍开始。

            for (int j=i*i; j<20000000; j+=i)

                prime[j] = 0;

}

五，欧拉函数

1.定理：

对正整数n，欧拉函数φ(phi)指是小于n的所有数中与之互质的个数(包含1)。如φ(8)=4，因为1,3,5,7均和8互质

2.表达形式：n=p1^a1*p2^a2....pk^ak(p1,p2...pk是素数)

3，计算公式：φ(n)=n*(1-1/p1)*(1-1/p2)*......*(1-1/pk)

例如：φ(8)=4有1,3,5,7，8=2^3， φ(8)=8*(1-1/2)=4.

     φ(10)=4有1,3,7,9 ，10=2*5，φ(10)=10*(1-1/2)*(1-1/5)=4.

4,性质：

a)当p为质数时, φ(p) = p – 1。

    证明：因为小于本身的数都与该数互质，但是注意φ(1)=1.

  b)对于互质的正整数a和n,有a^φ(n) ≡ 1 (mod n) (mod n的意思是两边同时%n).

  c)费马小定理：若正整数a 与素数p 互质，则有a^(p - 1)≡1 mod p。

    证明:由于性质a可知当p为质数，φ(p) = p -1，代入性质b即可证明。

d)当n为奇数时φ(2n)=φ(n).

  e)当n和m互质时,φ(n*m)=φ(n)*φ(m).

  f)若n=p^k(p为质数),φ(n)=p^k-p^(k-1).

    证明：因为除了p的倍数外,其他数都跟n互质。

朴素算法实现：

1.根据公式1：n=p1^k1*p2^k2*…*pr^kr和公式2：φ(n)=n* (1-1/p1) *…* (1-1/pr)。

2.可将公式2可拆成n* (1-1/p1)=n-n/p1计算。

代码实现：

int euler(int n)

{

    int i,ans=n;

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

        if(n%i==0)

        {

            ans=ans-ans/i;

            do

                n/=i;//把该素因子全部约掉

            while(n%i==0);

        }

    if(n>1)

        ans=ans-ans/n;

    return ans;

}

例题：

1286.有多少素数

Time Limit: 1000 MS    Memory Limit: 32768 KB

Total Submission(s):
319    Accepted Submission(s):
44

Description

给你很多的正整数，只是为了找出有多少素数。

Input

有很多的测试用例，每个测试用例第一行是正整数N，表示要从N个整数中找。每个整数不超过2147483647，其中每个不小于2。

Output

对于每种情况输出素数的个数。

Sample Input

3
2 3 4

Sample Output

2

(已经AC过的代码)

#include<cstdio>

#include<iostream>

#include<cmath>

using namespace std;

int IsPrimeNumber(int n)

{

    if (n==2)

    {

        return true;

    }

    if (n%2==0)

    {

        return false;

    }

    int sqrtn=(int)sqrt((double)n);

    bool flag=true;

    for (int i=3; i<=sqrtn; i+=2)

    {

        if (n%i==0)

        {

            flag=false;

        }

    }

    return flag;

}

int main()

{

    int m,n,x;

 while(scanf("%d",&m)!=EOF)

    {

        int sum=0;

        for(int k=0; k<m; k++)

        {

            scanf("%d",&n);

            x=IsPrimeNumber(n);

            if(x)

                sum++;

        }

        cout<<sum<<'\n';

    }

    return 0;

}