LeetCode 50. Pow(x, n)

50. Pow(x, n)

题目：实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，x**n ）。
链接 https://leetcode.cn/problems/powx-n/

个人思路

1. 脑袋空空，只能想到暴力解法，超时了。。。

class Solution:
    def myPow(self, x: float, n: int) -> float:
        ans = 1
        if n >= 0:
            for i in range(n):
                ans = ans * x
        else:
            for i in range(0-n):
                ans = ans * x
            ans = 1 / ans
        return ans

2. 然后想到x^n = x^(n/2)* x^(n/2)，例如：2^32=2^16*2^16，对于奇数：2^33=2^16*2^16*2，有点类似与二分法，这里采用递归来实现：

class Solution:
    def myPow(self, x: float, n: int) -> float:
        if n >= 0:
            if n == 0:
                return 1
            if n == 1:
                return x
            if n % 2 == 1:
                return self.myPow(x*x,(n-1)/2)*x
            else:
                return self.myPow(x*x,n/2)
        else:
            if n == -1:
                return 1/x
            elif n % 2 == 1:
            # 注意这里还是n-1，因为在返回1/x时候会把前面递归的x乘起来，
            # 所以要用-1把n变小来抵消
                return self.myPow(x*x,(n-1)/2)*x
            else:
                return self.myPow(x*x,n/2)

注意：这里调用自身方法来递归时候要加self.method或者Solution().method否则递归时候不知道你调用的是哪个method从而报错

这里贴一个官方的快速幂 + 递归，写得真简洁：

class Solution:
    def myPow(self, x: float, n: int) -> float:
        def quickMul(N):
            if N == 0:
                return 1.0
            y = quickMul(N // 2)
            return y * y if N % 2 == 0 else y * y * x
        
        return quickMul(n) if n >= 0 else 1.0 / quickMul(-n)

复杂度分析

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

其他思路

1. 快速幂 + 迭代
   由于递归需要使用额外的栈空间，我们试着将递归转写为迭代。在方法一中，我们也提到过，从左到右进行推导是不容易的，因为我们不知道是否需要额外乘 x。
   个人看不大懂

class Solution:
    def myPow(self, x: float, n: int) -> float:
        def quickMul(N):
            ans = 1.0
            # 贡献的初始值为 x
            x_contribute = x
            # 在对 N 进行二进制拆分的同时计算答案
            while N > 0:
                if N % 2 == 1:
                    # 如果 N 二进制表示的最低位为 1，那么需要计入贡献
                    ans *= x_contribute
                # 将贡献不断地平方
                x_contribute *= x_contribute
                # 舍弃 N 二进制表示的最低位，这样我们每次只要判断最低位即可
                N //= 2
            return ans
        
        return quickMul(n) if n >= 0 else 1.0 / quickMul(-n)

时间复杂度：O(logn)，即为对 n 进行二进制拆分的时间复杂度。
空间复杂度：O(1)O(1)。

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/powx-n/solution/powx-n-by-leetcode-solution/