欧拉函数，广义欧拉定理

讲解博客

欧拉定理

如果 $a$ 与 $n$ 互质，$a^{\phi (n)}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}n)$，$\phi (n)$ 是 $n$ 欧拉函数

威尔逊定理

$p$ 是质数时，$(p-1)!\equiv 1\equiv -1(\mathrm{m}\mathrm{o}\mathrm{d}n)$，$(p-2)!\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}n)$
等价于，如果 $p$ 是质数，则 $((p-1)!+1)\%p=0$
$n$ 是质数，$(n-1)!\%n=1$
$n$ 是合数，除 $n=4$ 以外，$(n-1)!\%n=0$

欧拉函数

就是对于一个正整数 $n$，满足 $x<n(x\in [1,n)$ 且 $gcd(n,x)=1$ （包括 $1$）的 $x$ 的个数，记作 $\phi (n)$。
欧拉函数通式：
$$\phi (x)=x\ast \prod _{i=1}^n(1-\frac{1}{p_i})$$
其中 $p1,p2\dots \dots pn$ 为 $n$ 的所有质因数，$n$ 是不为 $0$ 的整数。$\phi (1)=1$（唯一和 $1$ 互质的数就是 $1$ 本身）。

性质：

1. 对于质数 $p$， $\phi (p)=p-1$。注意 $\phi (1)=1$
2. 若 $m,n$ 互质，$\phi (mn)=\phi (m)\ast \phi (n)$
3. 若 $p$ 为质数且 $i\mathrm{m}\mathrm{o}\mathrm{d}p=0$, 那么 $\phi (i\ast p)=\phi (i)\ast p$
4. 当 $n$ 为奇数时，$\phi (2n)=\phi (n)$
5. 当 $n>2$ 时，所有 $\phi (n)$ 都是偶数
6. 当 $n>6$ 时，所有 $\phi (n)$ 都是合数
7. 欧拉定理：对于互质的正整数 $a$ 和 $n$ ，有 $a^{\phi (n)}\equiv 1\mathrm{m}\mathrm{o}\mathrm{d}n$
8. 费马小定理：若 $p$ 是质数，则 $a^{p-1}\equiv 1\mathrm{m}\mathrm{o}\mathrm{d}p$
9. 欧拉定理推论：小于等于 $n$ 的数中，与 $n$ 互质数的加和为：$\phi (n)\ast \frac{n}{2}(n>1)$

事实上，根据性质 $2,3$ ，结合唯一分解定理，我们可以推出一个结论
先说说推导过程
根据唯一分解定理：$n=p_1^{q_1}{p}_2^{q_2}{p}_3^{q_3}...p_n^{q_k}$
结合性质 $2$ 可以得到 $\phi (n)=\phi (p_1^{q_1})\phi (p_2^{q_2})\phi (p_3^{q_3})...\phi (p_n^{q_k})$
因为 $p_1^{q_1}=p_1\ast p_1^{q_1-1}$，显然符合性质 $3$，$p_1$ 是质数， 并且 $p_1\%p_1=0$
因此 $\phi (p_1^{q_1})=\phi (p_1^{q_1-1})\ast p_1=\phi (p_1^{q_1-2})\ast p_1^2=...=\phi (p_1)\ast p_1^{q_1-1}=(p_1-1)\ast p_1^{q_1-1}$

求一个数的欧拉函数

$O(sqrt(n))$
code：

//直接求解欧拉函数  
  int euler(int n){ //返回euler(n)   
       int res = n, a = n;  
       for(int i = 2; i * i <= a; ++i){  
           if(a % i == 0){  
               res = res / i * (i - 1);//先进行除法是为了防止中间数据的溢出   
               while(a % i == 0) a /= i;  
           }  
       }  
      if(a > 1) res = res / a * (a - 1);  
      return res;  
}

求1~n每个数的欧拉函数

普通筛法： $O(nlogn)$
code：

void Init(){     
     euler[1] = 1;    
     for(ll i = 2; i < maxn; ++i)    
        if(!euler[i])    
           for(ll j = i; j < maxn; j += i){
           	if(!euler[j]) euler[j] = j; 
            euler[j] = euler[j] / i * (i - 1);//先进行除法是为了防止中间数据的溢出
		   }	
}

线性筛法：
类似与筛素数，我们在这里利用欧拉函数是积性函数这个性质来筛 $\phi (n)$
这个筛法比上边快好几倍，$maxn$ 开 $1e7$ 秒出结果
线性筛法证明
code：

int cnt;
int prime[maxn],phi[maxn];
bool vis[maxn];
void Euler_sieve (int n)
{
	phi[1] = 1;
	for (int i = 2; i <= maxn - 9; ++i){
		if (!vis[i])	prime[++cnt] = i, phi[i] = i - 1;
		for (int j = 1; j <= cnt && i * prime[j] <= maxn - 9; ++j){
			vis[i * prime[j]] = true;
			if (i % prime[j] == 0){	phi[i * prime[j]] = phi[i] * prime[j];break;}
			phi[i * prime[j]] = phi[i] * phi[prime[j]];
		}
	}
} 

欧拉定理

内容：对任意两个正整数 $a,n$，若两者互质，则：$a^{\phi (n)}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}n)$。
注：作为对比，费马小定理$（a^{p-1}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}p)$，其中 $p$ 为质数），实际上就是欧拉公式的特殊情况。

