数论——素数筛选法与整数的素因子分解

筛选法   

     求出n以内的素数，最快的应该是筛选法。

 筛选法的思路是：

     要求10000以内的素数，把1-10000都列出来，1不是素数，划掉；2是素数，所有2的倍数都不是素数，划掉；取出下一个幸存的数，划掉它的所有倍数；直到所有素数找完为止。

     这种做法的空间复杂度是O(n)，时间复杂度O(n/logn)。

 1 const int Max = 1000005;
 2 bool prime[Max]={0};//0表示素数，1为非素数
 3 
 4 //筛选n以内的素数
 5 void getPrime(int n)
 6 {
 7     int i,j;
 8     int t;
 9     for(i = 2; i <= n; i++)
10     {
11         if(!prime[i])
12         {
13             for(j = 2; (t=j*i) <= n; j++)
14                 prime[t] = 1;
15         }
16     }
17 }

分解素因子

     唯一质因子分解定理：任意一个合数a仅能以一种方式，写成如下的乘积形式：

a = p1^e1*p2^e2*...*pr^er

    其中pi为素数，p1<p2<...<pr，且ei为正整数。例如数6000=2^4*3*5^3。

    素因子的分解技巧：首先a的某两个素因子不可能同时大于sqrt(a)，这样，先用筛选法求出sqrt(a)以内的所有素数，然后用a依次去mod这些素数，若能整除，则找到素因子，将素因子去掉，再继续找。最后若a>1，则a也是它的素因子。

 1 const int Max = 100005;
 2 int isPrime[Max]={0};
 3 int prime[Max/5],num=0;
 4 int factors[100],s=0;
 5 
 6 void getPrime(int n)
 7 {
 8     int i,j;
 9     int t;
10     for(i = 2; i <= n; i++)
11     {
12         if(!isPrime[i])
13         {
14             prime[num++] = i;
15             for(j = 2; (t=i*j) <= n; j++)
16                 isPrime[t] = 1;
17         }
18     }
19 }
20 
21 void decompose(int n, int* factors)
22 {
23     int te = (int)sqrt(n*1.0);
24     for(int i = 0; i<num&&prime[i]<=te; i++)
25     {
26         if(n%prime[i]==0)
27         {
28             factors[s++] = prime[i];
29             while(n%prime[i]==0)
30                 n = n/prime[i];
31         }
32     }
33     if(n > 1)
34         factors[s++] = n;
35 }