我們先從簡單的例子入手：求x^n % mod 。

演算法1.首先直接地來設計這個演算法：

int mod1(int x,int n,int mod)
{
    int ans=1;
    for(int i=1;i<=n;i++)
    {
        ans*=x;
    }
    return ans%mod;
}

這個演算法的時間複雜度體現在for迴圈中，為O（n）.這個演算法存在著明顯的問題，如果x和n過大，很容易就會溢位。

那麼，我們先來看看第一個改進方案：在講這個方案之前，要先有這樣一個公式：

(a*b)%c = ((a%c)*b)%c

這個公式大家在離散數學或者數論當中應該學過，即積的取餘等於取餘的積的取餘。

證明了以上的公式以後，我們可以先讓a關於c取餘，這樣可以大大減少a的大小，溢位的可能性會大大減小

於是上面的程式進行了改進：

**演算法2： *

int mod2(int x,int n,int mod)
{
    x=x%mod;///這裡就是改進的那一步
    int ans=1;
    for(int i=1;i<=n;i++)
    {
        ans*=x;
    }
    return ans%mod;
}

聰明的讀者應該可以想到，既然某個因子取餘之後相乘再取餘保持餘數不變，那麼新算得的ans也可以進行取餘，所以得到比較良好的改進版本。

演算法3：

int mod3(int x,int n,int mod)
{
    x=x%mod;///這裡就是改進的那一步
    int ans=1;
    for(int i=1;i<=n;i++)
    {
        ans=(ans*x)%mod;///又一次改進
    }
    return ans%mod;
}
 

這個演算法在時間複雜度上沒有改進，仍為O(n)，不過已經好很多的，但是在mod過大的條件下，還是很有可能超時，所以，我們推出以下的快速冪演算法。

快速冪演算法依賴於以下明顯的公式，我就不證明了。

a^b mod c=(a^2)^(b/2) mod c  (b為偶數)；  
   a^b mod c=((a^2)^(b div 2)*a) mod c (b為奇數) 

有了上述兩個公式後，我們可以得出以下的結論：

1.如果b是偶數，我們可以記k = a^2 mod c，那麼求(k)^b/2 mod c就可以了。

2.如果b是奇數，我們也可以記k = a^2 mod c，那麼求

((k)^b/2 mod c × a ) mod c =((k)^b/2 mod c × a) mod c 就可以了。

那麼我們可以得到以下演算法：

演算法4：

int mod4(int x,int n,int mod)
{
    int ans = 1;
    x = x % mod;
    if(n%2==1)
        ans = (ans * x) % mod; //如果是奇數，要多求一步，可以提前算到ans中
    int k = (x*x) % mod; //我們取a2而不是a
    for(int i = 1; i<=n/2; i++)
    {
        ans = (ans * k) % mod;
    }
    ans = ans % mod;
    return ans;
}

我們可以看到，我們把時間複雜度變成了O(n/2).當然，這樣子治標不治本。但我們可以看到，當我們令k = (x × x) % mod 時，狀態已經發生了變化，我們所要求的最終結果即為(k)^(n/2 ) % mod 而不是原來的(x^n) % mod ，所以我們發現這個過程是可以迭代下去的。當然，對於奇數的情形會多出一項x % mod ，所以為了完成迭代，當n是奇數時，我們通過

ans = (ans * x) % mod;來彌補多出來的這一項，此時剩餘的部分就可以進行迭代了。

形如上式的迭代下去後，當b=0時，所有的因子都已經相乘，演算法結束。於是便可以在O（log b）的時間內完成了。於是，有了最終的演算法：快速冪演算法。

演算法5：快速冪演算法

int mod5(int x,int n,int mod)
{
    int ans = 1;
    x = x % mod;
    while(n>0)
    {
        if(n % 2 == 1)
            ans = (ans * x) % mod;
        n = n/2;
        x = (x * x) % mod;
    }
    return ans;
}

本演算法的時間複雜度為O（logn），能在幾乎所有的程式設計（競賽）過程中通過，是目前最常用的演算法之一。

以下內容僅供參考：

擴充套件：有關於快速冪的演算法的推導，還可以從另一個角度來想。

求解這個問題，我們也可以從進位制轉換來考慮：

將10進位制的b轉化成2進位制的表示式：

那麼，實際上，.例如：x^22=x^16 × x^4 × x^2;
（而22轉換為二進位制數是10110）

所以，注意此處的要麼為0，要麼為1，如果某一項，那麼這一項就是1，這個對應了上面演算法過程中b是偶數的情況，為1對應了b是奇數的情況[不要搞反了，讀者自己好好分析，可以聯絡10進位制轉2進位制的方法]，我們從依次乘到。對於每一項的計算，計算後一項的結果時用前一項的結果的平方取餘。對於要求的結果而言，為時ans不用把它乘起來，[因為這一項值為1]，為1項時要乘以此項再取餘。

當然，這裡對於n的控制也可以用二進位制的思想來比較好理解

演算法6：

ll mod_pow(ll x,ll n,ll mod)
{
    ll res=1;
    while(n>0)
    {
        if(n&1)
            res=res*x%mod;
        x=x*x%mod;
        n>>=1;
    }
    return res;
}

ll mod_pow1(ll x,ll n,ll mod)
{
    if(n==0) return 1;
    ll res=mod_pow1(x*x%mod,n/2,mod);
    if(n&1) res=res*x%mod;
    return res;
}