欧拉降幂(广义欧拉定理)

引出：求解 $a^b\mathrm{m}\mathrm{o}\mathrm{d}p$，对于一定范围内我们可以利用快速幂求解，但是，当b大到一定程度时，利用快速幂这样的算法是无法在给定时间内求解的。
这时我们引入欧拉降幂算法，这个算法的特点就是降低幂方的值而不影响最终结果，使我们解决问题的时间缩短。

欧拉降幂公式：（无互质要求）
$$a^b\mathrm{m}\mathrm{o}\mathrm{d}p=\{\begin{array}{l}{a}^b，b<\phi (p)\\ \\ a^{b\mathrm{m}\mathrm{o}\mathrm{d}\phi (p)+\phi (p)}，b>=\phi (p)\end{array}$$
利用欧拉降幂公式求exponial(n）

洛谷模板题
$b$ 的指数部分可以边乘边模，最后对 $a^b$ 快速幂即可
$isdigit()$ 函数的作用检查参数是否为十进制数字字符
code：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll a, b, m;
inline ll read(ll m){
	register ll x = 0, f = 0;
	char ch = getchar();
	while(!isdigit(ch)) ch = getchar();
	while(isdigit(ch)){
		x = x * 10 + ch - '0';
		if(x >= m) f = 1;
		x %= m; ch = getchar();
	}
	return x + (f == 1 ? m : 0);
}
ll phi(ll x)
{
	ll ans = x;
	for(ll i = 2; i * i <= x; ++i)
	{
		if(x % i == 0)
		{
			ans = ans / i * (i - 1);
			while(x % i == 0) x /= i;
		}
	}
	if(x > 1) ans = ans / x * (x - 1);
	return ans;
}
ll q_pow(ll a, ll n, ll mod){
	ll ans = 1;while(n){
		if(n & 1) ans=ans*a%mod;n>>=1;a=a*a%mod;
	}return ans;
}
int main()
{
	cin >> a >> m;
	b = read(phi(m));
	cout << q_pow(a, b, m);
	return 0;
}

上帝与集合的正确用法
题意：
输入一个数 $p$，求 $f(p)=2^{2^{2^{2^{...}}}}\mathrm{m}\mathrm{o}\mathrm{d}p$，指数部分无限迭代
题意：
求 $f(p)=2^{2^{2^{2^{...}}}}\mathrm{m}\mathrm{o}\mathrm{d}p$，指数无限下去
思路：
当 $b>=\phi (p)$ 时， $a^b=a^{b\%\phi (p)+\phi (p)}\%p$，因为指数无限迭代，显然满足公式
于是我们可以设 $f(p)=2^{2^{2^{2^{...}}}}\mathrm{m}\mathrm{o}\mathrm{d}p$，那么有$f(1)=0$
所以 $f(p)=2^{2^{2^{2^{...}}}}\mathrm{m}\mathrm{o}\mathrm{d}p=2^{(2^{2^{2^{...}}}\%\phi (p)+\phi (p))}\mathrm{m}\mathrm{o}\mathrm{d}p=2^{f(\phi (p))+\phi (p)}\mathrm{m}\mathrm{o}\mathrm{d}p$
接下来就把欧拉定理和快速幂的板子套上就可以了
注意这个题的指数部分始终是无穷大，指数部分 $b$ 与 模数的 $\phi (p)$ 的关系是一定的，不用考虑变化。
code：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
 
ll ph(ll x)
{
    ll res=x,a=x;
    for(ll i=2;i*i<=x;i++)
    {
        if(a%i==0)
        {
            res=res/i*(i-1);
            while(a%i==0) a/=i;
        }
    }
    if(a>1) res=res/a*(a-1);
    return res;
}

ll quick_pow(ll a,ll b,ll mod)
{
    ll ans=1;
    while(b)
    {
        if(b&1) ans=(ans*a)%mod;
        a=(a*a)%mod;
        b>>=1;
    }
    return ans;
}

ll f(ll p)
{
    if(p == 1) return 0;
    ll k = ph(p);
    return quick_pow(2, f(k) + k, p);
}
 
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        ll p;scanf("%lld",&p);
        printf("%lld\n",f(p));
    }
    return 0;
}

