欧拉函数

欧拉函数：f(n)：1 ~ n 中与 n 互质的数的个数。
互质：两个数的最大公约数为1时，两个数互质。

分解质因数公式：N = a1 ^ p1* a2 ^ p2 * … * ak ^ pk
欧拉函数公式：f(N): N * (1 - 1 / p1)(1 - 1 / p2)…(1 - 1 / pk)

证明：（容斥原理）
1、1 ~ n 去掉 p1,p2,…pk的倍数（不可能互质）
2、加上所有pi * pj的倍数
3、减去所有pi * pj * pk倍数，以此类推，得到公式

代码：

#include<bits/stdc++.h>
using namespace std;

int n,a,res;

int main()
{
    cin>>n;
    while(n -- )
    {
        cin>>a;
        res = a;
        for(int i = 2; i <= sqrt(a); i ++ )//分解质因数
        {
            if(a % i == 0)
            {
                res = res / i * (i - 1);//等于 res *= (1 - (1 / i))
                while(a % i == 0)//但是1 / i是小数，而res是i的倍数，所以上式一定是整数
                a /= i;
            }
        }
        if(a > 1)//
        res = res / a * (a - 1);
        cout<<res<<endl;
    }
    return 0;
}

再来个扩展，求1 ~ n的欧拉函数之和

利用质数的线性筛：
1、当为质数时，euler[i] = i -1.
2、当（i % prime == 0）时， euler[i * prime[j]] = euler[i] * prime[j]，因为prime[j]是i的质因子，所以只需要乘欧拉函数公式前面的 N.
3、当（i % prime[j] != 0）时，euler[i * prime[j]] = euler[i] * (prime[j] - 1)，prime[j]不是i的质因子，但是prime[j] * i 的质因子，所以还要分解出 (1 - 1 / prime[j]).

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const int N = 1e7 + 10;

int pri[N],eul[N],ans,n;
bool st[N];

int main()
{
    cin>>n;
    eul[1] = 1;
    for(int i = 2; i <= n; i ++ )
    {
        if(!st[i])
        {
            pri[ans ++ ] = i;
            eul[i] = i - 1;
        }
        for(int j = 0; pri[j] * i <= n; j ++ )
        {
            st[pri[j] * i] = true;
            if(i % pri[j] == 0)
            {
                eul[pri[j] * i] = eul[i] * pri[j];
                break;
            }
            eul[pri[j] * i] = eul[i] * (pri[j] - 1);
        }
    }
    ll res = 0;
    for(int i = 1; i <= n; i ++ )
        res += eul[i];
    cout<<res;
    return 0;
}