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

$$a^n=? \qquad 0 \le n \le 10^{10^5}$$
没错，乘法快速幂就是解决上述问题的。

乘法快速幂的思想

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

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

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

$$\begin{equation*}a^n=\underbrace{a\times a\times \cdots a }_{n}\end{equation*}$$

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

$$\begin{equation*} \begin{array} &a^{n} &=\underbrace{a\times a\times \cdots a }_{\frac{n}{2}}\times \underbrace{a\times a\times \cdots a }_{\frac{n}{2}}\times (a|1)\\ &=a^{\frac{n}{2}}\times a^{\frac{n}{2}}\times (a|1) \end{array} \end{equation*}$$

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

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

出现上面这种情况是因为你用到了倍增的想法(这个想法可以用在快速幂的非递归实现中)，从小到大，而如果把这个问题倒过来看：要求$a^n$，是不是要先求$a^{\frac{n}{2}}$；要求$a^{\frac{n}{2}}$，是不是要求$a^{\frac{n}{4}}$，……，那么这里$n$有可能是奇数，没关系啊，是奇数我们就把答案再多乘一个$a$，即$a^{2k+1}=a^k\times a^k \times a$。这样最终我们要解决的问题就是$a^0$，$a^0=1$啊，这么一说，乘法快速幂的递归写法是不是就呼之欲出了。

快速幂的高效

不过这里先说一下乘法快速幂的时间复杂度，由于递归版的乘法快速幂是基于二分递归的，因此时间复杂度为$O(logn)$，那么在文首的那个背景下，$n=10^{10^5}，10^3\approx 2^{10}$，即$logn\approx 10^6$，程序在1s能还是可以跑完的，不过用递归可能会爆栈。

快速幂的应用

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

一般都会对$a^n$进行取模，即$a^n(mod\quad m)=?$，然后这个$m$一般都是$10e9 + 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;
}

非递归

现在回到文首一开始提到的循环做法，非递归版中确实需要计算$a^0, a^1, a^2,\cdots$但是，如何把计算出来的这些东西凑成$a^n$呢？

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

$$a^n=a^{13}=a^{1101}=a^{2^3}\times a^{2^2}\times a^{2^0}=a^{8}\times a^{4}\times a^{1}$$

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

写法也呼之欲出了。就是：让$a$从$a^0, a^1, a^2,\cdots$往上增加，然后通过n的二进制中的某一位k来确定要不要把$a^k$乘入结果。

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

最后这种方法我觉得也很好，$a\times b=(1010111\cdots)_2\times b=b*2^n+b*2^{n-2}+\cdots$；

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

总结

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