欧拉-费马小定理定理（证实及推论）

 欧拉定理：

    若正整数 a , n 互质，则  a^φ(n)≡1(mod n)   其中 φ(n) 是欧拉函数（1~n) 与 n 互质的数。

证实以下：

    不妨设X₁，X₂ ...... X_φn是1~n与n互质的数。

　　首先咱们先来考虑一些数：aX₁，aX₂ ...... aX_φn

　　这些数有以下两个性质：

　（1）任意两个数模n余数必定不一样：（反证）若存在aX1≡aX₂（mod n），则 n |（ aX₁ - aX₂ ），而a，n互质且（X₁ - X₂）< n，因此n不可能整除（ aX₁ - aX₂ ），也就是说

不存在aX1≡aX₂（mod n）。概括法：对于任意的与n互质的X_i均成立。故得证。

　　那么由于有 φn 个这样的数，X_i mod n（i=1~φn）因此就有 φn 个不一样的余数，而且都是模数天然是（0~n-1）。

　（2）对于任意的aX_i（mod n）都与n互质。这不难想，由于a与n互质这是欧拉函数的条件，X_i是（1~n）与n互质的数的集合中的元素。因此若是a*X_i作为分子，n作为分母，那么

他们构成的显然就是一个最简分数，也就是aX_i和n互质。接下来就能够用欧几里得算法：由于：gcd（aX_i，n）==1因此：gcd（aX_i，n）== gcd（n，aX_i%n）== 1

 

　　这样，咱们把上面两个性质结合一下来讲，aX₁（mod n），aX₂（mod n） ...... aX_φn（mod n）构成了一个集合（性质1证实了全部元素的互异性），而且这些数是1~n与n互

质的全部数构成的集合（性质1已说明）。这样，咱们巧妙的发现了，集合{ aX₁（mod n），aX₂（mod n） ...... aX_φn（mod n）}通过必定的排序后和集合{ X₁，X₂ ...... X_φn }

彻底一一对应。那么：aX₁（mod n）* aX₂（mod n）*  ...... * aX_φn（mod n）= X₁ * X₂ * ...... * X_φn   所以：咱们能够写出如下式子：

    aX₁ * aX₂ *  ...... * aX_φn ≡  X₁ * X₂ * ...... * X_φn  （mod n），即：（a^φn -1）X₁ * X₂ * ...... * X_φn ≡ 0 （mod n）

　　又由于X₁ * X₂ * ...... * X_φn与n互质，因此， （a^φn -1）| n，那么a^φn ≡ 1（mod n）。欧拉定理得证。

 

 费马小定理：

　　对于质数p，任意整数a，均知足：a^p≡a（mod p）

证实以下：

　　这个能够用欧拉定理来讲明：首先，咱们把这个式子作一个简单变换得：a^p-1 * a ≡ a（mod p） 由于a ≡ a（mod p）恒成立，因此a^p-1 mod p == 1时费马小定理才成立，又由于p

是质数，因此 φn == n-1 ,因此根据欧拉定理：若a，p互质则a^p-1 mod p == 1成立。那么对于a，p不互质，由于p是质数，因此，a必定是倍数a^p ≡ a ≡ 0（mod p）。综上所述，费马小定理

成立，其实它算是欧拉定理的一个特例。

 

 欧拉定理的推论：

　　若正整数a，n互质，那么对于任意正整数b，有a^b≡a^{b mod φ（n）}（mod n）

证实以下：（相似费马小定理的证实）

　　把目标式作一简单变形：a^{b - b mod φ（n）}* a^{b mod φ（n）}≡ a^{b mod φ（n）}（mod n），因此接下来只须要证实a^{b - b mod φ（n）}≡ 1 （mod n），又由于：

（ b - b mod φ（n））| φ（n），不妨设：（ b - b mod φ（n））= q*φ（n）（q为天然数），则有a^q*φ（n）== （a^q）^φ（n），由于a，n互质，那么（a^q）与n也互质，

那么就转换到了欧拉定理：（a^q）^φ（n）≡ 1 （mod n），成立。因此咱们这个推论成立。

 

这个推论能够帮助咱们在求幂运算的时候缩小数据范围和计算次数。具体的说：在求乘方运算时，能够先把底数对mod取模，再把指数对b mod φ（n）取模。

特别的，若是a，mod不互质，且b>φ（n）时，a^b≡a^{b mod φ（n）+ φ（n）}（mod n）。

 

 

下面咱们就用这个推论来作一道题：// http://www.nyzoj.com:5283/problem/6

 

题目：
　　给定a，n求出 $\mathrm{S=((((aa)a)a)a\cdot \cdot \cdot \cdot )a （mod 998244353）}$$\mathrm{共n个a。}$

