HDU 5728 PowMod（数论+递归）

Description
定义，其中n无平方因数，是欧拉函数
现给出n,m,p，求 ，式子中k有无穷个
Input
第一行为一整数T表示用例组数，每组用例占一行包括三个整数n,m,p
(T<=100,1<=n,m,p<=10^7)
Output
对于每组用例，输出ans
Sample Input
1 2 6
1 100 9
Sample Output
4
7
Solution
首先求k，需要用到欧拉函数的两个性质：
1.若(n,m)=1，则有
2.若m是素数且m|n，则有
由这两个性质有：

记solve(n,m)=,p为n的素因子，则有

当n=1时，solve(1,m)=;
当m=1时，solve(n,1)=;
当m=0时，solve(n,0)=0;
这个递归求解最多递归n的素因子个数层，故可以在至多O(log n)的复杂度内求出k，下面来求ans
此处引入一个由欧拉定理衍生出的一个指数循环节定理

每次往上幂一层模数就取一次欧拉函数值，由于一个数的欧拉函数值一定小于自身，所以至多经过O(log p)次操作模数就变成了1，那么上面的幂就没有意义了，无限幂就变成了有限幂
Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
#define maxn 11111111
#define mod 1000000007ll
int euler[maxn],prime[maxn],sum[maxn],res;
void get_euler()
{
    memset(euler,0,sizeof(euler));
    euler[1]=1,sum[1]=1;
    res=0; 
    for(int i=2;i<maxn;i++)
    {
        if(!euler[i])
        {
            euler[i]=i-1;
            prime[res++]=i;
        } 
        for(int j=0;j<res&&prime[j]*i<maxn;j++)
        {
            if(i%prime[j]) 
                euler[prime[j]*i]=euler[i]*(prime[j]-1);
            else
            {
                euler[prime[j]*i]=euler[i]*prime[j];
                break;
            }
        }
        sum[i]=(sum[i-1]+euler[i])%mod;
    }
}
int solve(int n,int m)
{
    if(n==1)return sum[m];
    if(m==1)return euler[n];
    if(m==0)return 0;
    for(int i=0;i<res;i++)
        if(n%prime[i]==0)
            return (1ll*(prime[i]-1)*solve(n/prime[i],m)%mod+solve(n,m/prime[i]))%mod;
}
ll mod_pow(ll a,ll b,int p)
{
    ll ans=1;
    while(b)
    {
        if(b&1)ans=ans*a%p;
        a=a*a%p;
        b>>=1;
    }
    return ans;
}
int deal(int k,int p)
{
    if(p==1)return 0;
    ll temp=deal(k,euler[p]);
    return mod_pow(k,temp+euler[p],p)%p;
}
int main()
{
    get_euler();
    int n,m,p;
    while(~scanf("%d%d%d",&n,&m,&p))
    {
        ll k=solve(n,m);
        int ans=deal(k,p);
        printf("%d\n",ans);
    }
    return 0;
}