欧拉函数

欧拉函数 Euler' totient function

即 φ(n)，表示 1~n 中 且与n互质的数的个数 ；

---

 

通式：

　　φ(n) = n *  ∏_{质数p | n} （1 - 1 / p) ；

 　即： n = p₁^k1 * p₂^k2 * p₃^k3 * ...... * p_m^km

　　　  φ(n) = n * (1 - 1 / p₁) * (1 - 1 / p₂) * (1 - 1 / p₃) * ...... * (1 - 1 / p_m)

特别地 ：φ(1) = 1；

　　　　当 n 是质数时  φ(n) = n - 1 ；

　　　　当 n 是奇数时  φ(2n) = φ(n) ；

---

 

性质：

• • 欧拉函数是积性函数 ：若 gcd(a, b) = 1 ; 　则 φ(a * b) = φ(a) * φ(b) ； 　　特别地 ：当 n 为奇数时 φ(2n) = φ(n) ； 

　　　　　　积性函数：对于任意互质的整数 a 和 b 有性质 ƒ(a * b) =ƒ(a)  * ƒ(b) ；

　　　　　　完全积性函数：对于任意整数 a 和 b 有性质 ƒ(a * b) = ƒ(a)  * ƒ(b) ；

　　积性函数的性质：

1. 1. •  n = p₁^a1 * p₂^a2 * p₃^a3 * ...... * p_n^an 　　—— n 表示质因数的分解式 ；
      • 若 ƒ 为积性函数 且 n = p₁^a1 * p₂^a2 * p₃^a3 * ...... * p_n^an  ，则 ƒ(n) = ƒ(p₁^a1) * ƒ( p₂^a2)  * ƒ(p₃^a3)  * ...... *ƒ(p_n^an) 
      • 若 ƒ 为积性函数 且有 ƒ(pⁿ)  = ƒ ⁿ(p) ，则 ƒ 为完全积性函数 ；　　
      • 特别地 ： 当 n 为奇数时 ƒ(2n) = ƒ(n) ；　

• • n = ∑_{d | n}  φ(d)  ，∑_{d | n}  φ(d) = n ；
  • 对任意 n > 1 ，1 ~ n 中与 n 互质的数的和为 n * φ(n) / 2 ；
  • 若 n = p ^k ，其中 p 是质数，那么 φ(n) = p ^k  - p ^{k - 1}  =（p - 1) * p ^{k - 1}  ；
  • 设 p 为质数，若 p | n 且 p² | n (p²  是 n 的质数），即：n，n / p 包含相同的质因子，

　　　　　　　　　　　则： φ(n) = φ(n / p) * p ；（φ(n) =  n *  ∏_{质数p | n} （1 - 1 / p) ； φ(n / p) =  (n / p) *  ∏_{质数p | n / p} （1 - 1 / p) ;  则 φ(n) / φ(n / p)  = p)

• • 设 p 为质数，若 p | n 且 p² † n (p²  不是 n 的质数），即：p，n / p 互质，

　　　　　　　　　　　则：φ(n) = φ(n / p) * (p - 1) ；（由积性函数 可得 φ(n) = φ(n / p) * φ(p) ；p 是质数 可得 φ(p) = p - 1）

---

 

模板：

• 求一个数的欧拉函数

 根据欧拉函数的计算公式：φ(n) = n *  ∏_{质数p | n} （1 - 1 / p) ；只需要分解质因数，即可求出欧拉函数

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

• 求2~n 中每个数的欧拉函数　　
  • 利用埃拉托斯托尼筛法（埃氏筛法的核心是：如果 x 是合数，那么 x 的倍数也是合数；合数与质数相对，最小合数是4，1既不是合数也不是质数）　　时间复杂度：O(nlogn)

void euler(int n) {
    for (int i = 2; i <= n; i++) phi[i] = i;
    for (int i = 2; i <= n; i++)
        if (phi[i] == i)
            for (int j = i; j <= n; j += i)
                phi[j] = phi[j] / i * (i - 1);
}

• • 利用线性筛法      时间复杂度：O(n)

　　由性质：

　　　　1.设 p 为质数，若 p | n 且 p² | n (p²  是 n 的质数），即：n，n / p 包含相同的质因子，则： φ(n) = φ(n / p) * p ；

　　　　2.设 p 为质数，若 p | n 且 p² † n (p²  不是 n 的质数），即：p，n / p 互质，则：φ(n) = φ(n / p) * (p - 1) ；

　　在线性筛法中，每个合数 n 只会被它的最小质因子 p 筛一次，可通过上面的两条性质 从 φ(n / p) 递推到 φ(n)

int v[MAX_N], prime[MAX_N], phi[MAX_N];
int m;
void euler(int n) {
    memset(v, 0, sizeof(v)); //标记最小质因子
    m = 0; //质数数量
    for (int i = 2; i <= n; i++) {
        if (v[i] == 0) { //i是质数
            v[i] = i;
            prime[++m] = i; //存储质数
            phi[i] = i - 1;
        }
        //给当前的数i乘上一个质因子
        for (int j = i; j <= m; j++) {
            if (prime[j] > v[i] || prime[j] > n / i) //i有比prime[j]更小的质因子，或者超出n的范围，停止循环
                break;
            v[i * prime[j]] = prime[j]; //prime[j]是合数i*prime[j]的最小质因子
            phi[i * prime[j]] = phi[i] * (i % prime[j] ? prime[j] - 1 : prime[j]); //判断使用上面的性质1还是2

        }
    }
}