完全理解乘法快速幂及其两种写法的解析

                         

没错，乘法快速幂就是解决上述问题的。

乘法快速幂的思想

可以看到，要求一个数的aa的nn次幂，而且这个nn非常大，如果利用循环来处理，O(n)O(n)的时间复杂度对于计算机的处理速度来说是远远不够的；

循环既然不能满足要求，那我们能不能加速一下这个循环呢，比如O(n)→O(logn)O(n)→O(logn)的优化呢？

循环的做法是把这个式子展开：

an=a×a×⋯anan=a×a×⋯a⏟n

然后从左到右依次相乘，最后得到结果。但是仔细一看可以知道： 

an=a×a×⋯an2×a×a×⋯an2×(a|1)=an2×an2×(a|1)an=a×a×⋯a⏟n2×a×a×⋯a⏟n2×(a|1)=an2×an2×(a|1)

按照循环的做法，当求出了an2an2的时候，后面的an2an2你也就知道了，不需要再计算了，但是循环的做法还是会计算，这也就导致了效率低下，没有用到之前的计算结果。

你是不是很快就会想到：在循环的做法中，当算出a1a1的时候马上就可以知道a2a2，那么很快就可以知道a4a4，……，没错，确实是这样，但是问题来了，这样的递增如何才能保证你刚好就算到了anan。有可能你跨过了anan，这些都是存在的；

出现上面这种情况是因为你用到了倍增的想法(这个想法可以用在快速幂的非递归实现中)，从小到大，而如果把这个问题倒过来看：要求anan，是不是要先求an2an2；要求an2an2，是不是要求an4an4，……，那么这里nn有可能是奇数，没关系啊，是奇数我们就把答案再多乘一个aa，即a2k+1=ak×ak×aa2k+1=ak×ak×a。这样最终我们要解决的问题就是a0a0，a0=1a0=1啊，这么一说，乘法快速幂的递归写法是不是就呼之欲出了。

快速幂的高效

不过这里先说一下乘法快速幂的时间复杂度，由于递归版的乘法快速幂是基于二分递归的，因此时间复杂度为O(logn)O(logn)，那么在文首的那个背景下，n=10105，103≈210n=10105，103≈210，即logn≈106logn≈106，程序在1s能还是可以跑完的，不过用递归可能会爆栈。

快速幂的应用

通常，不会让你直接求anan，因为数字太大了，计算机的int乃至long long都存不下，如果真让你求了，没办法，要么用JAVA的BigInteger这个类，要么就自己写一个C++的大数模板。

一般都会对anan进行取模，即an(modm)=?an(modm)=?，然后这个mm一般都是10e9+710e9+7，这是为了把结果限制在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,⋯a0,a1,a2,⋯但是，如何把计算出来的这些东西凑成anan呢？

我们把nn写成二进制试试，举个具体例子吧，n=13=(1101)2n=13=(1101)2。

an=a13=a1101=a23×a22×a20=a8×a4×a1an=a13=a1101=a23×a22×a20=a8×a4×a1

没错，就是这么凑的，可以看到，通过二进制来分解nn从而计算anan的时间复杂度也是O(logn)O(logn)。

写法也呼之欲出了。就是：让aa从a0,a1,a2,⋯a0,a1,a2,⋯往上增加，然后通过n的二进制中的某一位k来确定要不要把akak乘入结果。

这个思想和剑指Offer66题之每日6题 - 第八天中的第五题：求1+2+3+…+n 中的

最后这种方法我觉得也很好，a×b=(1010111⋯)2×b=b∗2n+b∗2n−2+⋯a×b=(1010111⋯)2×b=b∗2n+b∗2n−2+⋯；

就是把aa化成二进制，然后利用乘法的分配率进行计算，由于bb都是乘以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型的参数，也就是说如果nn一旦达到了long long的范围，那么这个函数是不能用的，因此还是要掌握乘法快速幂的原理与写法，这样才能更好地解决问题。

总结

要么二分，要么二进制，总会从O(n)→O(logn)O(n)→O(logn)的。