没错,乘法快速幂就是解决上述问题的。
乘法快速幂的思想
可以看到,要求一个数的 a a 的次幂,而且这个 n n 非常大,如果利用循环来处理,的时间复杂度对于计算机的处理速度来说是远远不够的;
循环既然不能满足要求,那我们能不能加速一下这个循环呢,比如 O(n)→O(logn) O ( n ) → O ( l o g n ) 的优化呢?
循环的做法是把这个式子展开:
然后从左到右依次相乘,最后得到结果。但是仔细一看可以知道:
按照循环的做法,当求出了 an2 a n 2 的时候,后面的 an2 a n 2 你也就知道了,不需要再计算了,但是循环的做法还是会计算,这也就导致了效率低下,没有用到之前的计算结果。
你是不是很快就会想到:在循环的做法中,当算出 a1 a 1 的时候马上就可以知道 a2 a 2 ,那么很快就可以知道 a4 a 4 ,……,没错,确实是这样,但是问题来了,这样的递增如何才能保证你刚好就算到了 an a n 。有可能你跨过了 an a n ,这些都是存在的;
出现上面这种情况是因为你用到了倍增的想法(这个想法可以用在快速幂的非递归实现中),从小到大,而如果把这个问题倒过来看:要求 an a n ,是不是要先求 an2 a n 2 ;要求 an2 a n 2 ,是不是要求 an4 a n 4 ,……,那么这里 n n 有可能是奇数,没关系啊,是奇数我们就把答案再多乘一个,即 a2k+1=ak×ak×a a 2 k + 1 = a k × a k × a 。这样最终我们要解决的问题就是 a0 a 0 , a0=1 a 0 = 1 啊,这么一说,乘法快速幂的递归写法是不是就呼之欲出了。
快速幂的高效
不过这里先说一下乘法快速幂的时间复杂度,由于递归版的乘法快速幂是基于二分递归的,因此时间复杂度为 O(logn) O ( l o g n ) ,那么在文首的那个背景下, n=10105,103≈210 n = 10 10 5 , 10 3 ≈ 2 10 ,即 logn≈106 l o g n ≈ 10 6 ,程序在1s能还是可以跑完的,不过用递归可能会爆栈。
快速幂的应用
通常,不会让你直接求
an
a
n
,因为数字太大了,计算机的int
乃至long long
都存不下,如果真让你求了,没办法,要么用JAVA的BigInteger
这个类,要么就自己写一个C++的大数模板。
一般都会对
an
a
n
进行取模,即
an(modm)=?
a
n
(
m
o
d
m
)
=
?
,然后这个
m
m
一般都是,这是为了把结果限制在int
的取值范围中,但是变量都申明为long long
类型的,这样是防止在做乘法的过程中结果超过int
的范围而导致数据丢失。由于乘法不受取模先后的影响,因此可以在递归的过程中就取模。
乘法快速幂的这种思想也应用在矩阵快速幂中,这个在博客深入浅出矩阵快速幂及其简单应用中有详细说明。
乘法快速幂的两种写法
乘法快速幂在互联网招聘的笔试中就有考察,例如迅雷2018秋招的第一道编程题,快手2018春招的第一道编程题就是裸的乘法快速幂。
递归
递归的写法刚在前面已经提到过了,递归的终点就是n == 0
,这个时候返回1
。
// 递归
long long mul(long long a, long long n, long long mod)
{
// a ^ 0 = 1
if (n == 0)
return 1LL;
// caculate a ^ (n / 2)
long long ret = mul(a, n / 2, mod);
ret = ret * ret % mod;
// select a or 1 by n % 2
return ret * (n & 1 ? a : 1) % mod;
}
非递归
现在回到文首一开始提到的循环做法,非递归版中确实需要计算 a0,a1,a2,⋯ a 0 , a 1 , a 2 , ⋯ 但是,如何把计算出来的这些东西凑成 an a n 呢?
我们把 n n 写成二进制试试,举个具体例子吧,。
没错,就是这么凑的,可以看到,通过二进制来分解 n n 从而计算的时间复杂度也是 O(logn) O ( l o g n ) 。
写法也呼之欲出了。就是:让
a
a
从往上增加,然后通过n
的二进制中的某一位k
来确定要不要把
ak
a
k
乘入结果。
这个思想和剑指Offer66题之每日6题 - 第八天中的第五题:求1+2+3+…+n 中的
最后这种方法我觉得也很好, a×b=(1010111⋯)2×b=b∗2n+b∗2n−2+⋯ a × b = ( 1010111 ⋯ ) 2 × b = b ∗ 2 n + b ∗ 2 n − 2 + ⋯ ;
就是把 a a 化成二进制,然后利用乘法的分配率进行计算,由于都是乘以2的幂次,故可以通过左移来代替乘法运算;之后再通过递归来累加这些乘积。
这个想法很类似,大家可以参照着看一下。
// 非递归
long long mul(long long a, long long n, long long mod)
{
long long ret = 1LL;
while (n > 0) {
// select a ^ k to ret by some bit of n
ret = ret * (n & 1 ? a : 1) % mod;
// change a ^ k to 2 ^ (2k)
a = a * a % mod;
n >>= 1;
}
return ret;
}
JAVA的BigInteger类
万一要是不记得写了,那么还有JAVA呢,BigInteger
的pow
函数的实现就是用了非递归版的乘法快速幂:
public BigInteger pow(int exponent) {
if (exponent < 0)
throw new ArithmeticException("Negative exponent");
if (signum == 0)
return (exponent == 0 ? ONE : this);
// Perform exponentiation using repeated squaring trick
int newSign = (signum < 0 && (exponent & 1) == 1 ? -1 : 1);
int[] baseToPow2 = this.mag;
int[] result = {1};
while (exponent != 0) {
if ((exponent & 1) == 1) {
result = multiplyToLen(result, result.length,
baseToPow2, baseToPow2.length, null);
result = trustedStripLeadingZeroInts(result);
}
if ((exponent >>>= 1) != 0) {
baseToPow2 = squareToLen(baseToPow2, baseToPow2.length, null);
baseToPow2 = trustedStripLeadingZeroInts(baseToPow2);
}
}
return new BigInteger(result, newSign);
}
里面七七八八的函数我也看不懂,不过思想就是乘法快速幂,用的是非递归版的实现,要是不会了,直接调用这个函数就是了。
BigInteger mul(BigInteger a, int n)
{
return a.pow(n);
}
如果还要取模,那么直接mul(a, n).mod(m)
就可以了。
不过这个BigInteger
的pow
有个缺点,它只接受int
型的参数,也就是说如果
n
n
一旦达到了long long
的范围,那么这个函数是不能用的,因此还是要掌握乘法快速幂的原理与写法,这样才能更好地解决问题。
总结
要么二分,要么二进制,总会从的。