快速幂模板

转自:点击打开链接

1.大数模幂运算的缺陷:

快速幂取模算法的引入是从大数的小数取模的朴素算法的局限性所提出的,在朴素的方法中我们计算一个数比如5^1003%31是非常消耗我们的计算资源的,在整个计算过程中最麻烦的就是我们的5^1003这个过程
缺点1:在我们在之后计算指数的过程中,计算的数字不都拿得增大,非常的占用我们的计算资源(主要是时间,还有空间)
缺点2:我们计算的中间过程数字大的恐怖,我们现有的计算机是没有办法记录这么长的数据的,所以说我们必须要想一个更加高效的方法来解决这个问题

2.快速幂的引入:

我们首先从优化的过程开始一步一步优化我们的模幂算法

1.朴素模幂运算过程:

  1. #define ans=1  
  2. for(int i=1;i<=b;i++)  
  3. {  
  4.     ans*=a;  
  5. }  
#define ans=1
for(int i=1;i<=b;i++)
{
	ans*=a;
}
根据我们上面说的,这种算法是非常的无法容忍的,我们在计算的过程中出现的两个缺点在这里都有体现
在这里我们如果要做优化的话,我肥就是每个过程中都加一次模运算,但是我们首先要记住模运算是非常的消耗内存资源的,在计算的次数非常的大的时候,我们是没有办法忍受这种时间耗费的

2.快速幂引入:

在讲解快速幂取模算法之前,我们先将几个必备的知识
1.对于取模运算:
  1. (a*b)%c=(a%c)*(b%c)%c  
(a*b)%c=(a%c)*(b%c)%c
这个是成立的:也是我们实现快速幂的基础
之后我们来看看快速幂的核心本质
我通过离散课上的学习,将快速幂的本质差不多理解了一下,感觉还是很深刻的

在这里,我们对指数懂了一些手脚,核心思想在于
将大数的幂运算拆解成了相对应的乘法运算,利用上面的式子,始终将我们的运算的数据量控制在c的范围以下,这样我们可以客服朴素的算法的缺点二,我们将计算的数据量压缩了很大一部分,当指数非常大的时候这个优化是更加显著的,我们用Python来做一个实验来看看就知道我们优化的效率有多高了
  1. from time import *  
  2. def orginal_algorithm(a,b,c):  #a^b%c  
  3.     ans=1  
  4.     a=a%c  #预处理,防止出现a比c大的情况  
  5.     for i in range(b):  
  6.         ans=(ans*a)%c  
  7.     return ans  
  8.   
  9. def quick_algorithm(a,b,c):  
  10.     a=a%c  
  11.     ans=1  
  12.     #这里我们不需要考虑b<0,因为分数没有取模运算  
  13.     while b!=0:  
  14.         if b&1:  
  15.             ans=(ans*a)%c  
  16.         b>>=1  
  17.         a=(a*a)%c  
  18.     return ans  
  19.   
  20. time=clock()  
  21. a=eval(input("底数:"))  
  22. b=eval(input("指数:"))  
  23. c=eval(input("模:"))  
  24. print("朴素算法结果%d"%(orginal_algorithm(a,b,c)))  
  25. print("朴素算法耗时:%f"%(clock()-time))  
  26. time=clock()  
  27. print("快速幂算法结果%d"%(quick_algorithm(a,b,c)))  
  28. print("快速幂算法耗时:%f"%(clock()-time))  
from time import *
def orginal_algorithm(a,b,c):  #a^b%c
    ans=1
    a=a%c  #预处理,防止出现a比c大的情况
    for i in range(b):
        ans=(ans*a)%c
    return ans

def quick_algorithm(a,b,c):
    a=a%c
    ans=1
    #这里我们不需要考虑b<0,因为分数没有取模运算
    while b!=0:
        if b&1:
            ans=(ans*a)%c
        b>>=1
        a=(a*a)%c
    return ans

time=clock()
a=eval(input("底数:"))
b=eval(input("指数:"))
c=eval(input("模:"))
print("朴素算法结果%d"%(orginal_algorithm(a,b,c)))
print("朴素算法耗时:%f"%(clock()-time))
time=clock()
print("快速幂算法结果%d"%(quick_algorithm(a,b,c)))
print("快速幂算法耗时:%f"%(clock()-time))
实验结果:
  1. 底数:5  
  2. 指数:1003  
  3. 模:12  
  4. 朴素算法结果5  
  5. 朴素算法耗时:3.289952  
  6. 快速幂算法结果5  
  7. 快速幂算法耗时:0.006706  
