Pow(x, n)

Leetcode地址：50. Pow(x, n) - 力扣（LeetCode） (leetcode-cn.com)

本题看着挺简单的，但是写出了两个超出递归深度的解法

1.naive的解法：直接递归。简单不表

2.分情况递归，超时算法如下所示：

时间复杂度：O（logn)

空间复杂度：O（logn)

class Solution(object):
    def myPow(self, x, n):
        """
        :type x: float
        :type n: int
        :rtype: float
        """
        if n==0:
            return 1
        elif n>0:
            return self.pow(x,n)
        else:
            return 1/self.pow(x,-n)
    
    def pow(self,x,n):
        if n==1:
            return x
        if n%2==0:
            return self.pow(x,n/2)*self.pow(x,n/2)
        else:
            return x*self.pow(x,n/2)*self.pow(x,n/2)

太惨了，很不简练。

本来是想分而治之，目标是O（logn)的时间复杂度，一不小心变成了 logn*logn

x^n=x^(n/2)*x^(n/2)=x^(2*n/2)=(x^2)^(n/2)，才是O(logn)

class Solution(object):
    def myPow(self, x, n):
        """
        :type x: float
        :type n: int
        :rtype: float
        """
        if n==1:
            return x
        if n<0:
            return 1/self.myPow(x,-n)
        if n%2:
            return x*self.myPow(x,n-1)
        return self.myPow(x*x,n/2)

然后就是说，还是会超出最大深度，因为测试用例有long的整数

所以俺想那整个循环吧，不要递归了

3.循环法

这里的二分就变成是 (x^(n/2))^2

class Solution(object):
    def myPow(self, x, n):
        """
        :type x: float
        :type n: int
        :rtype: float
        """
        mi=n if n>0 else -n
        res=1
        while mi>=1:
            if mi%2:
                res=res*x
            x=x*x
            mi=mi//2
        return res if n>0 else 1/res

时间复杂度：O（logn)

空间复杂度：O（1）

终于可以通过