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[N],phi[N];
bool vis[N];
int tot;
ll sum[N];
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[n]) {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;
}