【求x的n次幂，快速幂，递归分治思想 & 二进制解法】

题目：力扣https://leetcode.cn/problems/powx-n/description/

实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，x^n ）。

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：

输入：x = 2.10000, n = 3
输出：9.26100
示例 3：

输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25

提示：

-100.0 < x < 100.0
-231 <= n <= 231-1
n 是一个整数
要么 x 不为零，要么 n > 0 。
-104 <= x^n <= 104

快速幂

快速幂（Exponentiation by squaring，平方求幂）是一种简单而有效的小算法，它可以 O(logn) 的时间复杂度计算乘方。快速幂不仅本身非常常见，而且后续很多算法也都会用到快速幂。

关于快速幂的算法面试与日常题目，简直不要太多，一个知识点变着法的考你，但这个知识点很难？真不难…让我们先了解快速幂的实现思想，再来结合知识进一步的刷题吧！

举个例子，日常生活中，我们要计算3的10次方如何算？

Java :

class Solution {
    public static void main(String[] args) {
//        内置函数
        System.out.println((int)Math.pow(3, 10));
//        循环相乘
        int ret = 1;
        for (int i = 0; i < 10; i++)
            ret *= 3;
        System.out.println(ret);
    }
}

抛开内置函数，我们通过循环来实现x ^ y 的时间复杂度是多少？ O(n)

数量级小的情况下，我们可能看不出太多东西，那换个用例，比如我是夜店小王子，我要求857857的百万次方又该如何操作呢？怕溢出，没关系，上面告诉你取模的方法和常数了，我就是任性要求857857的百万次，来吧展示。

按照上面的循环，我们需要计算 O(n) 的时间复杂度，即一百万次。有没有办法优化呢？这里就需要引出我们的快速幂操作了。

分治思想

快速幂是如何在 O(logn) 的时间复杂度完成幂的计算呢？这里需要介绍下 分治思想 ，所为分治就是分而治之。

比如我们要计算x的y次方。
通常情况我们需要执行y次。
但是如果我们将其转化为(x*x) ^ (y/2)就只需要执行一半的时间了，
那么如果是()(x*x) \* (x*x)) ^ (y/2/2)就只用四分之一的时间了，
好家伙我直呼好家伙这不就是 O(logn) 的方式么。
但这里有一个问题，你怎么知道y能一直被二整除呢？
如果不能被整除怎么办？举个大家都会举的例子，
计算3 ^ 10，第一次转化为了9 ^ 5 但下一次5/2不够除该怎么办？
转化为（9\^4）\*（9^1），即：

3^10=3*3*3*3*3*3*3*3*3*3
3^10=(3*3)*(3*3)*(3*3)*(3*3)*(3*3)
3^10=(3*3)^5
3^10=9^5
9^5=（9^4）*（9^1）
9^5=（9^4）*（9^1）
9^5=（6561^1）*(9^1)

思路理解了，下来就看该如何实现了。

通过上面的分治思想，我们可以很轻易的想到递归的实现方法，来看看吧：
Java:

public int quickPow(int x, int y) {
    if (y == 0) {
        return 1;
    }
    int ret = quickPow(x, y / 2);
    return y % 2 == 0 ? ret * ret : ret * ret * x;
}

循环快速幂

递归快速取模的算法思想没有问题，但是在递归的过程中，会使用很多额外的栈空间，是否存在一种办法，能通过迭代的循环方式完成，而非递归实现呢？

答案当然是有的。我们只需要判断什么时候指数不能被2整除，则单独乘以底数，否则就将当前的数值平方即可。那么如何判断当前的指数是否能被2整除呢？使用y对2取模？不不不，我们来学习一下二进制与操作吧！

思路很简单：当一个数 & 1若为1，即该数的最后一位为1，不能被2整除，否则代表可以被2整数。

10:     00001010
1 :     00000001
按位与  00000000
-----------------
9:      00001001
1:      00000001
按位与  00000001

最终代码为：

Java：

public int quickPow(int x, int y) {
    int ret = 1;
    while(y != 0){
        if((y & 1) != 0) {
            ret = ret * x;
        }
        x = x * x;
        y >>= 1;
    }
    return ret;
}

上面的两种方法，着重在于讲解快速幂的实现，但是Java的朋友们会说了，使用int类型不是轻轻松松就内存溢出了…

所以，我们可以看下Java的pow就是使用的double类型。

下面来看代码实现求x的n次幂的两种方法。

递归解题

class Solution {
    public double myPow(double x, int n) {
        long N = n;
        return N >= 0 ? quickPow(x, N) : 1.0 / quickPow(x, -N);
    }

    public double  quickPow(double  x, long y) {
        if (y == 0) {
            return 1.0;
        }
        double ret = quickPow(x, y / 2);
        return y % 2 == 0 ? ret * ret : ret * ret * x;
    }
}

二进制解题

class Solution {
    public double myPow(double x, int n) {
        long N = n;
        return N >= 0 ? quickPow(x, N) : 1.0 / quickPow(x, -N);
    }

    public double quickPow(double x, long y) {
        double ret = 1.0;
        while(y != 0){
            if((y & 1) != 0) {
                ret = ret * x;
            }
            x = x * x;
            y >>= 1;
        }
        return ret;
    }
}

作者：清风Python
链接：https://leetcode.cn/problems/powx-n/solutions/944540/50-powx-n-kuai-su-mi-de-ji-chu-zhi-shi-d-z7ny/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。