$\mathrm{输入：}$

$\mathrm{输入仅一行.\; 两个正整数a和n。}$

$\mathrm{输出：}$

$\mathrm{输出仅一行.\; 一个正整数S。}$

 

样例解释：

 

$((22)2)2 mod 998244353 = 256$

$数据范围：$

$a，n\; <=\; 1018$

 

$思路：$

$先求出指数，即an-1（快速幂求解），并将指数对mod-1（由于mod是质数，那么\phi （mod）=\; mod-1），再用更新后的指数作为新的指数用快速幂求解便可。代码以下：$

#include<cstdio>
typedef long long ll;
ll a,n;
const int M=998244353;
ll mi(ll a,ll b,int mod)
{
    ll re=1; a%=mod;
    while (b)
    {
        if (b&1) re=(re*a)%mod;
        a=(a*a)%mod;
        b>>=1; 
    }
    return re;
}
int main()
{
    scanf ("%lld%lld",&a,&n);
    ll t=mi(a,n-1,M-1);
    printf("%lld",mi(a,t,M));
    return 0;
} 

 

 

$\mathrm{课后例题：//poj\; 3696}$

$\mathrm{给定一个正整数L，L <=\; 2*109.\; 问多少个8连在一块儿的数是L的倍数。若是不存在就输出0.}$

$\mathrm{//这里省略输入输出规则，请读者自行注意}$

 

$\mathrm{思路：}$

$\mathrm{x个8连在一块儿能够写成8*（10x-1）*9，假设d=gcd（L，8）。那么题目能够表达为：L\; | 8*（10x-1）*9\; ，\; 接下来咱们作一些简单的式子变形：}$

$\mathrm{L\; | 8*（10x-1）/9 \; \leftarrow \to L*9\; | 8*（10x-1） \leftarrow \to 9L/d\; | （10x-1） \leftarrow \to 10x \equiv \; 1\; （mod\; 9L/d）}$

$\mathrm{引理：对于任意互质的正整数a，n，知足：ax\equiv 1（mod\; n）最小的整数值\; X0 是\phi （n）的约数。}$

$\mathrm{证实以下：}$

$\mathrm{（反证法）假设X0不是\phi （n）的约数，则\phi （n）能够表示为：qX0 +\; r（0\; <=\; r\; <\; X0)。题设有：aX0\equiv 1（mod\; n），那么，aqX0\equiv 1（mod n）且正整数a,n互质，因此有欧拉定理：}$

$\mathrm{a\phi (n)\equiv 1(mod\; n)，即}$$\mathrm{：aqX0 *\; ar\equiv 1(mod\; n)，继而得出：ar\equiv 1(mod\; n)，此时r<X0，这与X0是最小的整数值矛盾，因此假设不成立。得证。}$

$\mathrm{因此，接下来咱们只须要求出\phi （9L/d）并将其约数带入10x \equiv \; 1\; （mod\; 9L/d）验证是否成当即可。求欧拉函数和快速幂，时间复杂度为：O（\surd （n）\; *\; log2\; n）。代码以下：}$

 

#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
ll n,mod;
int Case;
ll gcd(ll a,ll b)
{
    return a%b==0 ? b : gcd(b,a%b);
}
ll Er(ll x)
{
    ll re=x;
    for (ll i=2;i*i<=x;i++)
    {
        if (x%i==0)
        {
            re=re/i*(i-1);
            while (x%i==0) x/=i;
        }
    }
    if (x>1) re=re/x*(x-1);
    return re;
}
ll mul(ll a,ll b,ll p)
{
    ll re=0;
    while (b)
    {
        if (b&1) re=(re+a)%p;
        a=2*a%p;
        b>>=1;
    }
    return re;
}
ll ksm(ll a,ll b,ll p)
{
    ll re=1; a%=p;
    while (b)
    {
        if (b&1) re=mul(re,a,p);
        a=mul(a,a,p); b>>=1;
    }
    return re;
}
int main()
{
    while (scanf ("%lld",&n))
    {
        if (n==0) return 0;
        Case++;
        ll d=gcd(n,8);
        ll phi=Er(9*n/d);
        mod=9*n/d;
        ll flag=9223372036854775806;
        for (ll i=1;i*i<=phi;i++)
        {
            if (phi%i==0)
            {
                if (ksm(10,i,mod)==1) 
                  flag=min(flag,i);
                if (ksm(10,phi/i,mod)==1)
                  flag=min(flag,phi/i);
            }
        }
        flag==9223372036854775806?printf("Case %d: 0\n",Case):printf("Case %d: %lld\n",Case,flag);
    }
}