欧拉函数

2014 六月

10

原

lightoj 1007 欧拉函数

分类：模版--------------------数论

（388） （0）

公式推导转自：

点击打开链接

此题是关于欧拉函数的简单数论题，首先我们先来看看欧拉函数（也称 φ函数）：

　　

          欧拉函数： 对于给定正整数 n ，少于或等于n的数中与n互质的数的数目。

　　　　　　　　　　　　若n是质数p的i次幂，φ(n)=p^i - p^(i-1)=(p-1)*p^(i-1) (解题关键)，因为除了p的倍数外，其他数都跟n互质。

　　　　　　　　　　　　设n为正整数，以 φ(n)表示不超过n且与n互素的正整数的个数，称为n的欧拉函数值，这里函数

　　　　　　　　　　　　　　φ：N→N，n→φ(n) 称为欧拉函数。

　　　　　　　　　　　欧拉函数是积性函数——若m,n互质，φ(mn)=φ(m)φ(n) [积性函数的形式]。

　　　　　　　　　　　特殊性质：当n为奇数时，φ(2n)=φ(n), 证明与上述类似

    

　　根据欧拉函数，对于给定的 n ，我们总能找到小于 n 的（当 n 为素数时， 等于 n ）素数 p1, p2, ··· , pN, 使得

　　　　　　　　n = (p1 ^ a1) * (p2 ^ a2) * ···· * (pN ^ aN);

　　　　　　所以，

　　　　　　　　φ(n)=φ(p1 ^ a1) * φ(p2 ^ a2) * ··· * φ(pN ^ aN)

 　　　　　 所以，

　　　　　　　　φ(n) = ((p1 - 1)* p1^(a1 - 1)) * ((p2 - 1)* p2^(a2 - 1)) * ··· * ((pN - 1)* pN^(aN - 1))

 　　　　

　　

　　首先，我们假设与 n 互质的数(小于 n ) 有 n 个， 事实上它有 φ(n) 个， 我们可以寻找 n 与 φ(n) 的关系来求解：

　　　　　　   n / φ(n) = (p1 * p2 * ··· * pN) / ((p1-1) * (p2-1) * ··· *(pN-1))

 　　　　所以，

　　　　　　　 φ(n) = (n * (p1-1) * (p2-1) * ··· *(pN-1)) / (p1 * p2 * ··· * pN);

　　　　　　即：

　　　　　　　 φ(n) = n * ((p1-1) / p1) * ((p2-1) / p2) * ··· * ((pN-1) / pN);

AC代码如下：

[cpp] view plain copy

print ?

1. #include <iostream>  
2. #include <cstring>  
3. #include <cstdio>  
4. #include <algorithm>  
5. using namespace std;  
6.   
7. const int MAX_N = 5000005;  
8.   
9. unsigned long long num[MAX_N];  
10.   
11. void init(){  
12.     memset( num, 0, sizeof( num ) );  
13.     for( int i = 2; i < MAX_N; i++ ){  
14.         if( num[i] == 0 ){  
15.             for( int j = i; j < MAX_N; j += i ){  
16.                 if( num[j] == 0 )   num[j] = j;  
17.                 num[j] = num[j] / i * ( i - 1 );  
18.             }  
19.         }  
20.     }  
21.     for( int i = 2; i < MAX_N; i++ ){  
22.         num[i] = num[i] * num[i] + num[i-1];  
23.     }  
24. }  
25.   
26. int main(){  
27.     int a, b, T, Case = 1;  
28.   
29.     init();  
30.   
31.     cin >> T;  
32.     while( T-- ){  
33.         scanf( "%d%d", &a, &b );  
34.         printf( "Case %d: %llu\n", Case++, num[b] - num[a-1] );  
35.     }  
36.     return 0;  
37. }  

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;

const int MAX_N = 5000005;

unsigned long long num[MAX_N];

void init(){
    memset( num, 0, sizeof( num ) );
    for( int i = 2; i < MAX_N; i++ ){
        if( num[i] == 0 ){
            for( int j = i; j < MAX_N; j += i ){
                if( num[j] == 0 )   num[j] = j;
                num[j] = num[j] / i * ( i - 1 );
            }
        }
    }
    for( int i = 2; i < MAX_N; i++ ){
        num[i] = num[i] * num[i] + num[i-1];
    }
}

int main(){
    int a, b, T, Case = 1;

    init();

    cin >> T;
    while( T-- ){
        scanf( "%d%d", &a, &b );
        printf( "Case %d: %llu\n", Case++, num[b] - num[a-1] );
    }
    return 0;
}

文章列表