HDU5728 PowMod（积性函数+扩欧）

HDU5728 PowMod（积性函数+扩欧）

（本题解由 ljw 提供 ）

题面

题意：定义$k={\sum }_{i=1}^m\phi (i\ast n)mod1000000007$，且$n$是一个无平方因子数，$\phi (n)$是欧拉函数，计算$ans=k^{k^{k^{k^{..{.}^k}}}}modp$

范围：$1\le n,m,p\le 10^7$

分析：欧拉函数简介：

$\phi (n)$是欧拉函数，意义为在$1-n$的范围内，与$n$互质的数有多少个，例如$\phi (2)=1,\phi (4)=2$.

那么很容易可以发现当$n$为质数时$\phi (n)=n-1$，当$n$为合数时，我们实际上只需要求出它的所有素因子将$n$分解为$(p_1^{a_1})\ast (p_2^{a_2})\ast \dots \dots \ast (p_k^{a_k})$，那么$\phi (n)=n\ast (1-\frac{1}{p_1})\ast (1-\frac{1}{p_2})\ast \dots \dots \ast (1-\frac{1}{p_k})$（看不懂的可以去复习一下鸽巢原理）。

积性函数简介：

如果一个数论函数$f(n)$满足$f(pq)=f(p)f(q),p\perp q$，则称$f(n)$是一个积性函数。特别的，如果不要求$p\perp q$且依然满足上述式子的话，则称$f(n)$是一个完全积性函数。例如$f(x)=x$，便是完全积性函数。（$p\perp q$指$gcd(p,q)=1$）

常见的积性函数有：

$e(n)=[n=1]$,

$1(n)=1$,

$\mu (n)=\{\begin{array}{ll}(-1{)}^k& n=p_1{p}_2{p}_3\dots p_k\\ 0& n=p^{2}q\end{array}$,

$\phi (n)={\sum }_{i=1}^n[i\perp n]$,

$d(n)={\sum }_{i|n}1$,

$id(n)=n$,

$\sigma (n)={\sum }_{d|n}d$

其他还有一些扩展性知识可以网上搜索了解。

回到本题，可以看出欧拉函数就是一个典型的积性函数，且题目告诉我们$n$为无平方因子数，则我们可以得到$n={\prod }_{i=1}^k{p}_i$。因为$\phi (n)=\phi (\frac{n}{p})\ast \phi (p)(\frac{n}{p}\perp p)$，所以我们可以将${\sum }_{i=1}^m\phi (i\ast n)$化为${\sum }_{i=1\cap i\perp p}^m\phi (i\ast \frac{n}{p})\ast \phi (p)+{\sum }_{i=1}^{\frac{m}{p}}\phi (i\ast p\ast n)$。因为$p$为$n$的一个素因子，所以$\phi (i\ast p\ast n)=\phi (i\ast n)\ast p$（联系欧拉函数计算公式理解）。

继续化简可得$\phi (p)\ast {\sum }_{i=1\cap i\perp p}^m\phi (i\ast \frac{n}{p})+{\sum }_{i=1}^{\frac{m}{p}}\phi (i\ast n)\ast (\phi (p)+1)$。

进行分配律可得$\phi (p)\ast {\sum }_{i=1\cap i\perp p}^m\phi (i\ast \frac{n}{p})+\phi (p)\ast {\sum }_{i=1}^{\frac{m}{p}}\phi (i\ast n)+{\sum }_{i=1}^{\frac{m}{p}}\phi (i\ast n))$

可以发现，第二项就是第一项所缺少的部分，所以可得$\phi (p)\ast {\sum }_{i=1}^m\phi (i\ast \frac{n}{p})+{\sum }_{i=1}^{\frac{m}{p}}\phi (i\ast n))$。

到这里我们就已经完成前半个题目的解答，因为每一项都可以看成将题目的范围变化后求解相同的问题，所以得到$n$的所有素因子之后一个递归即可解决问题。

