引出问题
在计算机科学中,幂运算是一种非常常见且基础的操作,尤其是在涉及到大数运算时,幂运算的效率对整个计算过程至关重要。设想以下场景:
- 在加密算法中,如 RSA 算法,常常需要计算大数的幂,且这种计算必须在一定时间内完成,以确保安全性。
- 在数值计算中,我们可能需要反复进行大规模的幂运算,如果采用最直接的计算方法,其计算量和时间将非常庞大。
如果我们采用朴素的计算方法,例如计算 a b a^b ab 时,通过不断相乘 a a a 来获得结果,其时间复杂度为 O ( b ) O(b) O(b)。当 b b b非常大时,这种方法显然是不可行的。为此,我们需要一种更加高效的算法来解决这个问题,快速幂算法就是这样一种高效的算法。
快速幂算法原理
快速幂算法的核心思想是通过将幂指数拆分为二进制形式,并通过一系列的乘法和平方操作,来高效地计算幂次。它主要依赖两个关键概念:
二进制拆分
任何一个整数 ( b ) 都可以表示为一系列二进制位的组合,即:
b
=
b
k
×
2
k
+
b
k
−
1
×
2
k
−
1
+
⋯
+
b
1
×
2
1
+
b
0
×
2
0
b = b_k \times 2^k + b_{k-1} \times 2^{k-1} + \cdots + b_1 \times 2^1 + b_0 \times 2^0
b=bk×2k+bk−1×2k−1+⋯+b1×21+b0×20其中
b
i
b_i
bi为二进制位(0或1)。通过这一表示,可以将幂运算转化为多个乘法和平方操作。
举例说明
假设我们要计算 ( 3^{13} ),首先我们将 13 表示为二进制形式,即 ( 13 = 1101_2 )。根据二进制拆分的原则,我们可以将幂运算拆解为:
3
13
=
3
(
1
×
2
3
+
1
×
2
2
+
0
×
2
1
+
1
×
2
0
)
=
3
8
×
3
4
×
3
0
×
3
1
3^{13} = 3^{(1 \times 2^3 + 1 \times 2^2 + 0 \times 2^1 + 1 \times 2^0)} = 3^{8} \times 3^{4} \times 3^{0} \times 3^{1}
313=3(1×23+1×22+0×21+1×20)=38×34×30×31这种拆分将幂运算转化为多次乘法和平方操作,虽然差拆分后的项也是幂,但是这些项彼此之间也是有关系的,可以用较小的计算量算出,因此有助于提高计算效率。
霍纳法则
霍纳法则是一种高效计算多项式的方法,能够有效减少乘法运算次数。在快速幂算法中,霍纳法则可以帮助我们进一步简化幂运算的过程。我们可以将幂指数的二进制表示进行逐步计算,而不是一次性完成。根据霍纳法则,了可以进一步变换成
b
=
(
(
…
(
b
k
×
2
1
+
b
k
−
1
)
×
2
+
⋯
)
×
2
+
b
1
)
×
2
+
b
0
b =(( \dots (b_k \times 2^1 + b_{k-1}) \times 2 + \cdots )\times 2 + b_1) \times 2 + b_0
b=((…(bk×21+bk−1)×2+⋯)×2+b1)×2+b0那么就有
a
b
=
a
(
(
…
(
b
k
×
2
1
+
b
k
−
1
)
×
2
+
⋯
)
×
2
+
b
1
)
×
2
+
b
0
=
(
⋯
(
(
a
b
k
)
2
×
a
b
k
−
1
)
2
×
⋯
×
a
b
1
)
2
×
a
b
0
a^b =a^{(( \dots (b_k \times 2^1 + b_{k-1}) \times 2 + \cdots )\times 2 + b_1) \times 2 + b_0}=( \cdots((a^{b_k})^2 \times a^{b_{k-1}})^2 \times \cdots \times a^{b_1})^2 \times a^{b_0}
ab=a((…(bk×21+bk−1)×2+⋯)×2+b1)×2+b0=(⋯((abk)2×abk−1)2×⋯×ab1)2×ab0
从左到右的快速幂算法
从左到右的快速幂算法也就是刚才通过霍纳法则导出来的公式
通过依次读取幂指数 b b b的二进制表示,从高位到低位逐步构建幂运算的结果。在每读取一位时,首先将当前的结果进行平方,然后根据该位是否为1来决定是否乘以基数 a a a。这种方式避免了重复计算,使得时间复杂度降低到 O ( log b ) O(\log b) O(logb)。
算法步骤
- 初始化结果为1。
- 从左到右扫描 b b b的二进制表示(从最高位到最低位)。
- 对于每一位:
- 先将当前结果平方。
- 如果该位为1,则结果乘以基数 a a a。
- 最终的结果即为 a b a^b ab。
代码实现
def quick_pow_from_left_to_right(a, b):
b = bin(b)[2:] # 将整数b转换为二进制字符串,并去除前缀'0b'
ans = 1 # 初始化答案为1,因为幂次最低为0,任何数的0次幂都是1
for b_i in b: # 遍历b的二进制表示中的每一位
ans *= ans # 每遇到一个二进制位,都需要平方之前的结果
if b_i == '1': # 如果当前二进制位是1,则需要将a累乘到答案中
ans *= a
return ans # 返回最终的计算结果
运行原理
假设 ( b = 13 )(即二进制表示为 1101),我们想计算 ( 3^{13} )。从左到右读取其二进制表示:
- 第1位是1,结果先平方,再乘以 ( a )。
- 第2位是1,结果再平方,再乘以 ( a )。
- 第3位是0,结果只平方,不乘以 ( a )。
- 第4位是1,结果再平方,再乘以 ( a )。
bit | 1 | 1 | 0 | 1 |
---|---|---|---|---|
结果 | a 1 a^1 a1 | a 3 a^3 a3 | a 6 a^6 a6 | a 13 a^{13} a13 |
从右到左的快速幂算法
与从左到右的算法不同,从右到左的算法从幂指数的最低位开始读取二进制位。每次读取一位后,决定是否将当前的基数乘到结果上,然后将基数平方,为下一次迭代做准备。这个过程是直接利用了二进制拆分的公式,所以理解起来非常的直观
算法步骤
-
初始化结果为1,当前基数为 a a a。
-
从右到左扫描 b b b的二进制表示(从最低位到最高位)。
-
对于每一位:
- 如果该位为1,将当前基数乘到结果上。
- 将基数平方。
-
最终的结果即为 a b a^b ab。
代码实现
def quick_pow_from_right_to_left(a, b):
b = reversed(bin(b)[2:]) # 将整数b转换为反转二进制字符串,并去除前缀'0b'
ans = 1 # 初始化答案为1,即a的0次方
for b_i in b: # 遍历b的二进制每一位
if b_i == '1': # 如果当前位为1,将当前结果与a的平方累乘
ans *= a
a *= a # 每遍历一位,将底数a平方
return ans # 返回计算结果
运行原理
同样以 b = 13 b = 13 b=13(二进制为1101)为例,从右到左的计算步骤如下:
- 第1位是1,结果乘以 a a a,基数平方。
- 第2位是0,基数平方。
- 第3位是1,结果乘以平方后的基数,基数平方。
- 第4位是1,结果再乘以平方后的基数,最终得到结果。
bit | 1 | 1 | 0 | 1 |
---|---|---|---|---|
结果 | a 13 a^{13} a13 | a 5 a^5 a5 | a 1 a^1 a1 | a 1 a^1 a1 |
复杂度分析
快速幂算法的时间复杂度为 O ( log b ) O(\log b) O(logb),无论是从左到右还是从右到左。相比于朴素的 O ( b ) O(b) O(b)复杂度,这种方法在处理大幂次计算时显著提高了效率。
我将几种方法放在一起进行一个对比
a = 2
b = 1000000
import time
print('从左到右快速幂')
t = time.time()
quick_pow_from_left_to_right(a, b)
print(time.time() - t)
print('从右到左快速幂')
t = time.time()
quick_pow_from_right_to_left(a, b)
print(time.time() - t)
print('朴素幂')
t = time.time()
a ** b # 假设有一个pow_函数实现朴素幂运算
print(time.time() - t)
print('库函数')
t = time.time()
pow(a, b)
print(time.time() - t)
运行结果如下:
从左到右快速幂
0.0029942989349365234
从右到左快速幂
0.005053997039794922
朴素幂
18.3477623462677
库函数
0.0029935836791992188
可以发现在大指数时,快速幂的效果非常明显,并且根据运行时间推断,python内置的 pow
函数应该也是快速幂算法的变种。
总结
快速幂算法通过将幂次的二进制表示与逐步的平方、乘法操作结合起来,实现了高效的幂运算。无论是从左到右还是从右到左的实现,都大大减少了计算所需的时间,特别是在需要处理大数幂运算的场景下。掌握这种算法,对提升计算效率具有重要意义。