1. 程式人生 > >快速求冪與快速冪模

快速求冪與快速冪模

未優化過的


#include <iostream>

using namespace std;

void km(){//快速冪
    int a,n;
    cin >> a >> n;
    int pow = 1;
    while (n){
        if (n%2){
            pow *= a;
        }
        a *= a;
        n /= 2;
    }
    cout << pow << endl;
    return;
}

void kmm(){//快速冪模
int a,n,c; cin >> a >> n >> c; int pow = 1; while (n){ if (n%2){ pow =(pow*a)%c; } a =(a*a)%c; n /= 2; } cout << pow << endl; return; } int main() { kmm(); return 0; }

優化後的:


#include <iostream>
using namespace std; void km(){//快速冪 int a,n; cin >> a >> n; int pow = 1; while (n){ if (n&1){ pow *= a; } a *= a; n >>= 1; } cout << pow << endl; return; } void kmm(){//快速冪模 int a,n,c; cin
>> a >> n >> c; int pow = 1; while (n){ if (n&1){ pow =(pow*a)%c; } a =(a*a)%c; n >>= 2; } cout << pow << endl; return; } int main() { km(); // kmm(); return 0; }

快速求正整數次冪
2007-05-05 12:21
快速求正整數次冪,當然不能直接死乘。舉個例子:

3 ^ 999 = 3 * 3 * 3 * … * 3

直接乘要做998次乘法。但事實上可以這樣做,先求出2^k次冪:

3 ^ 2 = 3 * 3
3 ^ 4 = (3 ^ 2) * (3 ^ 2)
3 ^ 8 = (3 ^ 4) * (3 ^ 4)
3 ^ 16 = (3 ^ 8) * (3 ^ 8)
3 ^ 32 = (3 ^ 16) * (3 ^ 16)
3 ^ 64 = (3 ^ 32) * (3 ^ 32)
3 ^ 128 = (3 ^ 64) * (3 ^ 64)
3 ^ 256 = (3 ^ 128) * (3 ^ 128)
3 ^ 512 = (3 ^ 256) * (3 ^ 256)

再相乘:

3 ^ 999
= 3 ^ (512 + 256 + 128 + 64 + 32 + 4 + 2 + 1)
= (3 ^ 512) * (3 ^ 256) * (3 ^ 128) * (3 ^ 64) * (3 ^ 32) * (3 ^ 4) * (3 ^ 2) * 3

這樣只要做16次乘法。即使加上一些輔助的儲存和運算,也比直接乘高效得多(尤其如果這裡底數是成百上千位的大數字的話)。

我們發現,把999轉為2進位制數:1111100111,其各位就是要乘的數。這提示我們利用求二進位制位的演算法(其中mod是模運算):

REVERSE_BINARY(n)
1 while (n > 0)
2 do output (n mod 2)
3 n ← n / 2

這個演算法給出正整數n的反向二制進位,如6就給出011(6的二進位制表示為110)。事實上這個演算法對任意的p進位制數是通用的,只要把其中的2換成p就可以了。

如何把它改編為求冪運算?我們發現這個演算法是從低位向高位做的,而恰好我們求冪也想從低次冪向高次冪計算(參看前面的例子)。而且我們知道前面求出的每個2^k次冪只參與一次乘法運算,這就提示我們並不把所有的中間結果儲存下來,而是在計算出它們後就立即運算。於是,我們要做的就是把輸出語句改為要做的乘法運算,並在n減少的同時不斷地累積求2^k次冪。

還是看演算法吧:

POWER_INTEGER(x, n)
1 pow ← 1
2 while (n > 0)
3 do if (n mod 2 = 1)
4 then pow ← pow * x
5 x ← x * x
6 n ← n / 2
7 return pow

不難看出這個演算法與前面演算法的關係。在第1步給出結果的初值1,在while迴圈內進行運算。3、4中的if語句就來自REVERSE_BINARY的輸出語句,不過改成了如果是1則向pow中乘。5句則是不斷地計算x的2^k次冪,如對前面的例子就是計算2^2、2^4、2^8、…、2^512。

應該指出,POWER_INTEGER比前面分析的要再多做兩次乘法,一次是向pow中第一次乘x,如2^1也要進行這個乘法;另一次則是在演算法的最後,n除以2後該跳出迴圈,而前面一次x的自乘就浪費掉了(也可以考慮改變迴圈模式優化掉它)。另外,每趟while迴圈都要進行一次除法和一次模運算,這多數情況下除法和模運算都比乘法慢許多,不過好在我們往往可以用位運算來代替它。

相應的C++程式碼如下

NumberType pow_n(NumberType x, unsigned int n)
{
NumberType pw = 1;

while (n > 0) {
    if ((pw % 2) == 1)
        pw *= x;
    x *= x;
    n /= 2;

}

return pw;

}

進行簡單的優化後則有:

NumberType optimized_pow_n(NumberType x, unsigned int n)
{
NumberType pw = 1;

while (n > 0) {
    if (n & 1)        // n & 1 等價於 (n % 2) == 1
        pw *= x;
    x *= x;
    n >>= 1;        // n >>= 1 等價於 n /= 2
}

return pw;

}

注1:快速求冪演算法POWER_INTEGER常被寫成遞迴的形式,演算法實質完全相同,但卻是無必要的。

注2:這個演算法並不是做乘法數最少的,但多數情況下是足夠快並且足夠簡單的。如果單純追求做乘法數最少,則未必應該用2^k次冪進行計算。如果還允許做除法,則問題會進一步複雜化。

如:

x ^ 2 = x * x
x ^ 4 = (x ^ 2) * (x ^ 2)
x ^ 8 = (x ^ 4) * (x ^ 4)
x ^ 16 = (x ^ 8) * (x ^ 8)
x ^ 31 = (x ^ 16) * (x ^ 8) * (x ^ 4) * (x ^ 2) * x
要8次乘法。

x ^ 2 = x * x
x ^ 4 = (x ^ 2) * (x ^ 2)
x ^ 8 = (x ^ 4) * (x ^ 4)
x ^ 10 = (x ^ 8) * (x ^ 2)
x ^ 20 = (x ^ 10) * (x ^ 10)
x ^ 30 = (x ^ 20) * (x ^ 10)
x ^ 31 = (x ^ 30) * x
只要7次乘法。

x ^ 2 = x * x
x ^ 4 = (x ^ 2) * (x ^ 2)
x ^ 8 = (x ^ 4) * (x ^ 4)
x ^ 16 = (x ^ 8) * (x ^ 8)
x ^ 32 = (x ^ 16) * (x ^ 16)
x ^ 31 = (x ^ 32) / x
只要6次乘或除法。

不過具體得出上述乘(除)法數更少的演算法會變得相當複雜,在許多情況下時間收益還會得不償失。因此往往並不實用。ACM Japan 2006中有一道題即要求計算最少乘法數,可參看