之后便是计算最终答案。

扩展欧拉定理介绍：

结论：$a^c\equiv \{\begin{array}{ll}{a}^{cMod\varphi (m)}& \gcd (a,m)=1\\ a^c& \gcd (a,m)\ne 1\wedge c<\varphi (m)\\ a^{cMod\varphi (m)+\varphi (m)}& \gcd (a,m)\ne 1\wedge c\ge \varphi (m)\end{array}$

证明可看这篇blog。

利用这个定理，我们可以循环求解幂的情况，因为每次将幂向上一层，我们的模数都会变成原先的模数的欧拉函数，所以必然比原先的模数小，所以这个模数最终会变成$1$，即在一定程度上，无限幂次在取模的意义下和某一有限幂次是等价的。所以即可解决这个问题。

Code：

#include<bits/stdc++.h>
#define N 10000010
#define ll long long
using namespace std;
bool vis[N];
int phi[N];
long long sum2[N];
int cnt,prim[N];
const long long mod = 1000000007;
// 线性筛处理出所有素数以及欧拉函数值以及欧拉函数前缀和
void get(int maxn)
{
    phi[1]=1;
    for(int i=2;i<=maxn;i++)
    {
        if(!vis[i])
        {
            prim[++cnt]=i;
            phi[i]=i-1;
        }
        for(int j=1;j<=cnt&&prim[j]*i<=maxn;j++)
        {
            vis[i*prim[j]]=1;
            if(i%prim[j]==0)
            {
                phi[i*prim[j]]=phi[i]*prim[j];
                break;
            }
            else phi[i*prim[j]]=phi[i]*(prim[j]-1);
        }
    }
    for(int i=1;i<=maxn;i++)sum2[i]=(sum2[i-1]+phi[i]);
}

struct P {
	ll ans;
	bool v;
	P(ll _ans, bool _v) {
		ans = _ans;
		v = _v;
	}
};

ll gcd(ll a, ll b) {
	return b ? gcd(b, a % b) : a;
}
// 扩欧中的快速幂细节处理
P qpow(ll A, ll B, ll C) {
	ll re = 1;
	bool flag = 1;
	while(B) {
		if(B & 1) {
			if((re *= A) >= C) flag = 0;
			re = re % C;
		}
		B = B >> 1;
		if(B) {
			if(A >= C) flag = 0;
			A %= C;
			if((A *= A) >= C) flag = 0;
			A %= C;
		}
	}
	return P(re, flag);
}
// 扩欧计算第二步
P f(ll a, ll b, ll k, ll p) {
	if(p == 1) return P(0, 0);
	if(k == 0) return P(a % p, a < p);
	ll ep = phi[p];
	P tmp = f(b, b, k-1, ep);
	if(gcd(a, p) == 1)return qpow(a, tmp.ans, p);
	if(tmp.v == false) {
		tmp.ans += ep;
	}
	return qpow(a, tmp.ans, p);
}
// 迭代计算第一步，也可以预先处理出所有素因子
ll g(ll n,ll m)
{ 
	if(n == 1) return sum2[m] % mod;
	if(m == 1) return phi[n];
	if(m == 0) return 0;
	if(phi[n] == n - 1){
    	return (phi[n] * g(1, m) % mod + g(n, m / n)) % mod;
 	}
 	int p = sqrt(n) + 1;
	for(int i = 1; i <= cnt && prim[i] <= p; ++i){
    	if(!(n % prim[i]))
    		return (phi[prim[i]] * g(n / prim[i], m) % mod + g(n, m / prim[i])) % mod;
  	}
    
}

int main()
{
    int n, m, p;
    get(10000000);
    while(~scanf("%d %d %d", &n, &m, &p)){
        long long k = g(n, m);
        printf("%lld\n", f(k, k, 100000000, p).ans);
    }
    return 0;
}

【END】感谢观看