简单数据结构1
思路：
树状数组（区间修改，单点查询）+欧拉降幂
欧拉降幂大约递归 $log$ 次
注意指数 $b$ 和模数 $p$ 的关系不同时，对其的操作也不同。
考虑到欧拉降幂使用的条件，进行快速幂取模时不能直接用 $\%mod$，应使用下边的取模操作

inline ll Mod(ll x, ll mod)
{
	return x < mod ? x : x % mod + mod;
}

code：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 2e7 + 9;
ll n, m;
int phi[maxn], cnt, p[maxn];
bitset <maxn> v;
int op, l, r, P;
void init(int n)
{
	phi[1] = 1;
	for(ll i = 2; i <= n; ++i)
	{
		if(!v[i]) p[++cnt] = i, phi[i] = i - 1;
		for(ll j = 1; j <= cnt && i * p[j] <= n; ++j)
		{
			v[i * p[j]] = 1;
			if(i % p[j] == 0){
				phi[i*p[j]] = phi[i] * p[j];break;
			}
			phi[i*p[j]] = phi[i] * phi[p[j]];
		}	
	}return;
}

ll tr[maxn];
inline void add(int i, ll k){
	while(i <= n) tr[i] += k, i += i & (-i); 
}
inline ll query(int i, ll ans = 0){
	while(i) ans += tr[i], i -= i & (-i);return ans;
}
inline ll Mod(ll x, ll mod){
	return x < mod ? x : x % mod + mod;
}
ll q_pow(ll a, ll n, ll mod, ll ans = 1){
	a = Mod(a, mod);
	while(n){
		if(n & 1) ans=Mod(ans*a, mod);a=Mod(a*a,mod);n>>=1;
	}return ans;
}

inline ll f(int l, int r, int p)
{
	ll b = query(l);
	if(p == 1 || l == r) return b < p ? b : b % p + p;
	return q_pow(b, f(l + 1, r, phi[p]), p);
}

void work()
{
	cin >> n >> m;
	for(int i = 1; i <= n; ++i){
		ll x;cin >> x;add(i,x);add(i+1,-x);
	}
	while(m--)
	{
		cin >> op >> l >> r >> P;
		if(op == 1) add(l, P), add(r + 1, -P);
		else cout << f(l, r, P) % P << "\n";
	}
}

int main()
{
	ios::sync_with_stdio(0);
	init(2e7);
	work();
	return 0;
}