快速求冪與快速冪模
未優化過的
#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中有一道題即要求計算最少乘法數,可參看