leetcode刷题

1. 50 Pow(x, n)

# 暴力循环
class Solution1(object):
    def myPow(self, x, n):
        if n == 0:
            return 1
        if n < 0:
            x = 1 / x
            n = -n
        ans = 1
        res = 1
        while n:
            if n % 2:
                ans *= x
            n >>= 1
            x *= x
        return ans

# 分治法求解
class Solution2:
    def myPow(self, x: float, n: int) -> float:
        if n == 0:
            return 1
        if n == 1:
            return x
        if n < 0:
            n = -n
            half = self.myPow(x, n // 2)
            if n % 2 == 0:
                return 1 / (half * half)
            else:
                return 1 / (half * half * x)
        else:
            half = self.myPow(x, n // 2)
            if n % 2 == 0:
                return half * half
            else:
                return half * half * x

2. 53. 最大子序和

# 1. 自己的解题方法：
# 如果 之前的和大于0保留 并与当前值累加
# 如果 之前的和小于0 丢弃 只保留当前值
# 将 上述的值与最大值作比较保留最大的


class Solution1:
    def maxSubArray(self, nums):
        temp = max_ = nums[0]
        for i in range(1,len(nums)):
            # 若当前元素之前的和小于0，则丢弃当前元素之前的数列
            # 这一部分刚开始不理解 后来想想发现，确实与上述相同，因为加入当前元素之前的和大于0，那么其和当前元素的和必定大于当前元素。
            temp = max(nums[i],temp+nums[i])
            # 将当前值与最大值作比较 取最大。
            max_ = max(temp,max_)
        return max_


# 分治法
# 将其分两部分分析 要么 最大子序列在左边 要么最大子序列在右边 要么最大子序列在中间部分。
# 中间部分在进行 最大子序列求解 求出三个值 做对比求出 最大的。
class Solution2:
    def maxSubArray(self,nums):
        n = len(nums)
        # 递归终止条件
        if n == 1:
            return nums[0]
        else:
            # 递归计算左边
            max_left = self.maxSubArray(nums[0:len(nums) // 2])
            # 递归计算右遍
            max_right = self.maxSubArray(nums[len(nums) // 2:len(nums)])

        # 计算中间的最大子序列和
        max_l = nums[len(nums) // 2 - 1]
        tmp = 0
        for i in range(len(nums) // 2 - 1, -1, -1):
            tmp += nums[i]
            max_l = max(tmp, max_l)
        max_r = nums[len(nums) // 2]
        tmp = 0
        for i in range(len(nums) // 2, len(nums)):
            tmp += nums[i]
            max_r = max(tmp, max_r)
        # 返回三个中的最大值
        return max(max_right, max_left, max_l + max_r)

3. 多数元素

# 分治法：把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……
# 直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。
# 将问题分解为子问题并递归地解决它们(这就是最最重要的部分)。
# 合并子问题的解以获得原始问题的解。

# 方法1 通过 统计频次计算超过 ⌊ n/2 ⌋ 的元素
class Solution:
    def majorityElement(self, nums):
        numDict = {}
        n = len(nums)
        for i in nums:
            numDict[i] = numDict.get(i, 0) + 1
        for key in numDict.keys():
            if numDict[key] > n/2:
                return key

# 方法2 通过 分治法
class Solution2:
    def majorityElement(self, nums):
        return self.findNum(nums)

    def findNum(self, nums):
        if len(nums) == 1: return nums[0]
        mid = len(nums) // 2
        left_num = self.findNum(nums[0:mid])
        right_num = self.findNum(nums[mid:])
        if left_num != right_num:
            return left_num if nums.count(left_num) >= nums.count(right_num) else right_num
        else:
            return left_num