素数

素数就是质数，在大于1的自然数中，除了1和它本身以外，不能被任何数整除

 

唯一分解定理： 一个数要么其本身是质数，要么可以分解为几个质数之积。

 

对于一个正整数X(除1外)都有这样一个式子

(p是素因子，a是素因子的个数)

 

判断素数

• 素数 朴素算法（复杂度O(n)）：

  int flag=0
  for(int i=2;i<=n;i++){
      if(x%i) {
          flag=1;
          break;
      }
  }

   

• 进阶版：复杂度（复杂的O(√n)）

int flag=0
for(int i=2;i<=n;i++){
    if(x%i) {
        flag=1;
        break;
    }
}

素数筛法

• 朴素算法：复杂度nlog(n)

  int prim[MAXN];
  bool flag[MAXN]
  for(int i=2;i<MAXN;i++){
      if(flag[i]==false){
          prim[++prim[0]]=i;
          for(int j=i+i;j<=MAXN;j+=i){
              flag[j]=true;
          }
      }
  }

   

• 线性筛: 复杂度 O(n)

  vector prim;
  bool flag[MAXN]={false};
  for(int i=2;i<MAXN;i++){
      if(flag[i]==false) {
          prim.push_back(i);
      }
      for(int j=1;j<prim.size();j++){
          if(i*prim[j]>MAXN) break;
          flag[i*prim[j]]=true;
          if(i%prim[j]==0) break;
      }
  }

   

  if(i%prim[j]==0) break; 因为此时i和prim[j]说明i包括了prim[j]的所有质因子。若prime[j]在这个合数里只出现一次（i%prime[j]!=0）,也就是prime[j]在这个合数里出现了不止一次。

  举个例子，当i=4时，prim[1]=2，prime[2]=3，内层循环首先筛掉了4*prim[1]=8，这时候4%2==0，应该跳出循环，如果不跳出循环的话，下一次会筛掉4*prime[2]=12，然而这样是没有必要的，因为12会在i=6时被筛掉。也正因为这个语句，欧拉筛素数不会有重复的情况。在线性复杂度内可以完成。

   

欧拉函数

某个数的欧拉函数即为小于它且和它互质的数的个数

例如φ(8)=4，因为1,3,5,7均和8互质。

1~8有：φ(1)=1， φ(2)=1， φ(3)=2， φ(4)=2， φ(5)=4， φ(6)=2， φ(7)=6， φ(8)=4

p1,p2...pn为x的所有质因数

例如x=12，12的质因数有P(2,3)；12以内有1/2的数是2的倍数，1/3的数是3的倍数；（1-1/2）不是2的倍数，（1-1/3）不是3的倍数，（1-1/2）*（1-1/3）既不是2也不是3的倍数。故1-1/2）*（1-1/3）个数y，当y/12-->y/2*3时候化简，即与12互质

• 用辗转相除法求两个数的最大公共质因数

  int gcd(int a,int b){
      return b==0 ? a: gcd(b,a%b); 
  }

   

  若返回值为1，则两个数互质

  • 欧拉函数 朴素算法 O(n)

    int oula(int n){
        int rea=n;
        for(int i=2;i<=n;i++){
            if( n%i==0 ){
                rea=rea-rea/i;
                do{
                    n/=i;
                }
                while(n%i==0);
            }
        }
        return rea;
    }

int oula_youhua(int n){
    int rea=n;
    for(int i=2;i*i<=n;i++){
        if(n%i==0){
            rea=rea-rea/i;
            do{
                n/=i;
            }while(n%i==0)
        }
    }
    if(n>1) rea=rea-rea/n;
    return rea;
}

 

• 欧拉欧拉线性筛：复杂度O(n)

int prim[MAXN];
bool flag[MAXN]={false};
int  phi[MAXN];
for(int i=2;i<MAXN;i++){
    if(flag[i]==false) {
        prim[++prim[0]]=i;
        phi[i]=i-1;
    }
    for(int j=1;j<=prim[0];j++){
        if(i*prim[j]>MAXN) break;
        flag[i*prim[j]]=true;
        if(i%prim[j]==0) {
            phi[i*prim[j]]=phi[i]*prim[j];
            break;
        }
        else{
            phi[i*prim[j]] = phi[i]*phi[prim[j]];
        }
    }
}

 

gcd(i,n) =x gcd(i/x,n/x)=1 ;

oula(n/x)个gcd(i,n)=x的i gcd之和为x*oula(n/x)

x的所有因数的欧拉数和因数的乘积之和

gcd(x,n)=i （1<=i<=n）求gcd之和

对于一个gcd（x/i,n/i）=1,则x/i和n/i互质 。因为x,n的最大公约数为i，同除i后，两者最大公约数为1了。此时n/i与互质的x/i，就是为除i之前,与n最大公约数为i的 用oula(n/i) 就可以求得满足的x的个数 oula(n/i)*i即为gcd之和

 

 

习题 POJ2480

Longge is good at mathematics and he likes to think about hard mathematical problems which will be solved by some graceful algorithms. Now a problem comes: Given an integer N(1 < N < 2^31),you are to calculate ∑gcd(i, N) 1<=i <=N. 

"Oh, I know, I know!" Longge shouts! But do you know? Please solve it. 

Input

Input contain several test case. 
A number N per line. 

Output

For each N, output ,∑gcd(i, N) 1<=i <=N, a line

Sample Input

2
6

Sample Output

3
15

题意：输入n，计算x属于1-n ,gcd(x，n)之和。
题解：gcd(X,n)==i. 即gcd(x/i,n/i)*i之和
首先枚举i，i必须是n的因素.gcd(x/i,n/i)==1，这些x/i与n/i互质，即求phi(n/i),即为满足条件的x的个数.phi(n/i)*i,即为这些gcd(x,n)==i之和.
c++代码

#include<iostream>
using namespace std;
typedef long long ll;
const  ll N=100000;
ll phi[N];
ll prim[N];
bool flag[N]={false};
int getPhi(int x) {
    int rea = x;
    for (ll i = 2; i * i <= x; i ++) {
        if(x % i == 0) {
            rea = rea - rea / i;
            do{
                x /= i;
            }while(x % i == 0);
        }
    }
    if(x > 1) 
        rea = rea - rea / x;
    return rea;
}
int main(){

    int n;
    while(cin>>n){
        ll ans=0;
        for(ll i=1;i*i<=n;i++){
            if(n%i==0) {
                ans+=i*getPhi(n/i);
                if(i*i!=n){
                    ans+=(n/i)*getPhi(i);
                }
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/jjl0229/p/11298924.html