使用位运算实现乘法和乘方运算

1、使用位运算乘法。

把一个乘数变为2进制后，使用位运算完成乘数的乘法。

[cpp] view plaincopy

1. /* 
2.  * 输入：正整数k 和 正整数m 
3.  * 输出：k*m 
4.  */   
5. __int64 km(__int64 k, __int64 m){  
6.    __int64 x = k;  
7.    int w = (int)floor(log(m) / log(2)) -1;  
8.    __int64 e = 1 << w;  
9.    for(int i=0; i<=w; i++){  
10.        x <<= 1;  
11.        if(m & e)  
12.             x += k;  
13.        e >>= 1;  
14.    }  
15.    return x;  
16. }  

2、使用位运算的乘方运算

指数变为2进制后，使用位运算完成乘方运算。

伪代码：

C++实现

[cpp] view plaincopy

1. /* 
2.  * 输入：正整数v mod m 和 g mod m  
3.  * 输出：g^v mod m  
4.  */  
5. __int64 gvmm(__int64 g, __int64 v, __int64 m){  
6.     int w = (int)floor(log(v) / log(2)) - 1;  
7.     __int64 e = 1 << w;  
8.     __int64 x = g;  
9.     for(int i=0; i<=w; i++){  
10.         x = (x * x) % m;  
11.         if(v & e){  
12.              x = (g * x) % m;  
13.         }  
14.         e >>= 1;  
15.     }  
16.     return x;  
17. }  

乘方的测试：

使用普通算法和位运算算法比较。

[cpp] view plaincopy

1. #include <iostream>  
2. #include <math.h>  
3. #include <time.h>    
4. using namespace std;  
5.   
6. /* 
7.  * 输入：正整数v mod m 和 g mod m  
8.  * 输出：g^v mod m  
9.  */  
10. __int64 gvmm(__int64 g, __int64 v, __int64 m){  
11.     int w = (int)floor(log(v) / log(2)) - 1;  
12.     __int64 e = 1 << w;  
13.     __int64 x = g;  
14.     for(int i=0; i<=w; i++){  
15.         x = (x * x) % m;  
16.         if(v & e){  
17.              x = (g * x) % m;  
18.         }  
19.         e >>= 1;  
20.     }  
21.     return x;  
22. }  
23. /* 
24.  * 验证结果的普通算法  
25.  */  
26. int yanzheng(__int64 g, __int64 v, __int64 m){  
27.     __int64 x = 1;  
28.     for(int i=0; i<v; i++){  
29.         x *= g;  
30.         x %= m;  
31.     }  
32.     return x;  
33. }  
34.   
35. int main(){  
36.     clock_t begin = clock();  
37.     cout << yanzheng(23229,1892123, 23894)  << endl;  
38.     clock_t end = clock();    
39.     double cost = (double)(end - begin) / CLOCKS_PER_SEC;    
40.     printf("putong : %lf seconds\n", cost);    
41.     begin = clock();    
42.     cout << gvmm(23229,1892123, 23894) << endl;  
43.     end = clock();    
44.     cost = (double)(end - begin) / CLOCKS_PER_SEC;    
45.     printf("weiyunsuan: %lf seconds\n", cost);       
46.     system("pause");  
47. }  

按照程序中给出的稍复杂的乘方运算，其效率分别为（多次测量后都差不多这个数量级）

21963
putong : 0.071000 seconds
21963
weiyunsuan: 0.001000 seconds

差不多普通算法比位运算算法慢了50-70倍。

原文地址：点击打开链接