2016多校训练一 PowMod，hdu5728（欧拉函数+指数循环节）

Declare:
k=∑mi=1φ(i∗n) mod 1000000007

n is
a square-free number.

φ is
the Euler's totient function.

find:
ans=kkkk...k mod p

There are infinite number of k

 

Input

Multiple test cases(test cases ≤100),
one line per case.

Each line contains three integers, n,m and p.

1≤n,m,p≤107

 

Output

For each case, output a single line with one integer, ans.

 

Sample Input

1 2 6
1 100 9

 

Sample Output

4
7

题意：只要是那个k是无限个

题解：首先是算k：先了解两条性质，欧拉函数是积性函数；

（1）积性函数性质：F(m1*m2)=F(m1)*F(m2)，当且近当gcd(m1,m2)=1时成立；

（2）

，其中p是n的素因子。这个用欧拉函数的素因子表达式很好证明。

有了这个再来算k，题目的n是很特殊的，它的每个素因子的幂次都是1：

那么假设素数p是n的一个素因子，显然gcd(p,n/p)=1;关键是i，如果i中没有素因子p，那么就直接用积性性质。如果i%p==0，必然可以写成i=k*p;即倍数关系，否则i%p!=0;

所以分成两部分求：




.....p是素数,素数的欧拉值就是p-1;





到这里前两和式是可以合并的，考虑和式的上下限，含义不同，第二项的i表示的p的倍数i*p才是第一项i的含义，相当于第二项刚好把第一项补齐了，那么从1到m没有遗漏，而且第二项的i用第一项替换后里面也是n/p;最终



这是个二元递归式：n/p和m/p看成整体,那么设原先求的为f(n,m)，所以f(n,m)=(p的欧拉值)*f(n/p,m)+f(n,m/p);

每次枚举一个就够了，n每次要除以p，最多就是把它的每个素因子除完。

第二部分k的超级幂：用欧拉的定理：指数循环节

 


每次往幂次上一层模就取一次欧拉值,只有1的欧拉值等一自己,其他数的欧拉值都是小于自己的，所以模会不断变小至1，显然对1取模结果就是0，所以无限就变得有限了

#include<cstdio>
#include<cstring>
#include<string>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<utility>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
#include<iterator>
#include<stack>
using namespace std;
const int INF=1e9+7;
const double eps=1e-7;
const int N=1e7+5;
const int M=1000000007;
typedef long long ll;
int pri
,phi
;
bool vis
;
int tot;
ll sum
;
void init()
{
int n=N;
tot=0;
memset(vis,false,sizeof vis);
phi[1]=1;
for(int i=2;i<n;i++)
{
if(!vis[i])
{
pri[tot++]=i;
phi[i]=i-1;
}
for(int j=0;j<tot && i*pri[j]<n;j++)
{
vis[i*pri[j]]=true;
if(i%pri[j]==0)
{
phi[i*pri[j]]=phi[i]*pri[j];
break;
}
else phi[i*pri[j]]=phi[i]*(pri[j]-1);
}
}
sum[0]=0;
for(int i=1;i<N;i++)
sum[i]=(sum[i-1]+phi[i])%M;
}
ll Pow(ll a,ll n,ll mod)
{
ll ans=1;
while(n)
{
if(n&1)
{
ans=ans*a%mod;
//            if(ans>=mod)ans=ans%mod;
}
a=a*a%mod;
//        if(a>=mod) a=a%mod;
n>>=1;
}
if(ans==0) ans+=mod;
return ans;
}
ll solve(ll k,ll mod)
{
if(mod==1) return mod;
ll tmp=phi[mod];
ll up=solve(k,tmp);
ll ans=Pow(k,up,mod);
return ans;
}
int rear;
int a[15];
void resolve(ll n)
{
for(int i=0;i<tot;i++)
{
if(!vis
) {a[rear++]=n;break;}
if(n%pri[i]==0)
{
a[rear++]=pri[i];
n/=pri[i];
}
}
}
ll f(int pos,ll n,ll m)
{
//pos即每个素数，一次一个就行了
if(n==1) return sum[m];//n为1结果就是欧拉值的前缀和
if(m==0)return 0;
return ((a[pos]-1)*f(pos-1,n/a[pos],m)%M+f(pos,n,m/a[pos]))%M;
}
int main()
{
init();//打表
ll n,m,p;
while(~scanf("%I64d%I64d%I64d",&n,&m,&p))
{
rear=0;
resolve(n);//素因子分解
ll k=f(rear-1,n,m);//算k
ll ans=solve(k,p);
printf("%I64d\n",ans%p);
}
return 0;
}