hdu 5728 PowMod

Declare:
    

  is a square-free number.

  is the Euler's totient function.

find:
           

There are infinite number of  

Input Multiple test cases(test cases







 ), one line per case.

Each line contains three integers,





  and

 .




















 

  

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

1 2 6
1 100 9

   Sample Output

4
7
  原博客详情请见（转载自）http://blog.csdn.net/wust_zzwh/article/details/51966450

这个题考的是欧拉函数和指数循环节，我只是以这种方式想做个笔记才搞的这个博客

这个题考的欧拉函数的积性函数性质：
①当gcd(a,b)==1即a与b互质时，有phi(a*b)=phi(a)*phi(b);
②phi(m*n*p)=p*phi(m*n)，其中p与n/p互质，至于原因，把这个式子按照欧拉函数的基础通式展开再推一推就得到了;
然后就可以有：
分成两部分求：



.....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);

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


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

代码：
#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <string.h>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <string>
#include <math.h>
using namespace std;
typedef long long LL;
const LL MOD=1000000000+7;
const LL maxn=10000000+7;
LL el[maxn],sumel[maxn];
LL N,M,P;
bool isprime[maxn];
LL prime[maxn/5];
LL total;
LL fac[maxn/3];

void sox(LL m)//线性时间筛出欧拉值和质数
{
//elu();
memset(el,0,sizeof(el));
memset(sumel,0,sizeof(sumel));
el[1]=1;sumel[1]=1;
memset(isprime,false,sizeof(isprime));
memset(prime,0,sizeof(prime));
total=0;
isprime[0]=isprime[1]=false;

for(LL i=2;i<=m;i++)
{
if(!isprime[i])
{
prime[total++]=i;
el[i]=i-1;
}
for(LL j=0;j<total;j++)
{
if(i*prime[j]>m)break;
isprime[i*prime[j]]=true;
if(i%prime[j]==0)
{
el[i*prime[j]]=el[i]*prime[j];
break;
}
else
{
el[i*prime[j]]=el[i]*(prime[j]-1);
}
}
sumel[i]=sumel[i-1]+el[i];
}

memset(isprime,false,sizeof(isprime));
for(int i=0;i<total;i++)
{
isprime[prime[i]]=true;
}
}

LL f(LL m,LL n,LL i)//计算本题中的k
{
//printf("fac=%lld n=%lld i=%lld\n",fac[i],n,i);
if(m==0)return 0;
if(n==1)
{
return sumel[m]%MOD;
}
return (fac[i]-1)*f(m,n/fac[i],i-1)%MOD+f(m/fac[i],n,i)%MOD;
}
LL cir(LL p,LL sum)//指数为1时的循环次数
{
if(p==1)return sum;
return cir(el[p],sum+1);
}
LL fast(LL x,LL n,LL mo)
{
LL ans=1;
while(n>0)
{
if(n&1)ans=ans*x%mo;
x=x*x%mo;
n>>=1;
}
if(ans<=0)ans+=mo;
return ans;
}
LL cal(LL sum,LL val,LL mo,LL k)//计算超级幂
{
if(sum==1){/*printf("%lld %lld\n",el[mo],mo);*/return val%mo+mo;}
LL ans=cal(sum-1,val,el[mo],k);
return (fast(k,ans,mo))%mo+mo;
}

int main()
{

sox(maxn-1);
//for(int i=1;i<=9;i++)printf("%lld\n",el[i]);
while(scanf("%lld%lld%lld",&N,&M,&P)!=-1)
{
LL t=0,NN=N;
for(LL i=0;i<total&&prime[i]*prime[i]<=NN;i++)
{
if(NN%prime[i]==0)
{
fac[t++]=prime[i];
if(isprime[NN/prime[i]])
{
fac[t++]=NN/prime[i];
}
NN/=prime[i];
}
}
if(t==0)fac[t++]=N;
//printf("t=%lld\n",t);
sort(fac,fac+t);
/*for(int i=0;i<t;i++)
{
printf("%lld\n",fac[i]);
}*/
LL a1=f(M,N,t-1)%MOD;
//puts("a");
LL cs=cir(P,0);
//puts("a");
LL ans=cal(cs,a1,P,a1)%P;
printf("%lld\n",ans);
}
return 0;
}