Every day a Leetcode

题目来源：50. Pow(x, n)

解法1：递归

代码：

/*
 * @lc app=leetcode.cn id=50 lang=cpp
 *
 * [50] Pow(x, n)
 */

// @lc code=start
class Solution
{
public:
    double myPow(double x, int n)
    {
        if (n == 0)
            return 1.0;
        if (n < 0)
            return myPow(1.0 / x, abs(n));
        return x * myPow(x, n - 1);
    }
};
// @lc code=end

结果：超时

复杂度分析：

时间复杂度：O(n)，即为递归的层数。

空间复杂度：O(n)，即为递归的层数。这是由于递归的函数调用会使用栈空间。

解法2：快速幂 + 递归

「快速幂算法」的本质是分治算法。举个例子，如果我们要计算 x⁶⁴，我们可以按照：

x → x² → x⁴ → x⁸ → x¹⁶ → x³² → x⁶⁴

的顺序，从 x 开始，每次直接把上一次的结果进行平方，计算 6 次就可以得到 x⁶⁴ 的值，而不需要对 x 乘 63 次 x。

再举一个例子，如果我们要计算 x⁷⁷ ，我们可以按照：

x → x² → x⁴ → x⁹ → x¹⁹ → x³⁸ → x⁷⁷

的顺序。在x → x²、x² → x⁴、x¹⁹ → x³⁸ 这些步骤中，我们直接把上一次的结果进行平方，而在 x⁴ → x⁹、x⁹ → x¹⁹、x³⁸ → x⁷⁷ 这些步骤中，我们把上一次的结果进行平方后，还要额外乘一个 x。

直接从左到右进行推导看上去很困难，因为在每一步中，我们不知道在将上一次的结果平方之后，还需不需要额外乘 x。但如果我们从右往左看，分治的思想就十分明显了：

• 当我们要计算 xⁿ 时，我们可以先递归地计算出 y = x^⌊n/2⌋
• 根据递归计算的结果，如果 n 为偶数， xⁿ = y²；如果 n 为奇数， xⁿ = y² * x；
• 递归的边界为 n = 0，任意数的 0 次方均为 1。

由于每次递归都会使得指数减少一半，因此递归的层数为 O(logn)，算法可以在很快的时间内得到结果。

代码：

/*
 * @lc app=leetcode.cn id=50 lang=cpp
 *
 * [50] Pow(x, n)
 */

// @lc code=start
class Solution
{
public:
    double quickMul(double x, int n)
    {
        if (n == 0)
            return 1.0;
        double y = quickMul(x, n / 2);
        if (n % 2 == 0)
            return y * y;
        else
            return y * y * x;
    }
    double myPow(double x, int n)
    {
        if (n >= 0)
            return quickMul(x, n);
        else
            return quickMul(1.0 / x, abs(n));
    }
};
// @lc code=end

结果：

复杂度分析：

时间复杂度：O(logn)，即为递归的层数。

空间复杂度：O(logn)，即为递归的层数。这是由于递归的函数调用会使用栈空间。