底数:5
指数:1003
模:12
朴素算法结果5
朴素算法耗时:3.289952
快速幂算法结果5
快速幂算法耗时:0.006706
我们现在知道了快速幂取模算法的强大了,我们现在来看核心原理:
  1. 对于任何一个整数的模幂运算  
  2. a^b%c  
  3. 对于b我们可以拆成二进制的形式  
  4. b=b0+b1*2+b2*2^2+...+bn*2^n  
  5. 这里我们的b0对应的是b二进制的第一位  
  6. 那么我们的a^b运算就可以拆解成  
  7. a^b0*a^b1*2*...*a^(bn*2^n)  
  8. 对于b来说,二进制位不是0就是1,那么对于bx为0的项我们的计算结果是1就不用考虑了,我们真正想要的其实是b的非0二进制位  
  9.   
  10. 那么假设除去了b的0的二进制位之后我们得到的式子是  
  11. a^(bx*2^x)*...*a(bn*2^n)  
  12. 这里我们再应用我们一开始提到的公式,那么我们的a^b%c运算就可以转化为  
  13. (a^(bx*2^x)%c)*...*(a^(bn*2^n)%c)  
  14. 这样的话,我们就很接近快速幂的本质了  
对于任何一个整数的模幂运算
a^b%c
对于b我们可以拆成二进制的形式
b=b0+b1*2+b2*2^2+...+bn*2^n
这里我们的b0对应的是b二进制的第一位
那么我们的a^b运算就可以拆解成
a^b0*a^b1*2*...*a^(bn*2^n)
对于b来说,二进制位不是0就是1,那么对于bx为0的项我们的计算结果是1就不用考虑了,我们真正想要的其实是b的非0二进制位

那么假设除去了b的0的二进制位之后我们得到的式子是
a^(bx*2^x)*...*a(bn*2^n)
这里我们再应用我们一开始提到的公式,那么我们的a^b%c运算就可以转化为
(a^(bx*2^x)%c)*...*(a^(bn*2^n)%c)
这样的话,我们就很接近快速幂的本质了
  1. (a^(bx*2^x)%c)*...*(a^(bn*2^n)%c)  
  2. 我们会发现令  
  3. A1=(a^(bx*2^x)%c)  
  4. ...  
  5. An=(a^(bn*2^n)%c)  
  6. 这样的话,An始终是A(n-1)的平方倍(当然加进去了取模匀速那),依次递推  
(a^(bx*2^x)%c)*...*(a^(bn*2^n)%c)
我们会发现令
A1=(a^(bx*2^x)%c)
...
An=(a^(bn*2^n)%c)
这样的话,An始终是A(n-1)的平方倍(当然加进去了取模匀速那),依次递推
现在,我们基本的内容都已经了解到了,现在我们来考虑实现它:
  1. int quick(int a,int b,int c)  
  2. {  
  3.     int ans=1;   //记录结果  
  4.     a=a%c;   //预处理,使得a处于c的数据范围之下  
  5.     while(b!=0)  
  6.     {  
  7.         if(b&1) ans=(ans*a)%c;   //如果b的二进制位不是0,那么我们的结果是要参与运算的  
  8.         b>>=1;    //二进制的移位操作,相当于每次除以2,用二进制看,就是我们不断的遍历b的二进制位  
  9.         a=(a*a)%c;   //不断的加倍  
  10.     }  
  11.     return ans;  
  12. }  
int quick(int a,int b,int c)
{
	int ans=1;   //记录结果
	a=a%c;   //预处理,使得a处于c的数据范围之下
	while(b!=0)
	{
		if(b&1) ans=(ans*a)%c;   //如果b的二进制位不是0,那么我们的结果是要参与运算的
		b>>=1;    //二进制的移位操作,相当于每次除以2,用二进制看,就是我们不断的遍历b的二进制位
		a=(a*a)%c;   //不断的加倍
	}
	return ans;
}

现在,我们的快速幂已经讲完了
我们来大致的推演一下快速幂取模算法的时间复杂度
首先,我们会观察到,我们每次都是将b的规模缩小了2倍
那么很显然,原本的朴素的时间复杂度是O(n)
快速幂的时间复杂度就是O(logn)无限接近常熟的时间复杂度无疑逼朴素的时间复杂度优秀很多,在数据量越大的时候,者中优化效果越明显

3.OJ例题

POJ1995
题意:
快速幂版题
  1. #include"iostream"  
  2. #include"cstdio"  
  3. #include"cstring"  
  4. #include"cstdlib"  
  5.   
  6. using namespace std;  
  7.   
  8. int ans=0;  
  9. int a,b;  
  10. int c;  
  11.   
  12. int quick(int a,int b,int c)  
  13. {  
  14.     int ans=1;  
  15.     a=a%c;  
  16.     while(b!=0)  
  17.     {  
  18.         if(b&1) ans=(ans*a)%c;  
  19.         b>>=1;  
  20.         a=(a*a)%c;  
  21.     }  
  22.     return ans;  
  23. }  
  24.   
  25. int main()  
  26. {  
  27.     int for_;  
  28.     int t;  
  29.     scanf("%d",&t);  
  30.     while(t--)  
  31.     {  
  32.         ans=0;  
  33.         scanf("%d%d",&c,&for_);  
  34.         for(int i=1;i<=for_;i++)  
  35.         {  
  36.             scanf("%d%d",&a,&b);  
  37.             ans=(ans+quick(a,b,c))%c;  
  38.         }  
  39.         printf("%d\n",ans);  
  40.     }  
  41.     return 0;  
  42. }  
阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